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