home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / Tools / freeWAIS-sf-1.1 / ir / ztype1.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-05-19  |  8.0 KB  |  341 lines
  1. /* WIDE AREA INFORMATION SERVER SOFTWARE:
  2.    No guarantees or restrictions.  See the readme file for the full standard
  3.    disclaimer.    
  4. */
  5.  
  6. /* Copyright (c) CNIDR (see ../COPYRIGHT) */
  7.  
  8.   
  9. #ifndef lint
  10. static char *RCSid = "$Header: /usr/local/ls6/src+data/src/freeWAIS-0.2-sf/ir/RCS/ztype1.c,v 1.3 1994/05/20 12:58:23 pfeifer Exp $";
  11. #endif
  12.  
  13. /* Change log:
  14.  * $Log: ztype1.c,v $
  15.  * Revision 1.3  1994/05/20  12:58:23  pfeifer
  16.  * beta
  17.  *
  18.  * Revision 1.2  1994/03/08  21:07:24  pfeifer
  19.  * Patchlevel 04
  20.  *
  21.  * Revision 1.1  1993/02/16  15:05:35  freewais
  22.  * Initial revision
  23.  *
  24.  * Revision 1.2  92/02/12  14:00:49  jonathan
  25.  * Added "$Log" so RCS will put the log message in the header
  26.  * 
  27.    3.26.90    Harry Morris, morris@think.com
  28.    4.11.90  HWM - generalized conditional includes (see c-dialect.h)
  29. */
  30.  
  31. #define _C_Type_1_Query_
  32.  
  33. #include "ztype1.h"
  34. #include "cutil.h"
  35. #include "panic.h"
  36. /* #include <string.h> */
  37.  
  38. #ifndef ANSI_LIKE
  39. #include "ustubs.h"
  40. #endif
  41.  
  42. /*----------------------------------------------------------------------*/
  43.  
  44. query_term*
  45. makeAttributeTerm(use,
  46.           relation,
  47.           position,
  48.           structure,
  49.           truncation,
  50.           completeness,
  51.           term)
  52. char* use;
  53. char* relation;
  54. char* position;
  55. char* structure;
  56. char* truncation;
  57. char* completeness;
  58. any* term;
  59. {
  60.   query_term* qt = (query_term*)s_malloc((size_t)sizeof(query_term));
  61.  
  62.   qt->TermType = TT_Attribute;
  63.  
  64.   /* copy in the attributes */
  65.   strncpy(qt->Use,use,ATTRIBUTE_SIZE);
  66.   strncpy(qt->Relation,relation,ATTRIBUTE_SIZE);
  67.   strncpy(qt->Position,position,ATTRIBUTE_SIZE);
  68.   strncpy(qt->Structure,structure,ATTRIBUTE_SIZE);
  69.   strncpy(qt->Truncation,truncation,ATTRIBUTE_SIZE);
  70.   strncpy(qt->Completeness,completeness,ATTRIBUTE_SIZE);
  71.  
  72.   qt->Term = duplicateAny(term);
  73.  
  74.   qt->ResultSetID = NULL;
  75.  
  76.   return(qt);
  77. }
  78.  
  79. /*----------------------------------------------------------------------*/
  80.  
  81. query_term*
  82. makeResultSetTerm(resultSet)
  83. any* resultSet;
  84. { 
  85.   query_term* qt = (query_term*)s_malloc((size_t)sizeof(query_term));
  86.  
  87.   qt->TermType = TT_ResultSetID;
  88.  
  89.   qt->ResultSetID = duplicateAny(resultSet);
  90.  
  91.   qt->Term = NULL;
  92.   
  93.   return(qt);
  94. }
  95.  
  96. /*----------------------------------------------------------------------*/
  97.  
  98. query_term* 
  99. makeOperatorTerm(operatorCode)
  100. char* operatorCode;
  101. {
  102.   query_term* qt = (query_term*)s_malloc((size_t)sizeof(query_term));
  103.  
  104.   qt->TermType = TT_Operator;
  105.  
  106.   strncpy(qt->Operator,operatorCode,OPERATOR_SIZE);
  107.  
  108.   qt->Term = NULL;
  109.   qt->ResultSetID = NULL;
  110.  
  111.   return(qt);
  112. }
  113.  
  114. /*----------------------------------------------------------------------*/
  115.  
  116. void 
  117. freeTerm(qt)
  118. query_term* qt;
  119. {
  120.   switch (qt->TermType)
  121.     { case TT_Attribute:
  122.     freeAny(qt->Term);
  123.     break;
  124.       case TT_ResultSetID:
  125.     freeAny(qt->ResultSetID);
  126.     break;
  127.       case TT_Operator:
  128.     /* do nothing */
  129.     break;
  130.       default:
  131.     panic("Implementation error: Unknown term type %ld",
  132.           qt->TermType);
  133.     break;
  134.       }
  135.   s_free(qt);
  136. }
  137.  
  138. /*----------------------------------------------------------------------*/
  139.  
  140. #define ATTRIBUTE_LIST_SIZE    ATTRIBUTE_SIZE * 6
  141. #define AT_DELIMITER    " "
  142.  
  143. char* 
  144. writeQueryTerm(qt,buffer,len)
  145. query_term* qt;
  146. char* buffer;
  147. long* len;
  148. {
  149.   char* buf = buffer;
  150.   char attributes[ATTRIBUTE_LIST_SIZE];
  151.  
  152.   switch (qt->TermType)
  153.     { case TT_Attribute:
  154.     strncpy(attributes,qt->Use,ATTRIBUTE_LIST_SIZE); 
  155.     s_strncat(attributes,AT_DELIMITER,sizeof(AT_DELIMITER) + 1,ATTRIBUTE_LIST_SIZE);
  156.     s_strncat(attributes,qt->Relation,ATTRIBUTE_SIZE,ATTRIBUTE_LIST_SIZE); 
  157.     s_strncat(attributes,AT_DELIMITER,sizeof(AT_DELIMITER) + 1,ATTRIBUTE_LIST_SIZE);
  158.     s_strncat(attributes,qt->Position,ATTRIBUTE_SIZE,ATTRIBUTE_LIST_SIZE); 
  159.     s_strncat(attributes,AT_DELIMITER,sizeof(AT_DELIMITER) + 1,ATTRIBUTE_LIST_SIZE);
  160.     s_strncat(attributes,qt->Structure,ATTRIBUTE_SIZE,ATTRIBUTE_LIST_SIZE); 
  161.     s_strncat(attributes,AT_DELIMITER,sizeof(AT_DELIMITER) + 1,ATTRIBUTE_LIST_SIZE);
  162.     s_strncat(attributes,qt->Truncation,ATTRIBUTE_SIZE,ATTRIBUTE_LIST_SIZE); 
  163.     s_strncat(attributes,AT_DELIMITER,sizeof(AT_DELIMITER) + 1,ATTRIBUTE_LIST_SIZE);
  164.     s_strncat(attributes,qt->Completeness,ATTRIBUTE_SIZE,ATTRIBUTE_LIST_SIZE);
  165.     buf = writeString(attributes,DT_AttributeList,buf,len);
  166.     buf = writeAny(qt->Term,DT_Term,buf,len);
  167.     break;
  168.       case TT_ResultSetID:
  169.     buf = writeAny(qt->ResultSetID,DT_ResultSetID,buf,len);
  170.     break;
  171.       case TT_Operator:
  172.     buf = writeString(qt->Operator,DT_Operator,buf,len);
  173.     break;
  174.       default:
  175.     panic("Implementation error: Unknown term type %ld",
  176.           qt->TermType);
  177.     break;
  178.       }
  179.  
  180.   return(buf);
  181. }
  182.  
  183. /*----------------------------------------------------------------------*/
  184.  
  185. char* 
  186. readQueryTerm(qt,buffer)
  187. query_term** qt;
  188. char* buffer;
  189. {
  190.   char* buf = buffer;
  191.   char  *attributeList = NULL;
  192.   char* operator = NULL;
  193.   any*     term;
  194.   char* use = NULL;
  195.   char* relation = NULL;
  196.   char* position = NULL;
  197.   char* structure = NULL;
  198.   char* truncation = NULL;
  199.   char* completeness;
  200.   any*    resultSetID = NULL;
  201.   data_tag tag;
  202.  
  203.   
  204.   tag = peekTag(buffer);
  205.  
  206.   switch(tag)
  207.     { case DT_AttributeList:
  208.     buf = readString(&attributeList,buf);
  209.     buf = readAny(&term,buf);
  210.     use = strtok(attributeList,AT_DELIMITER);
  211.     relation = strtok(NULL,AT_DELIMITER);
  212.     position = strtok(NULL,AT_DELIMITER);
  213.     structure = strtok(NULL,AT_DELIMITER);
  214.     truncation = strtok(NULL,AT_DELIMITER);
  215.     completeness = strtok(NULL,AT_DELIMITER);
  216.     *qt = makeAttributeTerm(use,relation,position,structure,
  217.                 truncation,completeness,term);
  218.     s_free(attributeList);
  219.     freeAny(term);
  220.     break;
  221.       case DT_ResultSetID:
  222.     buf = readAny(&resultSetID,buf);
  223.     *qt = makeResultSetTerm(resultSetID);    
  224.     freeAny(resultSetID);
  225.     break;
  226.       case DT_Operator:
  227.     buf = readString(&operator,buf);
  228.     *qt = makeOperatorTerm(operator);
  229.     s_free(operator);
  230.     break;
  231.       default:
  232.     REPORT_READ_ERROR(buf);
  233.     break;
  234.       }
  235.   
  236.   return(buf);
  237. }
  238.  
  239. /*----------------------------------------------------------------------*/
  240.  
  241. static unsigned long getQueryTermSize _AP((query_term* qt));
  242.  
  243. static unsigned long
  244. getQueryTermSize(qt)
  245. query_term* qt;
  246. /* figure out how many bytes it will take to write this query */
  247. {
  248.   unsigned long size;
  249.   static char attributes[] = "11 22 33 44 55 66"; /* we just need this to 
  250.                              calculate its written
  251.                              size */
  252.  
  253.   switch (qt->TermType)
  254.     { case TT_Attribute:
  255.     size = writtenStringSize(DT_AttributeList,attributes);
  256.     size += writtenAnySize(DT_Term,qt->Term);
  257.     break;
  258.       case TT_ResultSetID:
  259.     size = writtenAnySize(DT_ResultSetID,qt->ResultSetID);
  260.     break;
  261.       case TT_Operator:
  262.     size = writtenStringSize(DT_Operator,qt->Operator);
  263.     break;
  264.       default:
  265.     panic("Implementation error: Unknown term type %ld",
  266.           qt->TermType);
  267.     break;
  268.       }
  269.  
  270.   return(size);
  271. }
  272.  
  273. /*----------------------------------------------------------------------*/
  274.  
  275. /* A query is simply a null terminated list of query terms. For 
  276.    transmission, a query is written into an any which is sent as
  277.    the user information field. */
  278.  
  279. any*
  280. writeQuery(terms)
  281. query_term** terms;
  282. {
  283.   any* info = NULL;
  284.   char* writePos = NULL;
  285.   char* data = NULL;
  286.   unsigned long size = 0;
  287.   long remaining = 0;
  288.   long i;
  289.   query_term* qt = NULL;
  290.  
  291.   if (terms == NULL)
  292.     return(NULL);
  293.  
  294.   /* calculate the size of write buffer */
  295.   for (i = 0,qt = terms[i]; qt != NULL; qt = terms[++i])
  296.     size += getQueryTermSize(qt);
  297.  
  298.   data = (char*)s_malloc((size_t)size);
  299.  
  300.   /* write the terms */
  301.   writePos = data;
  302.   remaining = size;
  303.   for (i = 0,qt = terms[i]; qt != NULL; qt = terms[++i])
  304.     writePos = writeQueryTerm(qt,writePos,&remaining);
  305.  
  306.   info = makeAny(size,data);
  307.  
  308.   return(info);
  309. }
  310.  
  311. /*----------------------------------------------------------------------*/
  312.  
  313. query_term**
  314. readQuery(info)
  315. any *info;
  316. {
  317.   char* readPos = info->bytes;
  318.   query_term** terms = NULL;
  319.   query_term* qt = NULL;
  320.   long numTerms = 0;
  321.  
  322.  
  323.   while (readPos < info->bytes + info->size)
  324.     { readPos = readQueryTerm(&qt,readPos);
  325.       if (terms == NULL)
  326.     { terms = (query_term**)s_malloc((size_t)(sizeof(query_term*)*2));
  327.     }
  328.       else
  329.     { terms = 
  330.         (query_term**)s_realloc((char*)terms,
  331.                     (size_t)(sizeof(query_term*)*(numTerms+2)));
  332.       }
  333.       terms[numTerms++] = qt;
  334.       terms[numTerms] = NULL;
  335.     }
  336.  
  337.   return(terms);
  338. }
  339.  
  340. /*----------------------------------------------------------------------*/
  341.