htvms_waisprot.c

elinks下lynx是最重要的二个文本浏览器, 在linux下非常实用, lynx比elinks早的多, 目前好像停止开发, 这是lynx源代码

static void
cleanUpWaisSearchResponse PARAMS((char* buf,char* seedWordsUsed,
			       WAISDocumentHeader** docHeaders,
			       WAISDocumentShortHeader** shortHeaders,
			       WAISDocumentLongHeader** longHeaders,
			       WAISDocumentText** text,
			       WAISDocumentHeadlines** headlines,
			       WAISDocumentCodes** codes,
			       diagnosticRecord**diags));

static void
cleanUpWaisSearchResponse (buf,seedWordsUsed,docHeaders,shortHeaders,
			   longHeaders,text,headlines,codes,diags)
char* buf;
char* seedWordsUsed;
WAISDocumentHeader** docHeaders;
WAISDocumentShortHeader** shortHeaders;
WAISDocumentLongHeader** longHeaders;
WAISDocumentText** text;
WAISDocumentHeadlines** headlines;
WAISDocumentCodes** codes;
diagnosticRecord** diags;
/* if buf is NULL, we have just gotten a read error, and need to clean up
   any state we have built.  If not, then everything is going fine, and
   we should just hang loose
 */
{
  void* ptr = NULL;
  long i;

  if (buf == NULL)
   { s_free(seedWordsUsed);
     if (docHeaders != NULL)
       for (i = 0,ptr = (void *)docHeaders[i]; ptr != NULL;
	    ptr = (void *)docHeaders[++i])
	 freeWAISDocumentHeader((WAISDocumentHeader*)ptr);
     s_free(docHeaders);
     if (shortHeaders != NULL)
       for (i = 0,ptr = (void *)shortHeaders[i]; ptr != NULL;
	    ptr = (void *)shortHeaders[++i])
	 freeWAISDocumentShortHeader((WAISDocumentShortHeader*)ptr);
     s_free(shortHeaders);
     if (longHeaders != NULL)
       for (i = 0,ptr = (void *)longHeaders[i]; ptr != NULL;
	    ptr = (void *)longHeaders[++i])
	 freeWAISDocumentLongHeader((WAISDocumentLongHeader*)ptr);
     s_free(longHeaders);
     if (text != NULL)
       for (i = 0,ptr = (void *)text[i]; ptr != NULL; ptr = (void *)text[++i])
	 freeWAISDocumentText((WAISDocumentText*)ptr);
     s_free(text);
     if (headlines != NULL)
       for (i = 0,ptr = (void *)headlines[i]; ptr != NULL;
	    ptr = (void *)headlines[++i])
	 freeWAISDocumentHeadlines((WAISDocumentHeadlines*)ptr);
     s_free(headlines);
     if (codes != NULL)
       for (i = 0,ptr = (void *)codes[i]; ptr != NULL;
	    ptr = (void *)codes[++i])
	 freeWAISDocumentCodes((WAISDocumentCodes*)ptr);
     s_free(codes);
     if (diags != NULL)
       for (i = 0,ptr = (void *)diags[i]; ptr != NULL;
	    ptr = (void *)diags[++i])
	 freeDiag((diagnosticRecord*)ptr);
     s_free(diags);
   }
}

/*----------------------------------------------------------------------*/

