home *** CD-ROM | disk | FTP | other *** search
/ Internet Publisher's Toolbox 2.0 / Internet Publisher's Toolbox.iso / internet / ntserver / wtsource / sersrch.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-23  |  35.1 KB  |  1,128 lines
  1. /* WIDE AREA INFORMATION SERVER SOFTWARE
  2.    No guarantees or restrictions.  See the readme file for the full standard
  3.    disclaimer.    
  4.    Brewster@think.com
  5. */
  6.  
  7. /* Copyright (c) CNIDR (see ../COPYRIGHT) */
  8.  
  9. /* implements the search part of irext.h 
  10.    (search_word and finished_search_word)
  11.    -brewster
  12.  
  13. Split from irsearch.c
  14.  
  15.    5/31/91 Added scale_scores.  Fixed document_score_array to long.
  16.    7/8/91 Removed scale_scores, handled in search_word with doc_id > 0.
  17.    2/4/92 Made document_score_array a double.
  18.  
  19.    - Jonny G
  20.  * $Log:    sersrch.c,v $
  21.  * Revision 1.33  93/07/21  18:47:38  warnock
  22.  * Added STELAR-specific patches
  23.  *
  24.  * Revision 1.10  1993/10/13  14:14:20  huynh1
  25.  * new code added for encapsulated boolean queries and
  26.  * modified literal search
  27.  * 
  28.  * Revision 1.32  93/07/19  17:09:39  warnock
  29.  * fixed problem with multiple documents in single file, from isaacs@hpcc05.corp.hp.com
  30.  *
  31.  * Revision 1.3  1993/07/13  08:19:56  pfeifer
  32.  * Sicherung vor Aenderungen Tung
  33.  * 
  34.  * Revision 1.31  93/07/02  18:31:06  warnock
  35.  * included ctype.h
  36.  * 
  37.  * Revision 1.3a  93/07/02  17:59:25  warnock
  38.  * change to search_word to handle compressed files from francois
  39.  * 
  40.  * Revision 1.1  1993/02/16  15:05:35  freewais
  41.  * Initial revision
  42.  *
  43.  * Revision 1.24  92/04/28  16:56:54  morris
  44.  * added boolean to serial engine
  45.  * 
  46.  * Revision 1.23  92/03/15  10:15:18  jonathan
  47.  * Added Simon Spero's ASSIGN replacement for read_bytes.
  48.  * 
  49.  * Revision 1.22  92/03/05  07:09:54  shen
  50.  * add two more dummy arguments to call to init_search_engine
  51.  * 
  52.  * Revision 1.21  92/02/12  17:29:52  jonathan
  53.  * Conditionalized inclusion of object code.
  54.  * 
  55.  * Revision 1.20  92/02/12  13:40:06  jonathan
  56.  * Added "$Log" so RCS will put the log message in the header
  57.  * 
  58. */
  59.  
  60. #include <string.h>
  61. #include "cdialect.h"
  62. #include "irfiles.h"
  63. #ifdef BIO
  64. #include "irtfiles.h" /* dgg, for wordDelimiter */
  65. #endif /* BIO */
  66. #include "irsearch.h"
  67. #include "irext.h"
  68. #include "byte_order.h"
  69. #include <ctype.h>
  70.  
  71. #include <math.h>
  72.  
  73. /* tung, 10/93 */
  74. #ifdef BOOLEANS
  75. #include "boolean_op.h"
  76. #endif /* BOOLEANS */
  77. /* tung, 10/93 */
  78.  
  79. /* #define MAXINT (unsigned long)2^(sizeof(long)*8-1) */
  80.  
  81. #define VALUE 1000000L
  82.  
  83. #include "stemmer.h"   
  84.  
  85. /* tung, 10/93 */
  86. #ifdef BOOLEANS
  87. #include "boolean_op.h"
  88. #endif /* BOOLEANS */
  89. /* tung, 10/93 */
  90.  
  91. #ifdef BOOL
  92. #include "obj.h"
  93. #include "irparse.h"
  94. object* currentQuery = NULL; /* kludge until irext goes away */
  95. #endif /* def BOOL */
  96.  
  97. #ifdef WIN32
  98. #include <io.h>
  99. #endif
  100.  
  101. /* weighting for relevant document terms - 
  102.    this may become a parameter to the query.
  103. */
  104.  
  105. #define RF_WEIGHTING 0.1
  106.  
  107. /* ==================================
  108.  * ===  Initialization Functions  ===
  109.  * ==================================*/
  110.  
  111.  
  112. long init_search_engine(file, initialize, for_search, cm_mem_percent, 
  113. text_size, grow_percent)
  114.   char* file;
  115.   boolean initialize;
  116.   boolean for_search;
  117.   long cm_mem_percent;  /* unused */
  118.   long text_size;     /* unused */
  119.   long grow_percent;  /* unused */
  120. {
  121.   static boolean inited = false;
  122.  
  123.   if (inited == false)
  124.    { 
  125. #ifdef BOOL
  126.      initObj();
  127.      initBool();
  128. #endif /* BOOL */
  129.      inited = true;
  130.    }
  131.  
  132.   return(0);
  133. }
  134.  
  135. long finished_search_engine()
  136. {
  137.   return(0);
  138. }
  139.  
  140.  
  141. /*
  142.  *  ext_open_database: see irext.h
  143.  */
  144.  
  145. long ext_open_database (db, initialize, for_search)
  146.      database *db;
  147.      boolean initialize;
  148.      boolean for_search;
  149. { /* this has to deal with the .inv file */
  150.   char file[MAX_FILE_NAME_LEN];
  151.  
  152.   if(initialize) /* make a new one */
  153.     db->index_stream = s_fopen(index_filename(file, db), "w+b");
  154.   else if(for_search) /* just search */
  155.     db->index_stream = s_fopen(index_filename(file, db), "rb");
  156.   else /* write to an existing db */
  157.     db->index_stream = s_fopen(index_filename(file, db), "r+b");
  158.  
  159.   if (db->index_stream == NULL) {
  160.     waislog(WLOG_HIGH, WLOG_ERROR,"2can't open the inverted index file %s\n", 
  161.         file);
  162.       disposeDatabase(db);
  163.       return(1);
  164.     }
  165.   return(0);
  166. }
  167.   
  168.  
  169.  
  170. /*
  171.  *  ext_close_database: see irext.h
  172.  */
  173.  
  174. long ext_close_database (db)
  175.      database *db;
  176. {
  177.   return(0);
  178. }
  179.  
  180. char *database_file(database_name)
  181.      char *database_name;
  182. {
  183.   return(database_name);
  184. }
  185.   
  186. /*===========================*
  187.  *===  Setting Paramters  ===*
  188.  *===========================*/
  189.  
  190. long max_hit_retrieved = 0;
  191. char **srcs = NULL;
  192.  
  193. long set_query_parameter (mask, parameters)
  194.      long mask;
  195.      query_parameter_type * parameters;
  196. {
  197.   switch (mask)
  198.     {
  199.     case SET_MAX_RETRIEVED_MASK:
  200.       max_hit_retrieved = parameters->max_hit_retrieved;
  201.       return(0);
  202.       break;
  203.     case SET_SELECT_SOURCE:
  204.       if(NULL != srcs){
  205.     if(NULL != srcs[0])
  206.       s_free(srcs[0]);
  207.     s_free(srcs);
  208.       }
  209.       srcs = parameters->srcs;
  210.       break;
  211.     default:
  212.       return(-1);
  213.       break;
  214.     }
  215.   return(0);
  216. }
  217.  
  218. /*==============================*
  219.  *===  Document Score Array  ===*
  220.  *==============================*/
  221.  
  222. double *document_score_array = NULL;
  223. long document_score_array_len = 0;
  224. #ifdef BOOLEANS
  225. double *prev_score_array = NULL;                    /* 12/91 GS TLG */
  226.  
  227. /* tung, 10/93 */
  228. search_result_struct *search_result_array = NULL;
  229. /* tung, 10/93 */
  230.  
  231. #endif /* BOOLEANS */
  232.  
  233. /* make_document_score_array insures that the document_score_array
  234.    array is long enough, if not it makes it long enough */
  235. static void make_document_score_array _AP((long length ));
  236. static void make_document_score_array(length)
  237. long length;
  238. {
  239.   if(length <= document_score_array_len)
  240.     return;
  241.   /* we have to make a new one.  free the old one first (if any) */
  242.   if(document_score_array != 0){
  243.     s_free(document_score_array);
  244. #ifdef BOOLEANS
  245.     s_free(prev_score_array);                   /* 12/91 GS TLG */
  246. #endif /* BOOLEANS */
  247.   }
  248.   document_score_array = (double*)s_malloc(
  249.                      (size_t)(length * sizeof(double)));
  250. #ifdef BOOLEANS
  251.   prev_score_array   = (double*)s_malloc((size_t)(length * sizeof(double)));  /* 12/91 GS TLG */
  252. #endif /* BOOLEANS */
  253.   document_score_array_len = length;
  254. }
  255.  
  256. static void destroy_document_score_array _AP((void));
  257. static void destroy_document_score_array()
  258. {
  259.   s_free(document_score_array);
  260. #ifdef BOOLEANS
  261.   s_free(prev_score_array);                 /* 12/91 GS TLG */
  262. #endif /* BOOLEANS */
  263.   document_score_array_len = 0;
  264. }
  265.     
  266. void clear_document_score_array()
  267. /* side effects the document_score_array. */
  268. { 
  269.   memset(document_score_array, 0, 
  270.      document_score_array_len * sizeof(double));
  271. #ifdef BOOLEANS
  272.   memset(prev_score_array, 0,                   /* 12/91 GS TLG */
  273.          document_score_array_len * sizeof(double));        /* 12/91 GS TLG */
  274. #endif /* BOOLEANS */
  275. }
  276.  
  277. /* for debugging purposes */
  278. void print_document_score_array(start,stop)
  279. unsigned long start;
  280. unsigned long stop;
  281. /* assumes start >= 0, stop < db->doc_table_allocated_entries */
  282. {
  283.     long i;
  284. #ifdef WIN32
  285.     for(i = start; i <= (long)stop; i++){
  286. #else
  287.     for(i = start; i <= stop; i++){
  288. #endif
  289.         printf("entry number %d: %f \n", 
  290.                i, document_score_array[i]);
  291.     }
  292. }
  293.  
  294.  
  295.  
  296. /*=========================*
  297.  *===  Best Hits Array  ===*
  298.  *=========================*/
  299.  
  300. hit *best_hits_array = NULL;
  301. long best_hits_array_len = 0;
  302. long current_best_hit = 0;
  303.  
  304. /* see irext.h for doc */
  305. long init_best_hit (db)
  306.      database *db;
  307. {
  308.  
  309. #ifdef BOOL
  310.   if (currentQuery != NULL)
  311.     send(currentQuery,InitBestHit,db);
  312. #endif /* def BOOL */
  313.  
  314.   return(0);
  315. }
  316.  
  317. /* make_best_hits_array insures that the best_hits_array
  318.    array is long enough, if not it makes it long enough */
  319. static void make_best_hits_array _AP((long length));
  320. static void make_best_hits_array(length)
  321. long length;
  322. {
  323.   if(length <= best_hits_array_len)
  324.     return;
  325.   /* we have to make a new one.  free the old one first (if any) */
  326.   if(best_hits_array != 0){
  327.     s_free(best_hits_array);
  328.   }
  329.   best_hits_array = (hit*)s_malloc((size_t)(length * sizeof(hit)));
  330.   best_hits_array_len = length;
  331. }
  332.  
  333. static void destroy_best_hits_array _AP((void));
  334. static void destroy_best_hits_array()
  335. {
  336.   s_free(best_hits_array);
  337.   best_hits_array_len = 0;
  338. }
  339.     
  340. void clear_best_hits_array()
  341. /* side effects the best_hits_array.  XXX could use memset */
  342. { 
  343.   memset((char*)best_hits_array, 0, best_hits_array_len * sizeof(hit));
  344. }
  345.  
  346. /* for debugging purposes */
  347. void print_best_hits()
  348. {
  349.   long i;
  350.   for( i = 0; i < best_hits_array_len; i++){
  351.     if (best_hits_array[i].weight != 0)
  352.       { printf("Best hit %ld: weight %lf, doc_id %ld, headline %s, filename %s, lines %ld\n", 
  353.            i, best_hits_array[i].weight, 
  354.            best_hits_array[i].document_id,
  355.            best_hits_array[i].headline,
  356.            best_hits_array[i].filename,
  357.            best_hits_array[i].number_of_lines);
  358.       }
  359.   }
  360. }
  361.  
  362. void sort_best_hits(db)
  363.      database * db;
  364. {
  365.   /* returns nothing.
  366.    * side effects best_hits and document_score_array
  367.    */
  368.  
  369.   long i, doc;
  370.   double worst_weight_to_make_it = 0.0;
  371.   document_table_entry doc_entry;
  372.   long best_hit_number = 0;
  373.  
  374.   /* snuff the scores */
  375.   for(i = 0; i < max_hit_retrieved; i++){
  376.     best_hits_array[i].weight = 0.0;
  377.  
  378.   }
  379.  
  380.   /* loop over the doc, and keep the doc_id and weight in best hit table */
  381.   for(doc = 1; doc < db->doc_table_allocated_entries; doc++){
  382.     double weight = document_score_array[doc];
  383. /* jmf */
  384.     read_document_table_entry(&doc_entry, doc, db);  /* if this could be
  385. removed, we'd gain speed */
  386. /*      if (doc_entry.document_length) */
  387. #ifdef WIN32
  388.     /* Windows NT doesn't like dividing by 0.  This will cause the first
  389.        entry in the document table (which is a null entry) to be skipped.
  390.        [I don't understand why UNIX or the Macintosh don't have a problem here.]
  391.      */
  392.     if (doc_entry.document_length == 0) continue;
  393. #endif /* WIN32 */
  394.     weight/=doc_entry.document_length;
  395.     if(worst_weight_to_make_it < weight){
  396.       /* merge it into the best_hits array. start at the bottom */
  397.       for(i = (max_hit_retrieved - 1); i >= 0; i--){
  398.     if(weight > best_hits_array[i].weight 
  399.        /* && (check_document_id(doc, db) == true) too slow.*/
  400.        ){
  401.       /* move this entry down */    
  402.       if((i + 1) < max_hit_retrieved){
  403.         best_hits_array[i+1].weight = best_hits_array[i].weight;
  404.         best_hits_array[i+1].document_id = best_hits_array[i].document_id;
  405.       }
  406.       best_hits_array[i].document_id = doc;
  407.       best_hits_array[i].weight = weight;
  408.     }
  409.     else
  410.       break;
  411.       }      
  412.     }
  413.   }
  414.   
  415.   for(i = 0; i < max_hit_retrieved; i++){
  416.     if(best_hits_array[i].weight <= 0.0)
  417.       return;
  418.     if (read_document_table_entry(&doc_entry,
  419.                   best_hits_array[i].document_id,
  420.                   db) 
  421.     == true){
  422.       best_hits_array[best_hit_number].weight = best_hits_array[i].weight;
  423.  
  424.       best_hits_array[best_hit_number].document_id = best_hits_array[i].document_id;
  425.       best_hits_array[best_hit_number].start_character = doc_entry.start_character;
  426.       best_hits_array[best_hit_number].end_character = doc_entry.end_character;
  427.       best_hits_array[best_hit_number].document_length = doc_entry.document_length;
  428.       best_hits_array[best_hit_number].number_of_lines = doc_entry.number_of_lines;
  429.       sprintf(best_hits_array[best_hit_number].date, "%d", doc_entry.date);
  430.       read_filename_table_entry(doc_entry.filename_id, 
  431.                 best_hits_array[best_hit_number].filename,
  432.                 best_hits_array[best_hit_number].type,
  433.                 NULL,
  434.                 db),
  435.       strncpy(best_hits_array[best_hit_number].headline, 
  436.           read_headline_table_entry(doc_entry.headline_id,db),
  437.           MAX_FILE_NAME_LEN);
  438.       best_hit_number++;
  439.     } 
  440.     beFriendly();
  441.   }
  442.   for(i = best_hit_number; i < max_hit_retrieved; i++){
  443.     best_hits_array[best_hit_number].weight = 0.0;
  444.   }
  445.   /* print_best_hits(s);  for debugging */
  446. }
  447.  
  448.  
  449. /* returns the next best hit */
  450. long best_hit(db, doc_id, best_character, best_line, score,start,end,date,
  451. length,nlines,headline,filename,type)
  452.      database *db;
  453.      long *doc_id;  
  454.      long *best_character;
  455.      long *best_line;
  456.      double *score;
  457.     long *start,*end,*date,*length,*nlines;
  458. char *headline,*filename,*type;
  459. {
  460. double tmp;
  461.  
  462.   *best_character = 0; 
  463.   *best_line = 0;
  464.   
  465. #ifdef BOOL
  466.   if (currentQuery != NULL) /* for boolean */
  467.    {
  468.      send(currentQuery,GetBestHit,db,doc_id,best_character,best_line,score);
  469.      if (*doc_id > 0)
  470.        return(0); /* ok */
  471.      else
  472.        return(-1); /* no more docs */
  473.    }
  474. #endif /* BOOL */
  475.  
  476.   if(current_best_hit > best_hits_array_len)
  477.     return(1);
  478.   if(best_hits_array[current_best_hit].weight == 0.0)
  479.     return(1);
  480.   *doc_id = best_hits_array[current_best_hit].document_id;
  481.   tmp  = ((double)(best_hits_array[current_best_hit].weight*VALUE));
  482. *score=tmp;
  483. *start=best_hits_array[current_best_hit].start_character;
  484. *end=best_hits_array[current_best_hit].end_character;
  485. *date=atoi(best_hits_array[current_best_hit].date);
  486. *length=best_hits_array[current_best_hit].document_length;
  487. *nlines=best_hits_array[current_best_hit].number_of_lines;
  488. strcpy(headline,best_hits_array[current_best_hit].headline);
  489. strcpy(filename,best_hits_array[current_best_hit].filename);
  490. strcpy(type,best_hits_array[current_best_hit].type);
  491.   current_best_hit++;
  492.   return(0);
  493. }
  494.  
  495. long finished_best_hit(db)
  496. database *db;
  497. { 
  498.  
  499. #ifdef BOOL
  500.   if (currentQuery != NULL) /* for boolean */
  501.    { send(currentQuery,Delete);
  502.      currentQuery = NULL;
  503.      return(0);
  504.    }
  505. #endif /* BOOL */
  506.  
  507.   /* if we are on a small machine, we might want to 
  508.      destroy_document_score_array */
  509.   clear_document_score_array();
  510.   clear_best_hits_array();
  511.   current_best_hit = 0;
  512.   return(0);
  513. }
  514.  
  515. /*=============================*    
  516.  *===  Searching for words  ===*
  517.  *=============================*/
  518.  
  519. /* see irext.h for doc */
  520. long init_search_word (db)
  521.      database* db;
  522. {
  523. char fn[256];
  524.   strcpy( fn,db->database_file );
  525.   strcat( fn,synonym_ext );
  526.   syn_ReadFile( fn,&db->syn_Table,&db->syn_Table_Size );
  527.  
  528.   return(0);
  529. }
  530.  
  531.  
  532. #ifdef BOOLEANS
  533. /* tung, 10/93 */
  534. long word_id = 0;
  535. extern long number_of_qwords ;
  536. /* tung, 10/93 */
  537.  
  538. static boolean   gLastAnd= false;
  539. static boolean   gLastNot= false;
  540. #endif /* BOOLEANS */
  541.  
  542. /* see irext.h for doc */
  543. /* returns -1 if error, 1 if word exists, 0 if not */
  544.  
  545. long search_word(word,char_pos, line_pos, weight, doc_id, 
  546.          word_pair, db)
  547.      char *word; /* the word to be searched for */
  548.      long char_pos;     /* the position of the start of the word */
  549.      long line_pos;     /* is this needed? not for signature system */
  550.      long weight;       /* how important the word looks syntactically,
  551.                    such as is it bold */
  552.      long doc_id;       /* current document, seed words is 0,
  553.                    then it increments into the relevant 
  554.                    document */
  555.      long word_pair;
  556.      database *db;
  557. {
  558.   /* this side effects the document_score_array,
  559.    * and downcases the word.
  560.    * Returns 0 if successful or word not present, 
  561.    * returns non-0 if an error.
  562.    *
  563.    */
  564.   
  565.   long not_full_flag = INDEX_BLOCK_FULL_FLAG; /*start out full so it will go on looking */
  566.   long count, index_block_size;
  567.   long internal_document_id,  number_of_valid_entries;
  568.   double internal_weight;
  569.   long index_file_block_number;
  570.   long number_of_occurances;
  571.  
  572.   FOUR_BYTE index_buffer_data[INDEX_ELEMENT_SIZE*(1024/4)];
  573.   char *index_buffer;
  574.   char *i;
  575.   FILE *stream = NULL;
  576.  
  577.  
  578. #ifdef LITERAL
  579. #ifdef WIN32
  580.   long txt_pos;                   /* 2/92 GS TLG */
  581.   document_table_entry doc_entry;                   /* 2/92 GS TLG */
  582.   static FILE *txt_stream = NULL;                   /* 2/92 GS TLG */
  583. #else
  584.   long txt_pos, icnt, wcnt, pcnt;                   /* 2/92 GS TLG */
  585.   document_table_entry doc_entry;                   /* 2/92 GS TLG */
  586.   static FILE *txt_stream = NULL;                   /* 2/92 GS TLG */
  587.   char cmpr_word[MAX_PHRASE_LENGTH + 1];                /* 2/92 GS TLG */
  588.   char phrase[MAX_PHRASE_LENGTH + 1];                   /* 2/92 GS TLG */
  589. #endif
  590.   char txt_filename[MAX_FILENAME_LEN + 1];              /* 2/92 GS TLG */
  591.   char *temp_txt_filename = NULL;               
  592.   char prev_txt_filename[MAX_FILENAME_LEN + 1];             /* 2/92 GS TLG */
  593.   char txt_type[MAX_TYPE_LEN + 1];                  /* 2/92 GS TLG */
  594.   long phraselen= 0, txt_pos_fix= 0;
  595.   char *document_section = NULL;     /* tung , 10/93 */
  596.   long document_section_len = 0;     /* tung , 10/93 */
  597.   long phrase_readed = 0;            /* tung , 10/93 */
  598.   long phrase_count = 0;             /* tung , 10/93 */
  599.   boolean phrase_found = false;      /* tung , 10/93 */
  600. #endif /* LITERAL */
  601.   
  602. /* do synonym conversion */
  603.  
  604. /* in theory, one can replace a word with a boolean phrase */
  605. char *newword;
  606. double idf;
  607.  
  608.   newword = lookup_Synonym( word,db->syn_Table,db->syn_Table_Size );
  609. waislog(WLOG_HIGH,WLOG_INFO,"Word %s Syn %s",word,newword);
  610. strncpy(word,newword,MAX_WORD_LENGTH);
  611.  
  612. /* call the stemmer */
  613. #ifdef LITERAL
  614.   if (weight!=LITERAL_FLAG) {
  615.     stemmer(word); 
  616.   }
  617. #else
  618.   stemmer(word); 
  619. #endif /* LITERAL */
  620.  
  621. /* tung, 10/93 */
  622. #ifdef BOOLEANS
  623.   if(number_of_qwords > 0) {
  624.     if((weight!=LITERAL_FLAG) && IsOperator(word)) {
  625.       boolean_operations(word);
  626.       return(0);
  627.     }
  628.     if(search_result_array == NULL) {
  629.       search_result_array = 
  630.         (search_result_struct *)
  631.           s_malloc((size_t)(number_of_qwords * sizeof(search_result_struct))); 
  632.       word_id = 0;
  633.     }
  634.     if(strlen(word) == 1) {
  635.       search_result_array[word_id].number_of_hits = 0;
  636.       search_result_array[word_id].word_id = word_id;
  637.       save_word_id(word_id);
  638.       ++word_id;
  639.       return(0);
  640.     }
  641.   }
  642. #endif /* BOOLEANS */
  643. /* tung, 10/93 */
  644.   
  645.  
  646. #ifdef LITERAL
  647.   if (weight==LITERAL_FLAG) {
  648.     /* goto after_booleans */
  649. /* printf("search_word: literal word is [%s]\n", word); */
  650.     }
  651.   else 
  652. #endif /* LITERAL */
  653. #ifdef BOOLEANS
  654.   if (strcmp(word,BOOLEAN_AND)==0) {  /* should be all lowercase cmp here */
  655.     gLastAnd= true;
  656.     return(0);
  657.     }
  658.   else if (strcmp(word,BOOLEAN_NOT)==0) {  
  659.   /* ^^ this is bad if we intersperse "not"s in a query --
  660.      docs found after not word may include notted word --
  661.      need to go back to doing not words after others --
  662.      but need now to check for literal string first
  663.   */
  664.     gLastNot= true;
  665.     return(0);
  666.     }
  667.   if (weight == BOOLEAN_NOT_FLAG) gLastNot= true;
  668. #else
  669.      ;   /* if not LITERAL_FLAG */
  670. #endif /* BOOLEANS */
  671.  
  672.   index_buffer = (char*)index_buffer_data;
  673.  
  674. #ifdef LITERAL
  675.   if (weight==LITERAL_FLAG) {
  676.   /* note: we found the first word of phrase once in map_over_words, but i'm too lazy 
  677.     to put another parameter in that cascade of function calls it takes
  678.     to get here.
  679.   */
  680.     char  word1[MAX_WORD_LENGTH + 1];
  681.     register int i, len;
  682.     register boolean more;
  683.     phraselen= MIN( MAX_PHRASE_LENGTH, strlen(word));
  684.     len = MIN( MAX_WORD_LENGTH, phraselen);
  685.     for (i=0, more=true; i < len && more; ) {
  686.        word1[i] = word[i++];
  687. #ifdef BIO
  688.        more= (wordDelimiter(word[i]) == NOT_DELIMITER); 
  689. #else
  690.        more= (isalnum(word[i]));
  691. #endif /* BIO */
  692.        }
  693.     word1[i]= '\0';
  694.     txt_pos_fix= strlen(word1) + 1;
  695. /* printf("search_word: literal word1 is [%s]\n", word1); */
  696.     index_file_block_number = 
  697.      look_up_word_in_dictionary(word1, &number_of_occurances, db);
  698.     }
  699.   else
  700. #endif  /* LITERAL */
  701.  
  702. #ifdef PARTIALWORD
  703.   index_file_block_number = 
  704.     look_up_partialword_in_dictionary(word, &number_of_occurances, db);
  705. #else
  706.   index_file_block_number = 
  707.     look_up_word_in_dictionary(word, &number_of_occurances, db);
  708. #endif /* PARTIALWORD */
  709.  
  710.   current_best_hit = 0;  /* so that the best hits willstart from 0 */
  711.  
  712.   /* check the document_score_array */
  713.   if(document_score_array_len < db->doc_table_allocated_entries)
  714.     make_document_score_array(db->doc_table_allocated_entries);
  715.  
  716.   if(index_file_block_number >= 0){
  717. #ifdef PARTIALWORD
  718.    while(index_file_block_number > 0){  /* dgg, need 2nd loop here for multiple partwords */
  719. #endif /* PARTIALWORD */
  720.     stream = db->index_stream;
  721.     
  722.     while((not_full_flag != INDEX_BLOCK_NOT_FULL_FLAG) && 
  723.       (index_file_block_number != 0)){  
  724.       /* read the index block */
  725.       if (0 != fseek(stream, (long)index_file_block_number, 
  726.              SEEK_SET)) 
  727.     { 
  728.       waislog(WLOG_HIGH, WLOG_ERROR, 
  729.           "fseek failed into the inverted file to position %ld",
  730.           (long)index_file_block_number); 
  731. #ifdef BOOLEANS
  732.    gLastNot= gLastAnd= false;
  733. #endif /* BOOLEANS */  
  734.       return(-1);
  735.     }
  736. #ifdef WIN32
  737.       _read(fileno(stream),index_buffer,INDEX_BLOCK_HEADER_SIZE);
  738. #else
  739.  
  740.       fread(index_buffer, INDEX_BLOCK_HEADER_SIZE, 1, stream);
  741. #endif
  742.  
  743.       ASSIGN(not_full_flag,
  744.          INDEX_BLOCK_FLAG_SIZE,
  745.          index_buffer,
  746.          INDEX_BLOCK_HEADER_SIZE,
  747.          0 );
  748.       ASSIGN(index_file_block_number,NEXT_INDEX_BLOCK_SIZE,
  749.          index_buffer+INDEX_BLOCK_FLAG_SIZE,
  750.          INDEX_BLOCK_HEADER_SIZE,
  751.          INDEX_BLOCK_FLAG_SIZE);
  752.       ASSIGN(index_block_size,INDEX_BLOCK_SIZE_SIZE,
  753.          index_buffer+INDEX_BLOCK_FLAG_SIZE+NEXT_INDEX_BLOCK_SIZE,
  754.          INDEX_BLOCK_HEADER_SIZE,
  755.          INDEX_BLOCK_FLAG_SIZE+NEXT_INDEX_BLOCK_SIZE);
  756.  
  757. /*
  758.   this is equivalent, but slower:
  759.  
  760.       not_full_flag = read_bytes(INDEX_BLOCK_FLAG_SIZE, stream);
  761.       index_file_block_number = read_bytes(NEXT_INDEX_BLOCK_SIZE, stream);
  762.       index_block_size = read_bytes(INDEX_BLOCK_SIZE_SIZE, stream);
  763. */
  764.  
  765. /*  Jim's debug code commented out
  766.       printf("flag = %d, block_num = %d, block_size = %d\n",
  767.          not_full_flag, 
  768.          index_file_block_number,
  769.          index_block_size);
  770. */
  771.       fflush(stdout);
  772.  
  773.       if(EOF == index_block_size) 
  774.     { 
  775.       waislog(WLOG_HIGH, WLOG_ERROR, 
  776.           "reading from the index file failed");
  777. #ifdef BOOLEANS
  778.    gLastNot= gLastAnd= false;
  779. #endif /* BOOLEANS */  
  780.       return(-1);
  781.     }
  782.       
  783.       if(not_full_flag == INDEX_BLOCK_NOT_FULL_FLAG){
  784.     /* not full */
  785.     number_of_valid_entries = index_file_block_number;
  786.       }
  787.       else if(not_full_flag == INDEX_BLOCK_FULL_FLAG){
  788.     /* full */
  789.     number_of_valid_entries = index_block_size - INDEX_BLOCK_HEADER_SIZE;
  790.       }
  791.       else{         /* bad news, file is corrupted. */
  792.     waislog(WLOG_HIGH, WLOG_ERROR, 
  793.         "Expected the flag in the inverted file to be valid.  it is %ld",
  794.         not_full_flag);
  795. #ifdef BOOLEANS
  796.    gLastNot= gLastAnd= false;
  797. #endif /* BOOLEANS */  
  798.     return(-1);
  799.       }
  800.       /* printf("number of valid bytes: %ld\n", number_of_valid_entries); */
  801.       
  802.       /* add the array to the document_score_array */
  803.       number_of_valid_entries /= INDEX_ELEMENT_SIZE;
  804.  
  805.  
  806. /* tung, 10/93 */
  807. #ifdef BOOLEANS   
  808.       if((number_of_qwords > 0) && (search_result_array != NULL)) {
  809.         if(search_result_array[word_id].doc_ids_array == NULL) 
  810.           search_result_array[word_id].doc_ids_array =
  811.             (doc_descr_struct *)
  812.               s_malloc((size_t)(sizeof(doc_descr_struct) * number_of_valid_entries));
  813.         search_result_array[word_id].number_of_hits = number_of_valid_entries;
  814.       }
  815. #endif /* BOOLEANS */
  816. /* tung, 10/93 */
  817.  
  818.  
  819. /* ses - idf is a fist approximation to the inverse document freq. */
  820. /* what it actually is  is the inverse occurance frequency which says
  821. that the significance of a word is inversly proportional to the number
  822. of times it occurs in the database */
  823.  
  824.     idf=1.0/number_of_occurances; 
  825.       for(count=0;count <  number_of_valid_entries;count++) {
  826.     int wgt;
  827.     int did;
  828. /*
  829.     if(count%1024 == 0) {
  830.       read(fileno(stream),index_buffer,INDEX_ELEMENT_SIZE*
  831.         MIN(1024,number_of_valid_entries-count));
  832.       i=index_buffer;
  833.     }
  834. */
  835.     did = read_bytes(DOCUMENT_ID_SIZE, stream);
  836.         (void)read_bytes(WORD_POSITION_SIZE, stream);
  837.         txt_pos=read_bytes(CHARACTER_POSITION_SIZE, stream);
  838.         wgt = read_bytes(WEIGHT_SIZE,stream);
  839. /*
  840.  
  841.     ASSIGN(wgt,WEIGHT_SIZE,    
  842.            i+DOCUMENT_ID_SIZE+WORD_POSITION_SIZE+CHARACTER_POSITION_SIZE,
  843.            INDEX_ELEMENT_SIZE,
  844.            DOCUMENT_ID_SIZE+WORD_POSITION_SIZE+CHARACTER_POSITION_SIZE);
  845.     ASSIGN(did,DOCUMENT_ID_SIZE,i,INDEX_ELEMENT_SIZE,0);
  846. */
  847. #ifdef LITERAL
  848.     /* dgg -- is this proper update of read form to ASSIGN form ??*/
  849.     /* txt_pos = read_bytes(CHARACTER_POSITION_SIZE, stream);*/     /* 2/92 GS TLG */
  850.         if ((weight == LITERAL_FLAG) && (0 == doc_id))  {        
  851. /*
  852.     ASSIGN(txt_pos,CHARACTER_POSITION_SIZE,i+DOCUMENT_ID_SIZE+WORD_POSITION_SIZE,
  853.         INDEX_ELEMENT_SIZE,DOCUMENT_ID_SIZE+WORD_POSITION_SIZE);
  854. */
  855. /* printf("search_word: txtpos=%d, wgt=%d, did=%d\n", txt_pos, wgt, did); */
  856.         }
  857. #endif /* LITERAL */
  858.  
  859. /* Commented out as suggested by Stan Isaacs at hp.com to come up with correct
  860.  * weights when there are multiple documents in a file
  861.  *
  862.  *  if(wgt>5L)
  863.  *      wgt-=5L;
  864.  */
  865.     internal_weight = log((double)wgt);
  866.     internal_weight+=10.0;
  867.     internal_document_id = did;
  868.  
  869. /*
  870.     printf("entry %ld, Doc_id: %ld, weight %lf \n",
  871.         count, internal_document_id, internal_weight);
  872.     fflush(stdout);
  873. */
  874.     if(EOF == wgt) 
  875.       { 
  876.         waislog(WLOG_HIGH, WLOG_ERROR, 
  877.             "reading from the doc-id table failed");
  878. #ifdef BOOLEANS
  879.    gLastNot= gLastAnd= false;
  880. #endif  /* BOOLEANS */
  881.         return(-1);
  882.       }
  883.  
  884. #ifdef LITERAL         
  885.         if ((weight == LITERAL_FLAG) && (0 == doc_id)) {        /* 2/92 GS TLG */
  886.           if (true == read_document_table_entry(&doc_entry,     /* 2/92 GS TLG */
  887.                                              internal_document_id, db)) /* 2/92 GS TLG */
  888.        {                                /* 2/92 GS TLG */
  889.             read_filename_table_entry(doc_entry.filename_id,        /* 2/92 GS TLG */
  890.                                       txt_filename, txt_type, NULL, db);  /* 2/92 GS TLG */
  891. /* printf("search_word: document is [%s]\n", txt_filename); */
  892.             if (NULL == txt_stream) {
  893.               if (probe_file(txt_filename)) {
  894.                 txt_stream = s_fopen(txt_filename, "rb");
  895.               }
  896.               else if (probe_file_possibly_compressed(txt_filename)) {
  897.                temp_txt_filename = s_fzcat(txt_filename);
  898.                if (temp_txt_filename) {
  899.             txt_stream = s_fopen(temp_txt_filename, "rb");
  900.            }
  901.           }
  902.           
  903.               strcpy(prev_txt_filename, txt_filename);
  904.             }
  905.             else if (0 != strcmp(txt_filename, prev_txt_filename)) {
  906.               s_fclose(txt_stream);
  907.               if ( temp_txt_filename != NULL ) {
  908.                 unlink(temp_txt_filename);
  909.                 s_free(temp_txt_filename);
  910.               }
  911.               if (probe_file(txt_filename)) {
  912.                 txt_stream = s_fopen(txt_filename, "rb");
  913.               }
  914.               else if (probe_file_possibly_compressed(txt_filename)) {
  915.                temp_txt_filename = s_fzcat(txt_filename);
  916.                if (temp_txt_filename) {
  917.             txt_stream = s_fopen(temp_txt_filename, "rb");
  918.             }
  919.           }
  920.               strcpy(prev_txt_filename, txt_filename);      /* 2/92 GS TLG */
  921.             }
  922.  
  923.             txt_pos += doc_entry.start_character - txt_pos_fix;  /* dgg */
  924.  
  925.             document_section_len = doc_entry.end_character - txt_pos;   /* tung, 10/93 */
  926.             s_fseek(txt_stream, txt_pos, SEEK_SET);                     /* 2/92 GS TLG */
  927.             document_section = 
  928.               (char*) s_malloc((size_t)((document_section_len+1)*sizeof(char))); /* tung, 10/93 */
  929.             fgets(document_section, document_section_len, txt_stream);   /* tung, 10/93 */
  930.             phrase_readed = 0;                                           /* tung, 10/93 */
  931.             phrase_readed += strlen(document_section);                   /* tung, 10/93 */
  932.             document_section = string_downcase(document_section);        /* tung, 10/93 */
  933. #if 0
  934.  
  935.             fread(phrase, 1L, phraselen, txt_stream);                   /* 2/92 GS TLG */
  936. /* { phrase[phraselen]= '\0';
  937. printf("search_word: file phrase is [%s]\n", phrase); 
  938. } */
  939. #ifdef WIN32
  940.             if (0 != _strnicmp(word, phrase, phraselen))      /* 2/92 GS TLG */
  941. #else
  942.             if (0 != strncasecmp(word, phrase, phraselen))      /* 2/92 GS TLG */
  943. #endif
  944.               internal_weight = 0.0;                    /* 2/92 GS TLG */
  945. #endif  /* 0 */
  946.  
  947.             if (NULL == strstr(document_section, word)) {                    /* tung, 10/93 */
  948.               while(phrase_readed < document_section_len) {                  /* tung, 10/93 */
  949.                 fgets(document_section, document_section_len, txt_stream);   /* tung, 10/93 */
  950.                 phrase_readed += strlen(document_section);                   /* tung, 10/93 */
  951.                 document_section = string_downcase(document_section);        /* tung, 10/93 */
  952.                 if(strstr(document_section, word) != NULL)  {                /* tung, 10/93 */
  953.                   phrase_found = true;                                       /* tung, 10/93 */
  954.                   break;                                                     /* tung, 10/93 */
  955.                 }                                                            /* tung, 10/93 */
  956.               }                                                              /* tung, 10/93 */
  957.               if(phrase_found == false)                                      /* tung, 10/93 */
  958.                 internal_weight = 0.0;                                       /* tung, 10/93 */
  959.               phrase_found = false;                                          /* tung, 10/93 */
  960.             }
  961.             s_free(document_section);                                        /* tung, 10/93 */
  962.           }
  963.         }                                                               
  964. #endif /* LITERAL */
  965.  
  966. #ifdef BOOLEANS
  967.     if (gLastNot) {    
  968.        document_score_array[internal_document_id] = 0;
  969. /*  printf("search_word: boolean 'not' scored\n"); */
  970.         }
  971.      else 
  972. #endif /* BOOLEANS */
  973.     {
  974.     /* if(doc_id > 0) we are doing a relevant document */
  975. /*
  976. printf("wgt: %ld, internal weight: %lf, idf: %lf occurances: %ld\n",
  977.     wgt,internal_weight, idf,number_of_occurances);
  978. fflush(stdout);
  979. */
  980.         internal_weight*=idf; /* ses - for inverse doc. freq. */
  981. #ifndef BOOLEANS
  982.         document_score_array[internal_document_id] += 
  983.           (doc_id) ? (internal_weight * RF_WEIGHTING) : internal_weight;
  984. #else
  985. /* tung, 10/93 */
  986.         if(number_of_qwords == 0) {
  987.           document_score_array[internal_document_id] += 
  988.             (doc_id) ? (internal_weight * RF_WEIGHTING) : internal_weight;
  989.         }
  990.         else {
  991.           if((number_of_qwords > 0) && (search_result_array != NULL)) {
  992.             if(weight == LITERAL_FLAG) {
  993.               if(document_score_array[internal_document_id] > 0) {
  994.                 ((search_result_array[word_id]).doc_ids_array[phrase_count]).doc_id = internal_document_id;
  995.                 ((search_result_array[word_id]).doc_ids_array[phrase_count]).score +=
  996.                   (doc_id) ? (internal_weight * RF_WEIGHTING) : internal_weight;
  997.                 phrase_count++;
  998.                 search_result_array[word_id].number_of_hits = phrase_count;
  999.               }
  1000.             }
  1001.             else {
  1002.               ((search_result_array[word_id]).doc_ids_array[count]).doc_id = internal_document_id;
  1003.               ((search_result_array[word_id]).doc_ids_array[count]).score +=
  1004.                 (doc_id) ? (internal_weight * RF_WEIGHTING) : internal_weight;
  1005.             }
  1006.           }
  1007.         }
  1008. #endif /* BOOLEANS */
  1009. /* tung, 10/93 */
  1010.         
  1011.         }
  1012. /*
  1013. printf("Score array: %lf\n",document_score_array[internal_document_id]);
  1014. fflush(stdout);
  1015. */
  1016.  
  1017.     i+=INDEX_ELEMENT_SIZE;
  1018.       }
  1019.     }
  1020.  
  1021. #ifdef PARTIALWORD
  1022.   index_file_block_number = 
  1023.     look_up_partialword_in_dictionary(NULL, &number_of_occurances, db);
  1024.   }
  1025. #endif /* PARTIALWORD */
  1026.  
  1027. /* tung, 10/93 */
  1028. #ifdef BOOLEANS
  1029.     if((number_of_qwords > 0) && (search_result_array != NULL)) {
  1030.       save_word_id(word_id);
  1031.       search_result_array[word_id].word_id = word_id;
  1032.       ++word_id;
  1033.     }
  1034. #endif /* BOOLEANS */
  1035. /* tung, 10/93 */
  1036.  
  1037. #ifdef BOOLEANS
  1038.    if(number_of_qwords == 0) {
  1039.     for (count=0; count < db->doc_table_allocated_entries; count++) {  
  1040.       if (!gLastAnd) {                                                  
  1041.         prev_score_array[count] = document_score_array[count];          
  1042.         }                                                               
  1043.       else {                                                            
  1044.         if ((document_score_array[count] == prev_score_array[count])    
  1045.             || (prev_score_array[count] == 0)) {
  1046.           document_score_array[count] = 0;                              
  1047.           prev_score_array[count] = 0;                                  
  1048.           }                                                             
  1049.         else {  
  1050.           prev_score_array[count] = document_score_array[count];        
  1051.           }                                                             
  1052.       }                                                                 
  1053.     }                                                                   
  1054.   /* if (gLastAnd) printf("search_word: boolean `and' scored\n"); */ 
  1055.   } 
  1056. #endif /* BOOLEANS */
  1057.  
  1058. #ifdef BOOLEANS
  1059.    gLastNot= gLastAnd= false;
  1060. #endif /* BOOLEANS */
  1061.     return(1); /* word present */
  1062. }
  1063.   
  1064.   else if(0 == index_file_block_number){
  1065.     /* an error occurred on looking up the word */
  1066. #ifdef BOOLEANS
  1067.    gLastNot= gLastAnd= false;
  1068. #endif  /* BOOLEANS */
  1069.     return(-1);
  1070.   }
  1071.   
  1072.   else {                /* index_file_block_number is negative */
  1073. #ifdef BOOLEANS
  1074. /* tung, 10/93 */
  1075.     if((number_of_qwords > 0) && (search_result_array != NULL)) {
  1076.       save_word_id(word_id);
  1077.       search_result_array[word_id].word_id = word_id;
  1078.       search_result_array[word_id].number_of_hits = 0;
  1079.       ++word_id;
  1080.     }
  1081. /* tung, 10/93 */
  1082.     else {
  1083.       if (gLastAnd) 
  1084.        for (count=0; count < db->doc_table_allocated_entries; count++) {
  1085.          document_score_array[count] = 0;                       
  1086.          prev_score_array[count] = 0;   
  1087.          } 
  1088.     }
  1089.    gLastNot= gLastAnd= false;
  1090. #endif  /* BOOLEANS */
  1091.     return(0);      /* word not present */
  1092.     }
  1093. }
  1094.  
  1095.  
  1096. /* now collect the best hits */
  1097. long finished_search_word(db)
  1098.      database *db;
  1099. { 
  1100. #ifdef BOOLEANS
  1101.   long number_of_hits; /* tung, 10/93 */
  1102. #endif /* BOOLEANS */
  1103.  
  1104. #ifdef BOOL
  1105.   if (currentQuery != NULL)
  1106.     return; /* do nothing for boolean */
  1107. #endif /* def BOOL */
  1108.  
  1109. /* tung, 10/93 */
  1110. #ifdef BOOLEANS
  1111.   if((number_of_qwords > 0) && (search_result_array != NULL))
  1112.     number_of_hits = retriev_result(db->doc_table_allocated_entries);
  1113. #endif /* BOOLEANS */
  1114. /* tung, 10/93 */
  1115.  
  1116.   /* check the document_score_array */
  1117.   if(document_score_array_len < db->doc_table_allocated_entries)
  1118.     make_document_score_array(db->doc_table_allocated_entries);
  1119.  
  1120.   make_best_hits_array(max_hit_retrieved);
  1121.   sort_best_hits(db);
  1122.  syn_Free( db->syn_Table,&db->syn_Table_Size );
  1123.  
  1124.   return(0);
  1125. }
  1126.  
  1127.  
  1128.