index/zlogs.c

   1 /*
   2  * Copyright (C) 1995-1998, Index Data I/S
   3  * All rights reserved.
   4  * Sebastian Hammer, Adam Dickmeiss
   5  *
   6  * $Log: zlogs.c,v $
   7  * Revision 1.9  1998-10-13 20:36:02  adam
   8  * Changed "indent" format string in log messages.
   9  *
  10  * Revision 1.8  1998/04/02 14:35:29  adam
  11  * First version of Zebra that works with compiled ASN.1.
  12  *
  13  * Revision 1.7  1998/01/29 13:40:11  adam
  14  * Better logging for scan service.
  15  *
  16  * Revision 1.6  1997/09/29 09:06:41  adam
  17  * Removed static var to make this module thread safe.
  18  *
  19  * Revision 1.5  1997/04/30 08:56:07  quinn
  20  * null
  21  *
  22  * Revision 1.4  1996/10/08  09:41:25  quinn
  23  * Fixed diagnostic.
  24  *
  25  * Revision 1.3  1996/03/20  09:36:40  adam
  26  * Function dict_lookup_grep got extra parameter, init_pos, which marks
  27  * from which position in pattern approximate pattern matching should occur.
  28  * Approximate pattern matching is used in relevance=re-2.
  29  *
  30  * Revision 1.2  1996/01/03  16:22:11  quinn
  31  * operator->roperator
  32  *
  33  * Revision 1.1  1995/11/16  17:00:55  adam
  34  * Better logging of rpn query.
  35  *
  36  */
  37 #include <stdio.h>
  38 #include <assert.h>
  39
  40 #include "zserver.h"
  41
  42 static void attrStr (int type, int value, enum oid_value ast, char *str)
  43 {
  44     *str = '\0';
  45     switch (ast)
  46     {
  47     case VAL_BIB1:
  48     case VAL_EXP1:
  49     case VAL_GILS:
  50         switch (type)
  51         {
  52         case 1:
  53             sprintf (str, "use");
  54             break;
  55         case 2:
  56             switch (value)
  57             {
  58             case 1:
  59                 sprintf (str, "relation=Less than");
  60                 break;
  61             case 2:
  62                 sprintf (str, "relation=Less than or equal");
  63                 break;
  64             case 3:
  65                 sprintf (str, "relation=Equal");
  66                 break;
  67             case 4:
  68                 sprintf (str, "relation=Greater or equal");
  69                 break;
  70             case 5:
  71                 sprintf (str, "relation=Greater than");
  72                 break;
  73             case 6:
  74                 sprintf (str, "relation=Not equal");
  75                 break;
  76             case 100:
  77                 sprintf (str, "relation=Phonetic");
  78                 break;
  79             case 101:
  80                 sprintf (str, "relation=Stem");
  81                 break;
  82             case 102:
  83                 sprintf (str, "relation=Relevance");
  84                 break;
  85             case 103:
  86                 sprintf (str, "relation=AlwaysMatches");
  87                 break;
  88             default:
  89                 sprintf (str, "relation");
  90             }
  91             break;
  92         case 3:
  93             switch (value)
  94             {
  95             case 1:
  96                 sprintf (str, "position=First in field");
  97                 break;
  98             case 2:
  99                 sprintf (str, "position=First in any subfield");
 100                 break;
 101             case 3:
 102                 sprintf (str, "position=Any position in field");
 103                 break;
 104             default:
 105                 sprintf (str, "position");
 106             }
 107             break;
 108         case 4:
 109             switch (value)
 110             {
 111             case 1:
 112                 sprintf (str, "structure=Phrase");
 113                 break;
 114             case 2:
 115                 sprintf (str, "structure=Word");
 116                 break;
 117             case 3:
 118                 sprintf (str, "structure=Key");
 119                 break;
 120             case 4:
 121                 sprintf (str, "structure=Year");
 122                 break;
 123             case 5:
 124                 sprintf (str, "structure=Date");
 125                 break;
 126             case 6:
 127                 sprintf (str, "structure=Word list");
 128                 break;
 129             case 100:
 130                 sprintf (str, "structure=Date (un)");
 131                 break;
 132             case 101:
 133                 sprintf (str, "structure=Name (norm)");
 134                 break;
 135             case 102:
 136                 sprintf (str, "structure=Name (un)");
 137                 break;
 138             case 103:
 139                 sprintf (str, "structure=Structure");
 140                 break;
 141             case 104:
 142                 sprintf (str, "structure=urx");
 143                 break;
 144             case 105:
 145                 sprintf (str, "structure=free-form-text");
 146                 break;
 147             case 106:
 148                 sprintf (str, "structure=document-text");
 149                 break;
 150             case 107:
 151                 sprintf (str, "structure=local-number");
 152                 break;
 153             case 108:
 154                 sprintf (str, "structure=string");
 155                 break;
 156             case 109:
 157                 sprintf (str, "structure=numeric string");
 158                 break;
 159             default:
 160                 sprintf (str, "structure");
 161             }
 162             break;
 163         case 5:
 164             switch (value)
 165             {
 166             case 1:
 167                 sprintf (str, "truncation=Right");
 168                 break;
 169             case 2:
 170                 sprintf (str, "truncation=Left");
 171                 break;
 172             case 3:
 173                 sprintf (str, "truncation=Left&right");
 174                 break;
 175             case 100:
 176                 sprintf (str, "truncation=Do not truncate");
 177                 break;
 178             case 101:
 179                 sprintf (str, "truncation=Process #");
 180                 break;
 181             case 102:
 182                 sprintf (str, "truncation=re-1");
 183                 break;
 184             case 103:
 185                 sprintf (str, "truncation=re-2");
 186                 break;
 187             default:
 188                 sprintf (str, "truncation");
 189             }
 190             break;
 191         case 6:
 192             switch (value)
 193             {
 194             case 1:
 195                 sprintf (str, "completeness=Incomplete subfield");
 196                 break;
 197             case 2:
 198                 sprintf (str, "completeness=Complete subfield");
 199                 break;
 200             case 3:
 201                 sprintf (str, "completeness=Complete field");
 202                 break;
 203             default:
 204                 sprintf (str, "completeness");
 205             }
 206             break;
 207         }
 208         break;
 209     default:
 210         break;
 211     }
 212     if (*str)
 213         sprintf (str + strlen(str), " (%d=%d)", type, value);
 214     else
 215         sprintf (str, "%d=%d", type, value);
 216 }
 217
 218 /*
 219  * zlog_attributes: print attributes of term
 220  */
 221 static void zlog_attributes (Z_AttributesPlusTerm *t, int level,
 222                              enum oid_value ast)
 223 {
 224     int of, i;
 225     char str[80];
 226 #ifdef ASN_COMPILED
 227     int num_attributes = t->attributes->num_attributes;
 228 #else
 229     int num_attributes = t->num_attributes;
 230 #endif
 231
 232     for (of = 0; of < num_attributes; of++)
 233     {
 234         Z_AttributeElement *element;
 235 #ifdef ASN_COMPILED
 236         element = t->attributes->attributes[of];
 237 #else
 238         element = t->attributeList[of];
 239 #endif
 240
 241         switch (element->which)
 242         {
 243         case Z_AttributeValue_numeric:
 244             attrStr (*element->attributeType,
 245                      *element->value.numeric, ast, str);
 246             logf (LOG_LOG, "%*.0s %s", level, "", str);
 247             break;
 248         case Z_AttributeValue_complex:
 249             logf (LOG_LOG, "%*.0s attributeType=%d complex", level, "",
 250                   *element->attributeType);
 251             for (i = 0; i<element->value.complex->num_list; i++)
 252             {
 253                 if (element->value.complex->list[i]->which ==
 254                     Z_StringOrNumeric_string)
 255                     logf (LOG_LOG, "%*.0s  string: '%s'", level, "",
 256                           element->value.complex->list[i]->u.string);
 257                 else if (element->value.complex->list[i]->which ==
 258                          Z_StringOrNumeric_numeric)
 259                     logf (LOG_LOG, "%*.0s  numeric: '%d'", level, "",
 260                           *element->value.complex->list[i]->u.numeric);
 261             }
 262             break;
 263         default:
 264             logf (LOG_LOG, "%.*s attribute unknown", level, "");
 265         }
 266     }
 267 }
 268
 269 static void zlog_structure (Z_RPNStructure *zs, int level, enum oid_value ast)
 270 {
 271     if (zs->which == Z_RPNStructure_complex)
 272     {
 273         switch (zs->u.complex->roperator->which)
 274         {
 275         case Z_Operator_and:
 276             logf (LOG_LOG, "%*.0s and", level, "");
 277             break;
 278         case Z_Operator_or:
 279             logf (LOG_LOG, "%*.0s or", level, "");
 280             break;
 281         case Z_Operator_and_not:
 282             logf (LOG_LOG, "%*.0s and-not", level, "");
 283             break;
 284         default:
 285             logf (LOG_LOG, "%*.0s unknown complex", level, "");
 286             return;
 287         }
 288         zlog_structure (zs->u.complex->s1, level+2, ast);
 289         zlog_structure (zs->u.complex->s2, level+2, ast);
 290     }
 291     else if (zs->which == Z_RPNStructure_simple)
 292     {
 293         if (zs->u.simple->which == Z_Operand_APT)
 294         {
 295             Z_AttributesPlusTerm *zapt = zs->u.simple->u.attributesPlusTerm;
 296
 297             if (zapt->term->which == Z_Term_general)
 298             {
 299                 logf (LOG_LOG, "%*.0s term '%.*s' (general)", level, "",
 300                       zapt->term->u.general->len, zapt->term->u.general->buf);
 301             }
 302             else
 303             {
 304                 logf (LOG_LOG, "%*.0s term (not general)", level, "");
 305             }
 306             zlog_attributes (zapt, level+2, ast);
 307         }
 308         else if (zs->u.simple->which == Z_Operand_resultSetId)
 309         {
 310             logf (LOG_LOG, "%*.0s set '%s'", level, "",
 311                   zs->u.simple->u.resultSetId);
 312         }
 313         else
 314             logf (LOG_LOG, "%*.0s unknown simple structure", level, "");
 315     }
 316     else
 317         logf (LOG_LOG, "%*.0s unknown structure", level, "");
 318 }
 319
 320 void zlog_rpn (Z_RPNQuery *rpn)
 321 {
 322     oident *attrset;
 323     enum oid_value ast;
 324
 325     attrset = oid_getentbyoid (rpn->attributeSetId);
 326     if (attrset)
 327     {
 328         ast = attrset->value;
 329         logf (LOG_LOG, "RPN query. Type: %s", attrset->desc);
 330     }
 331     else
 332     {
 333         ast = VAL_NONE;
 334         logf (LOG_LOG, "RPN query. Unknown type");
 335     }
 336     zlog_structure (rpn->RPNStructure, 0, ast);
 337 }
 338
 339 void zlog_scan (Z_AttributesPlusTerm *zapt, oid_value ast)
 340 {
 341     int level = 0;
 342     if (zapt->term->which == Z_Term_general)
 343     {
 344         logf (LOG_LOG, "%*.0s term '%.*s' (general)", level, "",
 345               zapt->term->u.general->len, zapt->term->u.general->buf);
 346     }
 347     else
 348         logf (LOG_LOG, "%*.0s term (not general)", level, "");
 349     zlog_attributes (zapt, level+2, ast);
 350 }