char*
readSearchResponseInfo(info,buffer)
void** info;
char* buffer;
{
  char* buf = buffer;
  unsigned long size;
  unsigned long headerSize;
  data_tag tag1;
  void* header = NULL;
  WAISDocumentHeader** docHeaders = NULL;
  WAISDocumentShortHeader** shortHeaders = NULL;
  WAISDocumentLongHeader** longHeaders = NULL;
  WAISDocumentText** text = NULL;
  WAISDocumentHeadlines** headlines = NULL;
  WAISDocumentCodes** codes = NULL;
  long numDocHeaders,numLongHeaders,numShortHeaders,numText,numHeadlines;
  long numCodes;
  char* seedWordsUsed = NULL;
  diagnosticRecord** diags = NULL;
  diagnosticRecord* diag = NULL;
  long numDiags = 0;

  numDocHeaders = numLongHeaders = numShortHeaders = numText = numHeadlines = numCodes = 0;

  buf = readUserInfoHeader(&tag1,&size,buf);
  headerSize = buf - buffer;

  while (buf < (buffer + size + headerSize))
   { data_tag tag = peekTag(buf);
     switch (tag)
      { case DT_SeedWordsUsed:
	  buf = readString(&seedWordsUsed,buf);
	  break;
	case DT_DatabaseDiagnosticRecords:
	  if (diags == NULL) /* create a new diag list */
	   { diags = (diagnosticRecord**)s_malloc((size_t)sizeof(diagnosticRecord*) * 2);
	   }
	  else /* grow the diag list */
	   { diags = (diagnosticRecord**)s_realloc((char*)diags,(size_t)(sizeof(diagnosticRecord*) * (numDiags + 2)));
	   }
	  buf = readDiag(&diag,buf);
	  diags[numDiags++] = diag; /* put it in the list */
	  diags[numDiags] = NULL;
	  break;
	case DT_DocumentHeaderGroup:
		  if (docHeaders == NULL) /* create a new header list */
		   { docHeaders = (WAISDocumentHeader**)s_malloc((size_t)sizeof(WAISDocumentHeader*) * 2);
		   }
		  else /* grow the doc list */
		   { docHeaders = (WAISDocumentHeader**)s_realloc((char*)docHeaders,(size_t)(sizeof(WAISDocumentHeader*) * (numDocHeaders + 2)));
		   }
		  buf = readWAISDocumentHeader((WAISDocumentHeader**)&header,buf);
		  cleanUpWaisSearchResponse(buf,seedWordsUsed,docHeaders,shortHeaders,longHeaders,text,headlines,codes,diags);
		  RETURN_ON_NULL(buf);
		  docHeaders[numDocHeaders++] =
		    (WAISDocumentHeader*)header; /* put it in the list */
		  docHeaders[numDocHeaders] = NULL;
		  break;
		case DT_DocumentShortHeaderGroup:
		  if (shortHeaders == NULL) /* create a new header list */
		   { shortHeaders = (WAISDocumentShortHeader**)s_malloc((size_t)sizeof(WAISDocumentShortHeader*) * 2);
		   }
		  else /* grow the doc list */
		   { shortHeaders = (WAISDocumentShortHeader**)s_realloc((char*)shortHeaders,(size_t)(sizeof(WAISDocumentShortHeader*) * (numShortHeaders + 2)));
		   }
		  buf = readWAISDocumentShortHeader((WAISDocumentShortHeader**)&header,buf);
		  cleanUpWaisSearchResponse(buf,seedWordsUsed,docHeaders,shortHeaders,longHeaders,text,headlines,codes,diags);
		  RETURN_ON_NULL(buf);
		  shortHeaders[numShortHeaders++] =
		    (WAISDocumentShortHeader*)header; /* put it in the list */
		  shortHeaders[numShortHeaders] = NULL;
		  break;
		case DT_DocumentLongHeaderGroup:
		  if (longHeaders == NULL) /* create a new header list */
		   { longHeaders = (WAISDocumentLongHeader**)s_malloc((size_t)sizeof(WAISDocumentLongHeader*) * 2);
		   }
		  else /* grow the doc list */
		   { longHeaders = (WAISDocumentLongHeader**)s_realloc((char*)longHeaders,(size_t)(sizeof(WAISDocumentLongHeader*) * (numLongHeaders + 2)));
		   }
		  buf = readWAISDocumentLongHeader((WAISDocumentLongHeader**)&header,buf);
		  cleanUpWaisSearchResponse(buf,seedWordsUsed,docHeaders,shortHeaders,longHeaders,text,headlines,codes,diags);
		  RETURN_ON_NULL(buf);
		  longHeaders[numLongHeaders++] =
		    (WAISDocumentLongHeader*)header; /* put it in the list */
		  longHeaders[numLongHeaders] = NULL;
		  break;
	case DT_DocumentTextGroup:
		  if (text == NULL) /* create a new list */
		   { text = (WAISDocumentText**)s_malloc((size_t)sizeof(WAISDocumentText*) * 2);
		   }
		  else /* grow the list */
		   { text = (WAISDocumentText**)s_realloc((char*)text,(size_t)(sizeof(WAISDocumentText*) * (numText + 2)));
		   }
		  buf = readWAISDocumentText((WAISDocumentText**)&header,buf);
		  cleanUpWaisSearchResponse(buf,seedWordsUsed,docHeaders,shortHeaders,longHeaders,text,headlines,codes,diags);
		  RETURN_ON_NULL(buf);
		  text[numText++] =
		    (WAISDocumentText*)header; /* put it in the list */
		  text[numText] = NULL;
		  break;
		case DT_DocumentHeadlineGroup:
		  if (headlines == NULL) /* create a new list */
		   { headlines = (WAISDocumentHeadlines**)s_malloc((size_t)sizeof(WAISDocumentHeadlines*) * 2);
		   }
		  else /* grow the list */
		   { headlines = (WAISDocumentHeadlines**)s_realloc((char*)headlines,(size_t)(sizeof(WAISDocumentHeadlines*) * (numHeadlines + 2)));
		   }
		  buf = readWAISDocumentHeadlines((WAISDocumentHeadlines**)&header,buf);
		  cleanUpWaisSearchResponse(buf,seedWordsUsed,docHeaders,shortHeaders,longHeaders,text,headlines,codes,diags);
		  RETURN_ON_NULL(buf);
		  headlines[numHeadlines++] =
		    (WAISDocumentHeadlines*)header; /* put it in the list */
		  headlines[numHeadlines] = NULL;
		  break;
		case DT_DocumentCodeGroup:
		  if (codes == NULL) /* create a new list */
		   { codes = (WAISDocumentCodes**)s_malloc((size_t)sizeof(WAISDocumentCodes*) * 2);
		   }
		  else /* grow the list */
		   { codes = (WAISDocumentCodes**)s_realloc((char*)codes,(size_t)(sizeof(WAISDocumentCodes*) * (numCodes + 2)));
		   }
		  buf = readWAISDocumentCodes((WAISDocumentCodes**)&header,buf);
		  cleanUpWaisSearchResponse(buf,seedWordsUsed,docHeaders,shortHeaders,longHeaders,text,headlines,codes,diags);
		  RETURN_ON_NULL(buf);
		  codes[numCodes++] =
		    (WAISDocumentCodes*)header; /* put it in the list */
		  codes[numCodes] = NULL;
		  break;
	default:
	  cleanUpWaisSearchResponse(buf,seedWordsUsed,docHeaders,shortHeaders,longHeaders,text,headlines,codes,diags);
	  REPORT_READ_ERROR(buf);
	  break;
      }
   }

  *info = (void *)makeWAISSearchResponse(seedWordsUsed,docHeaders,shortHeaders,
				 longHeaders,text,headlines,codes,diags);

  return(buf);
}

/*----------------------------------------------------------------------*/

WAISDocumentText*
makeWAISDocumentText(docID,versionNumber,documentText)
any* docID;
long versionNumber;
any* documentText;
{
  WAISDocumentText* docText = (WAISDocumentText*)s_malloc((size_t)sizeof(WAISDocumentText));

  docText->DocumentID = docID;
  docText->VersionNumber = versionNumber;
  docText->DocumentText = documentText;

  return(docText);
}

/*----------------------------------------------------------------------*/

void
freeWAISDocumentText(docText)
WAISDocumentText* docText;
{
  freeAny(docText->DocumentID);
  freeAny(docText->DocumentText);
  s_free(docText);
}

/*----------------------------------------------------------------------*/

char*
writeWAISDocumentText(docText,buffer,len)
WAISDocumentText* docText;
char* buffer;
long* len;
{
  unsigned long header_len = userInfoTagSize(DT_DocumentTextGroup,
											DefWAISDocTextSize);
  char* buf = buffer + header_len;
  unsigned long size;

  RESERVE_SPACE_FOR_WAIS_HEADER(len);

  buf = writeAny(docText->DocumentID,DT_DocumentID,buf,len);
  buf = writeNum(docText->VersionNumber,DT_VersionNumber,buf,len);
  buf = writeAny(docText->DocumentText,DT_DocumentText,buf,len);

  /* now write the header and size */
  size = buf - buffer;
  buf = writeUserInfoHeader(DT_DocumentTextGroup,size,header_len,buffer,len);

  return(buf);
}

/*----------------------------------------------------------------------*/

char*
readWAISDocumentText(docText,buffer)
WAISDocumentText** docText;
char* buffer;
{
  char* buf = buffer;
  unsigned long size;
  unsigned long headerSize;
  data_tag tag1;
  any *docID,*documentText;
  long versionNumber;

  docID = documentText = NULL;
  versionNumber = UNUSED;

  buf = readUserInfoHeader(&tag1,&size,buf);
  headerSize = buf - buffer;

  while (buf < (buffer + size + headerSize))
   { data_tag tag = peekTag(buf);
     switch (tag)
      { case DT_DocumentID:
		  buf = readAny(&docID,buf);
		  break;
		case DT_VersionNumber:
		  buf = readNum(&versionNumber,buf);
		  break;
		case DT_DocumentText:
		  buf = readAny(&documentText,buf);
		  break;
	default:
	  freeAny(docID);
	  freeAny(documentText);
	  REPORT_READ_ERROR(buf);
	  break;
      }
   }

  *docText = makeWAISDocumentText(docID,versionNumber,documentText);
  return(buf);
}

/*----------------------------------------------------------------------*/

WAISDocumentHeadlines*
makeWAISDocumentHeadlines(docID,
			  versionNumber,
			  source,
			  date,
			  headline,
			  originCity)
any* docID;
long versionNumber;
char* source;
char* date;
char* headline;
char* originCity;
{
  WAISDocumentHeadlines* docHeadline =
    (WAISDocumentHeadlines*)s_malloc((size_t)sizeof(WAISDocumentHeadlines));

  docHeadline->DocumentID = docID;
  docHeadline->VersionNumber = versionNumber;
  docHeadline->Source = source;
  docHeadline->Date = date;
  docHeadline->Headline = headline;
  docHeadline->OriginCity = originCity;

  return(docHeadline);
}

/*----------------------------------------------------------------------*/

void
freeWAISDocumentHeadlines(docHeadline)
WAISDocumentHeadlines* docHeadline;
{
  freeAny(docHeadline->DocumentID);
  s_free(docHeadline->Source);
  s_free(docHeadline->Date);
  s_free(docHeadline->Headline);
  s_free(docHeadline->OriginCity);
  s_free(docHeadline);
}

/*----------------------------------------------------------------------*/

char*
writeWAISDocumentHeadlines(docHeadline,buffer,len)
WAISDocumentHeadlines* docHeadline;
char* buffer;
long* len;
{
  unsigned long header_len = userInfoTagSize(DT_DocumentHeadlineGroup,
											DefWAISDocHeadlineSize);
  char* buf = buffer + header_len;
  unsigned long size;

  RESERVE_SPACE_FOR_WAIS_HEADER(len);

  buf = writeAny(docHeadline->DocumentID,DT_DocumentID,buf,len);
  buf = writeNum(docHeadline->VersionNumber,DT_VersionNumber,buf,len);
  buf = writeString(docHeadline->Source,DT_Source,buf,len);
  buf = writeString(docHeadline->Date,DT_Date,buf,len);
  buf = writeString(docHeadline->Headline,DT_Headline,buf,len);
  buf = writeString(docHeadline->OriginCity,DT_OriginCity,buf,len);

  /* now write the header and size */
  size = buf - buffer;
  buf = writeUserInfoHeader(DT_DocumentHeadlineGroup,size,header_len,buffer,len);

  return(buf);
}

/*----------------------------------------------------------------------*/

char*
readWAISDocumentHeadlines(docHeadline,buffer)
WAISDocumentHeadlines** docHeadline;
char* buffer;
{
  char* buf = buffer;
  unsigned long size;
  unsigned long headerSize;
  data_tag tag1;
  any* docID;
  long versionNumber;
  char *source,*date,*headline,*originCity;

  docID = NULL;
  versionNumber = UNUSED;
  source = date = headline = originCity = NULL;

  buf = readUserInfoHeader(&tag1,&size,buf);
  headerSize = buf - buffer;

  while (buf < (buffer + size + headerSize))
   { data_tag tag = peekTag(buf);
     switch (tag)
      { case DT_DocumentID:
		  buf = readAny(&docID,buf);
		  break;
		case DT_VersionNumber:
		  buf = readNum(&versionNumber,buf);
		  break;
		case DT_Source:
		  buf = readString(&source,buf);
		  break;
		case DT_Date:
		  buf = readString(&date,buf);
		  break;
		case DT_Headline:
		  buf = readString(&headline,buf);
		  break;
		case DT_OriginCity:
		  buf = readString(&originCity,buf);
		  break;
	default:
	  freeAny(docID);
	  s_free(source);
	  s_free(date);
	  s_free(headline);
	  s_free(originCity);
	  REPORT_READ_ERROR(buf);
	  break;
      }
   }

  *docHeadline = makeWAISDocumentHeadlines(docID,versionNumber,source,date,
									       headline,originCity);
  return(buf);
}

/*----------------------------------------------------------------------*/

WAISDocumentCodes*
makeWAISDocumentCodes(docID,
		      versionNumber,
		      stockCodes,
		      companyCodes,
		      industryCodes)
any* docID;
long versionNumber;
char* stockCodes;
char* companyCodes;
char* industryCodes;
{
  WAISDocumentCodes* docCodes = (WAISDocumentCodes*)s_malloc((size_t)sizeof(WAISDocumentCodes));

  docCodes->DocumentID = docID;
  docCodes->VersionNumber = versionNumber;
  docCodes->StockCodes = stockCodes;
  docCodes->CompanyCodes = companyCodes;
  docCodes->IndustryCodes = industryCodes;

  return(docCodes);
}