home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / Tools / freeWAIS-sf-1.1 / ir / cutil.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-09-08  |  27.1 KB  |  1,227 lines
  1.  
  2. /* Copyright (c) CNIDR (Work in progress) */
  3.  
  4. /* Wide AREA INFORMATION SERVER SOFTWARE    
  5.    No guarantees or restrictions.  See the readme file for the full standard
  6.    disclaimer.  
  7.   
  8.    3.26.90    Harry Morris, morris@think.com
  9.    4.11.90  HWM - generalized conditional includes (see c-dialect.h)
  10.    7/19/91  speed up substrcmp by ses@ccgr.technion.ac.il (Simon E Spero)
  11.  *
  12.  * $Log: cutil.c,v $
  13.  * Revision 1.21  1994/09/08  16:43:14  pfeifer
  14.  * removed dead code (was ifdef'ed AUTOCONF)
  15.  *
  16.  * Revision 1.20  1994/09/02  14:34:21  pfeifer
  17.  * fixed overlapping memory copies
  18.  *
  19.  * Revision 1.19  1994/08/08  07:31:52  pfeifer
  20.  * Moved wais_log_file_name and waislogfile to cutil.[ch]
  21.  *
  22.  * Revision 1.17  1994/06/13  10:40:39  pfeifer
  23.  * replaced strdup by function provided by Kent C Brodie
  24.  * <kcb@post.its.mcw.edu>
  25.  *
  26.  * Revision 1.16  1994/06/10  12:49:48  pfeifer
  27.  * typo
  28.  *
  29.  * Revision 1.15  1994/06/10  08:22:43  pfeifer
  30.  * bad typo
  31.  *
  32.  * Revision 1.14  1994/06/10  08:15:24  pfeifer
  33.  * added definition for strdup, wich is missing with solaris 2.3 ?
  34.  *
  35.  * Revision 1.13  1994/05/21  14:35:24  pfeifer
  36.  * initalize memory, in fs_realloc if it is really an malloc (should be
  37.  * obsolete :-( )
  38.  *
  39.  * Revision 1.12  1994/05/20  12:55:43  pfeifer
  40.  * beta
  41.  *
  42.  * Revision 1.11  1994/03/23  15:30:58  pfeifer
  43.  * fixed iso code
  44.  *
  45.  * Revision 1.10  1994/03/08  20:57:40  pfeifer
  46.  * Patchlevel 04
  47.  *
  48.  * Revision 1.9  1993/09/22  16:07:52  pfeifer
  49.  * Fixed word breaking for german ISO Umlaute and sz
  50.  *
  51.  * Revision 1.8  1993/07/16  12:10:19  huynh1
  52.  * Function generate_newline_for_boolean deleted!
  53.  *
  54.  * Revision 1.7  1993/07/14  09:52:38  huynh1
  55.  * keine "Anderung!
  56.  *
  57.  * Revision 1.6  1993/07/14  07:30:24  huynh1
  58.  * "Anderung in der Funktion generate_newline_for_boolean: Variable umbenannt: brackets = parentheses!
  59.  *
  60.  * Revision 1.5  1993/07/13  19:14:43  huynh1
  61.  * printf(".....") gel"oscht!
  62.  *
  63.  * Revision 1.4  1993/07/13  18:44:04  huynh1
  64.  * Keine "Anderung!
  65.  *
  66.  * Revision 1.3  1993/07/13  18:40:31  huynh1
  67.  * funktion generate_newline_for_boolean eingef"ugt!
  68.  *
  69.  * Revision 1.2  1993/02/16  14:59:21  freewais
  70.  * include stdargs.h or varargs.h based on whether compiler
  71.  * is ansi or non-ansi
  72.  *
  73.  * Revision 1.1  1993/02/16  14:53:14  freewais
  74.  * Initial revision
  75.  *
  76.  * Revision 1.24  92/03/28  19:53:39  jonathan
  77.  * Removed useless ifdef BSD in cprintf
  78.  * 
  79.  * Revision 1.23  92/03/07  19:44:39  jonathan
  80.  * ANSIfied arguments.
  81.  * 
  82.  * Revision 1.22  92/03/04  16:14:23  jonathan
  83.  * Added include <ctype.h> for isalnum.
  84.  * 
  85.  * Revision 1.21  92/02/21  11:03:15  jonathan
  86.  * Fixed $Log.
  87.  * 
  88.  * Revision 1.20  92/02/21  11:02:02  jonathan
  89.  * Added wais_log_level, RCSIdent
  90.  * 
  91.  * Revision 1.19  92/02/16  21:24:54  jonathan
  92.  * Added code for vprintf, if needed (like for old BSD).
  93.  * 
  94.  * Revision 1.18  92/02/12  14:33:26  morris
  95.  * made string_downcase not die when passed NULL
  96.  * 
  97.  * Revision 1.17  92/02/12  13:16:21  jonathan
  98.  * Added $Log so RCS will put the log message in the header
  99.  * 
  100.  *
  101. */
  102.  
  103. #ifndef lint
  104. static char *RCSid = "$Header: /usr/local/ls6/src+data/src/freeWAIS-sf/ir/RCS/cutil.c,v 1.21 1994/09/08 16:43:14 pfeifer Exp $";
  105. #endif
  106.  
  107. #define _C_C_util_
  108.  
  109. #include "cutil.h"
  110. #include "panic.h"
  111.  
  112. #include <ctype.h>
  113. /*----------------------------------------------------------------------*/
  114.  
  115. /* #define MEMORY_ACCOUNTING */
  116.  
  117. #ifdef MEMORY_ACCOUNTING
  118. #include "futil.h"
  119. #undef s_checkPtr
  120. #define s_checkPtr(ptr) fs_checkPtr(ptr)
  121. static FILE* memRecord = NULL;
  122. static void prepMemAcct _AP((void));
  123. static void 
  124. prepMemAcct()
  125. {
  126.   if (memRecord == NULL)
  127.     memRecord = s_fopen("MemoryAccounting","w");
  128. }
  129. static void flushMemAcct _AP((void));
  130. static void 
  131. flushMemAcct()
  132. {
  133.   fflush(memRecord);
  134. }
  135. #define tickles 0
  136. static char*     badPtr    = (char*)-1;
  137. static size_t    badSize    = -1;
  138. #endif /* def MEMORY_ACCOUNTING */
  139.  
  140. /*----------------------------------------------------------------------*/
  141.  
  142. void
  143. fs_checkPtr(ptr)
  144. void* ptr;
  145. /* If the ptr is NULL, give an error */
  146. { 
  147. #ifdef MEMORY_ACCOUNTING
  148. static char** ptrs = NULL;
  149. long i;
  150. static Boolean  doneSetup = false;
  151. if (doneSetup == false)
  152. {
  153. #ifdef THINK_C
  154. Debugger();
  155. #endif /* def THINK_C */
  156. doneSetup = true;
  157. }
  158. #endif /* def MEMORY_ACCOUNTING */
  159.  
  160.   if (ptr == NULL)
  161.     panic("checkPtr found a NULL pointer");
  162.  
  163. #ifdef MEMORY_ACCOUNTING
  164. /* look for specific ptr (useful when tracking un-freed memory) */
  165. if (ptr == badPtr) warn("checking found bad ptr"); 
  166. /* tickle a memory bug */
  167. if (ptrs == NULL && tickles > 0)
  168.   ptrs = (char**)malloc((size_t)tickles * sizeof(char*));
  169. for (i = 0; i < tickles; i++)
  170. { ptrs[i] = malloc((size_t)5);
  171. }
  172. for (i = 0; i < tickles; i++)
  173. { free(ptrs[i]);
  174. }
  175. #endif /* def MEMORY_ACCOUNTING */
  176.  
  177. }
  178.  
  179. /*----------------------------------------------------------------------*/
  180.  
  181. void*
  182. fs_malloc(size)
  183. size_t size;
  184. /* does safety checks and optional accounting */
  185. { 
  186.   register void* ptr = NULL;
  187.  
  188.   if(!size) return(NULL);
  189.  
  190. #ifdef THINK_C
  191.   ptr = (void*)NewPtr((long)size);
  192.   s_checkPtr(ptr);
  193.   memset(ptr,0,(size_t)size);    /* zero it */
  194. #else  
  195.   ptr = NULL;
  196.   ptr = (void*)calloc((size_t)size,(size_t)1);
  197.   s_checkPtr(ptr);
  198. #endif
  199.   
  200. #ifdef MEMORY_ACCOUNTING
  201.   /* look for specific size (useful when tracking un-freed memory) */
  202.   if (size == badSize)
  203.     warn("bad size in malloc");
  204.   
  205.   prepMemAcct();
  206.   fprintf(memRecord,"malloced %lu bytes at %lu\n",size,ptr);
  207.   flushMemAcct();
  208. #endif
  209.  
  210.   return(ptr);
  211. }
  212.  
  213. /*----------------------------------------------------------------------*/
  214.  
  215. void*
  216. fs_realloc(ptr,size)
  217. void* ptr;
  218. size_t size;
  219. /* does safety checks and optional accounting 
  220.    note - we don't know how big ptr's memory is, so we can't ensure
  221.    that any new memory allocated is NULLed!
  222.  */
  223. { 
  224.   register void* nptr = NULL;
  225.   
  226.   if (ptr == NULL) {        /* this is really a malloc */
  227.     nptr = s_malloc(size);      /* Initialize (up) */
  228.     if (nptr != NULL) bzero(nptr,size);
  229.     return(nptr);
  230.   }
  231. #ifdef THINK_C
  232.   nptr = NewPtr(size);        /* need to make a copy */ 
  233.   s_checkPtr(nptr);
  234.   BlockMove(ptr,nptr,size);    /* move the old contents into it */
  235.   DisposPtr(ptr);            /* get rid of the old ones */
  236. #else
  237.   nptr = (void*)realloc(ptr,size);
  238.   s_checkPtr(ptr);
  239. #endif  
  240.    
  241. #ifdef MEMORY_ACCOUNTING
  242.   /* look for specific size (useful when tracking un-freed memory) */
  243.   if (size == badSize) 
  244.     warn("bad size in realloc");
  245.   
  246.   prepMemAcct();
  247.   fprintf(memRecord,"realloced %lu bytes at %lu from %lu\n",size,nptr,ptr);
  248.   flushMemAcct();
  249. #endif
  250.  
  251.   return(nptr);
  252. }
  253.  
  254. /*----------------------------------------------------------------------*/
  255.  
  256. void
  257. fs_free(ptr)
  258. void* ptr;
  259. /* does safety checks and optional accounting */
  260. {
  261. #ifdef MEMORY_ACCOUNTING
  262.   prepMemAcct();
  263.   /* note that the sizeof a pointer is always 4.  If only we could find out
  264.      how much space that pointer was pointing to.  Oh well, this is a place
  265.      holder for now
  266.    */
  267.   fprintf(memRecord,"freed %lu bytes at %lu\n",(size_t)sizeof(ptr),ptr);
  268.   flushMemAcct();
  269.  
  270.   /* look for specific ptr (useful when tracking un-freed memory) */
  271.   if (ptr == badPtr) warn("bad ptr in free");
  272. #endif
  273.  
  274.   if (ptr != NULL)        /* some non-ansi compilers/os's cant handle freeing null */
  275.     {                /* if we knew the size of this block of memory, we could clear it - oh well */
  276. #ifdef THINK_C
  277.       DisposPtr(ptr);
  278. #else
  279.       free(ptr);
  280. #endif
  281.     }
  282. }
  283.  
  284. /*----------------------------------------------------------------------*/
  285.  
  286. char*
  287. s_strdup(s)
  288. char* s;
  289.  
  290. /* return a copy of s.  This is identical to the standard library routine
  291.    strdup(), except that it is safe.  If s == NULL or malloc fails, 
  292.    appropriate action is taken.
  293.  */
  294. {
  295.   unsigned long len;
  296.   char* copy = NULL;
  297.   
  298.   if (s == NULL)        /* saftey check to postpone stupid errors */
  299.     return(NULL);
  300.     
  301.   len = strlen(s);        /* length of string - terminator */
  302.   copy = (char*)s_malloc((size_t)(sizeof(char)*(len + 1)));
  303.   strncpy(copy,s,len + 1);
  304.   return(copy);
  305. }
  306.  
  307. /*----------------------------------------------------------------------*/
  308.  
  309. char*
  310. fs_strncat(dst,src,maxToAdd,maxTotal)
  311. char* dst;
  312.    char* src;
  313.    size_t maxToAdd;
  314.    size_t maxTotal;
  315.  
  316. /* like strncat, except the fourth argument limits the maximum total 
  317.    length of the resulting string
  318.  */
  319. {
  320.   size_t dstSize = strlen(dst);
  321.   size_t srcSize = strlen(src);
  322.   
  323.   if (dstSize + srcSize < maxTotal) /* use regular old strncat */
  324.     return(strncat(dst,src,maxToAdd));
  325.   else
  326.     { size_t truncateTo = maxTotal - dstSize - 1;
  327.       char   saveChar;
  328.       char*  result = NULL;
  329.  
  330.       saveChar = src[truncateTo];
  331.       src[truncateTo] = '\0';
  332.       result = strncat(dst,src,maxToAdd);
  333.       src[truncateTo] = saveChar;
  334.       return(result);
  335.     }
  336. }
  337.  
  338. /*----------------------------------------------------------------------*/
  339.  
  340. char*
  341. fs_strncpy(s1, s2, n)
  342.      char* s1;
  343.      char* s2;
  344.      long n;
  345. /* like strncpy except that it guarentees that the destination string ends with a NULL at position n.
  346.  */
  347. {
  348.   s1[n-1] = '\0';
  349.   return(strncpy(s1, s2, n - 1));
  350. }
  351.  
  352. /*----------------------------------------------------------------------*/
  353.  
  354. boolean 
  355. wordbreak_notalnum(ch)        /* dgg */
  356. long   ch;
  357. {   
  358.     return( !isalnum(ch));
  359. }
  360.  
  361. boolean 
  362. wordbreak_notgraph(ch)        /* dgg */
  363. long   ch;
  364. {   
  365.     return( !isgraph(ch));
  366. }
  367.  
  368. boolean wordbreak_user(c)
  369. long c;
  370. {
  371.   if ( (gDelimiters[0] != '\0') && (strchr(gDelimiters, (char) c) != NULL) )
  372.     return(IS_DELIMITER);  
  373.   else if (isgraph(c))
  374.     return(NOT_DELIMITER);
  375.   else
  376.     return(IS_DELIMITER);
  377. }
  378.  
  379. typedef boolean (boolfunc) _AP((long c));
  380.  
  381. char*
  382. strtokf(s1,isDelimiter)
  383. char* s1;
  384. boolfunc *isDelimiter; /* really *isDelimiter() */
  385.  
  386. /* This function is exactly like strtok, except that instead of passing a 
  387.    delimiter string, you pass a function that decides if a character is 
  388.    a delimiter or not, returning IS_DELIMITER or NOT_DELIMITER respecively.
  389.    Note that passing a NULL delimiter function will cause the last delimiter
  390.    to be used.
  391.  */
  392. {
  393.   static char* searchStr = NULL;
  394.   static boolfunc *delimiterFunc;
  395.   long i;
  396.   char* startTok = NULL;
  397.  
  398.   if (s1 != NULL)        /* passing s1 = NULL says use the last pos */
  399.     searchStr = s1;
  400.     
  401.   if (isDelimiter != NULL)
  402.     delimiterFunc = isDelimiter;
  403.    
  404.   if (searchStr == NULL || searchStr[0] == '\0')
  405.     return(NULL);        /* nothing left to search */
  406.     
  407.   if (delimiterFunc == NULL)
  408.     return(NULL);        /* no delimiter to search with */
  409.     
  410.   /* find the start of the next token */
  411.   for (i = 0; searchStr[i] != '\0'; i++)
  412.     { if ((*delimiterFunc)((long)searchStr[i]) == NOT_DELIMITER)
  413.     break;
  414.     }
  415.   
  416.   if (searchStr[i] == '\0') 
  417.     return(NULL);        /* read to end of search string */
  418.   else
  419.     startTok = searchStr + i;    /* remember the starting point for this token*/
  420.     
  421.   /* find the end of the next token */
  422.   for (; searchStr[i] != '\0'; i++)
  423.     { if ((*delimiterFunc)((long)searchStr[i]) == IS_DELIMITER)
  424.     break;
  425.     }
  426.    
  427.   /* if the end is a delimiter (and not just the end of the search string)
  428.      replace it with '\0', and put searchStr just beyond it, otherwise
  429.      put searchStr at the terminator. */
  430.   if (searchStr[i] != '\0')
  431.     { searchStr[i] = '\0';
  432.       searchStr = searchStr + i + 1;
  433.     }
  434.   else
  435.     searchStr = searchStr + i;
  436.    
  437.   return(startTok);
  438. }
  439.  
  440. /*----------------------------------------------------------------------*/
  441.  
  442. char*
  443. strtokf_isalnum(s1)
  444. char* s1;
  445.  
  446. /* 
  447.   This is a partially evaluated version of strtok_f
  448.  */
  449. {
  450.   static char* searchStr = NULL;
  451.   long i;
  452.   char* startTok = NULL;
  453.  
  454.   if (s1 != NULL)        /* passing s1 = NULL says use the last pos */
  455.     searchStr = s1;
  456.     
  457.    
  458.   if (searchStr == NULL || searchStr[0] == '\0')
  459.     return(NULL);        /* nothing left to search */
  460.     
  461.     
  462.   /* find the start of the next token */
  463.   for (i = 0; searchStr[i] != '\0'; i++)
  464.     { if (isalnum(searchStr[i]))
  465.     break;
  466.     }
  467.   
  468.   if (searchStr[i] == '\0') 
  469.     return(NULL);        /* read to end of search string */
  470.   else
  471.     startTok = searchStr + i;    /* remember the starting point for this token*/
  472.     
  473.   /* find the end of the next token */
  474.   for (; searchStr[i] != '\0'; i++)
  475.     { if (!isalnum(searchStr[i]))
  476.     break;
  477.     }
  478.    
  479.   /* if the end is a delimiter (and not just the end of the search string)
  480.      replace it with '\0', and put searchStr just beyond it, otherwise
  481.      put searchStr at the terminator. */
  482.   if (searchStr[i] != '\0')
  483.     { searchStr[i] = '\0';
  484.       searchStr = searchStr + i + 1;
  485.     }
  486.   else
  487.     searchStr = searchStr + i;
  488.    
  489.   return(startTok);
  490. }
  491.  
  492. /*----------------------------------------------------------------------*/
  493.  
  494. #ifdef ANSI_LIKE /* use ansi varargs */
  495.  
  496. long
  497. cprintf(boolean print, char* format, ...)
  498. /* just like printf, but only prints if the first argument = 1 */
  499. {
  500.   va_list ap;            /* the variable arguments */
  501.   if (print == 1)
  502.     { long res;
  503.       va_start(ap,format);    /* init ap */
  504.       res = vprintf(format,ap);    /* print the contents */
  505.       va_end(ap);        /* free ap */
  506.       return(res);
  507.     }
  508.   else
  509.     return(0);
  510. }
  511.  
  512. #else /* use k&r varargs */
  513.  
  514. long
  515. cprintf(va_alist)
  516. va_dcl
  517. /* just like printf, but only prints if the first argument = 1 */
  518. {
  519.   va_list ap;            /* the variable arguments */
  520.   boolean print;
  521.   long res;
  522.  
  523.   va_start(ap);            /* init ap */
  524.  
  525.   print = va_arg(ap,boolean);    /* get the condition */
  526.  
  527.   if (print == 1)
  528.     { char* format = va_arg(ap,char*); /* get the format */
  529.       res = vprintf(format,ap);    /* print the contents */
  530.     }
  531.   else
  532.     res = 0;
  533.  
  534.   va_end(ap);            /* free ap */
  535.  
  536.   return(res);
  537. }
  538.  
  539.   
  540. #endif
  541.  
  542. /* 
  543.    Define them here! Goes to libwais.a. So will be included in all
  544.    programs using wais.
  545. */
  546.  
  547. char* wais_log_file_name = NULL;
  548. FILE* waislogfile = NULL;
  549.  
  550. /* waislog - a new and improved logging facility.
  551.    first two arguments are important, the rest is text.
  552.  
  553.    arg1: priority.  If priority > log_level (some global), output this
  554.    message
  555.  
  556.    arg2: message code.  This is the kind of message (search, retrieval, etc). */
  557.  
  558. char *syslog_name = 0;
  559.   
  560. void
  561. #ifdef ANSI_LIKE
  562. waislog(long priority, long message, char *format, ...)
  563. #else
  564. waislog(va_alist)
  565. va_dcl
  566. #endif
  567.   {
  568.   va_list ap;
  569. #ifndef ANSI_LIKE
  570.   int priority, message;
  571.   char *format;
  572.   
  573.   va_start(ap);
  574.   priority = va_arg(ap, int);
  575.   message = va_arg(ap, int);
  576.   format = va_arg(ap, char *);
  577.   vwaislog(priority, message, format, ap);
  578.   va_end(ap);
  579. #else
  580.   va_start(ap, format);
  581.   vwaislog(priority, message, format, ap);
  582.   va_end(ap);
  583. #endif
  584.   }
  585.   
  586.   void
  587. #ifdef ANSI_LIKE /* use ansi varargs */
  588. vwaislog(long priority, long message, char* format, va_list ap)
  589. #else
  590. vwaislog(priority, message, format, ap)
  591. long priority, message;
  592. char *format;    
  593. va_list ap;
  594. #endif /* ANSI_LIKE */
  595.   /* just like printf, but prints to the waislogfile, with PID and time. */
  596.   {
  597.   static boolean in_vwaislog; /* to avoid reentrancy problems if */
  598.                   /* s_malloc fails and calls panic() */
  599.   
  600. #ifdef USE_SYSLOG
  601.   static boolean opened = 0;
  602. #endif
  603.   
  604.   in_vwaislog++;
  605.   
  606. #ifdef USE_SYSLOG
  607.   if (syslog_name && !opened) {
  608.     openlog(syslog_name, LOG_PID, LOG_WAIS);
  609.     opened = 1;
  610.   }
  611. #endif
  612.   
  613.   if(priority <= wais_log_level) {
  614.   
  615. #ifdef USE_SYSLOG
  616.     if (! opened) {
  617. #endif
  618.       if(waislogfile == NULL && wais_log_file_name != NULL)
  619.     waislogfile = fopen(wais_log_file_name, "a");
  620.   
  621.       if(waislogfile) {
  622.   
  623.     fprintf(waislogfile, "%d: %d: %s: %d: ", wais_pid, log_line++,
  624.         printable_time(), message);
  625.   
  626.     vfprintf(waislogfile, format,ap); /* print the contents */
  627.     fprintf(waislogfile, "\n");
  628.     fflush(waislogfile);
  629.       }
  630.  
  631.       if(waislogfile != NULL && waislogfile != stderr) {
  632.     fclose(waislogfile);
  633.     waislogfile = NULL;
  634.       }
  635. #ifdef USE_SYSLOG
  636.     }
  637.     else {
  638.       int log_priority;
  639.       char log_buf[512];
  640.       static int buffer_size;
  641.       static char *buffer;
  642.       char *use_buffer;
  643.       int format_size = strlen(format);
  644.  
  645.       /*
  646.        * All of this grungy code is to allow us to use s_malloc or
  647.        * s_realloc to allocate enough space for the message buffers,
  648.        * while at the same time not getting into an infinite loop if
  649.        * s_malloc or s_realloc fails and calls panic.
  650.        */
  651.   
  652.       if ((in_vwaislog > 1) || (format_size <= sizeof(log_buf) - 20)) {
  653.     use_buffer = log_buf;
  654.       }
  655.       else {
  656.     if (format_size + 20 > buffer_size) {
  657.       buffer_size = format_size + 20;
  658.       if (! buffer) {
  659.         buffer = s_malloc(buffer_size);
  660.       }
  661.       else {
  662.         buffer = s_realloc(buffer, buffer_size);
  663.       }
  664.     }
  665.     use_buffer = buffer;
  666.       }
  667.  
  668.       if (message < 0) {
  669.        /* Error message or warning */
  670.        if (priority >= 9) {
  671.         log_priority = LOG_NOTICE;
  672.        }
  673.        else if (priority >= 5) {
  674.         log_priority = LOG_WARNING;
  675.        }
  676.        else {
  677.         priority = LOG_ERR;
  678.        }
  679.       }
  680.       else {
  681.        switch (priority) {
  682.        case 1:
  683.        case 2:
  684.        case 3:
  685.         log_priority = LOG_NOTICE;
  686.         break;
  687.        case 4:
  688.        case 5:
  689.        case 6:
  690.         log_priority = LOG_INFO;
  691.         break;
  692.        default:
  693.         log_priority = LOG_DEBUG;
  694.         break;
  695.        }
  696.       }
  697.       
  698.       sprintf(use_buffer, "%d: %s", message, format);
  699.       vsyslog(log_priority, use_buffer, ap);
  700.       }
  701. #endif /* USE_SYSLOG */
  702.     }
  703.   
  704.   in_vwaislog--;
  705. }
  706.     
  707.   /*----------------------------------------------------------------------*/
  708.  
  709. void
  710. warn(message)
  711. char* message;
  712.  
  713. {
  714. #ifdef THINK_C
  715.   Debugger();
  716. #else
  717.   printf("%s\n<press return to continue>\n",message);
  718.   getchar();
  719. #endif
  720. }
  721.  
  722. /*----------------------------------------------------------------------*/
  723. boolean substrcmp(string1,string2)
  724. unsigned char *string1, *string2;
  725. {
  726.   /* compares the strings up until one of then ends.
  727.    * returns true if they are the same, false if not.
  728.    */
  729.   register unsigned char *a, *b;
  730.   
  731.   a = string1;
  732.   b = string2;
  733.   
  734.   while (*a && *b) 
  735.     if(*a++ != *b++) 
  736.       return false;
  737.   return true;
  738. }
  739.  
  740. /*----------------------------------------------------------------------*/
  741.  
  742. char *printable_time()
  743. { 
  744.   static char *string;
  745.   time_t tptr;
  746.   time(&tptr);
  747.   string = ctime(&tptr);
  748.   if(string){
  749.     if(string[strlen(string)-1] == '\n')
  750.       string[strlen(string)-1] = '\0';   
  751.     return(string+4);
  752.   }
  753.   else
  754.     return("Time Unknown");
  755. }
  756.  
  757. /*----------------------------------------------------------------------*/
  758.  
  759. char char_downcase(long_ch)
  760. unsigned long long_ch;
  761. {
  762.   unsigned char ch = long_ch & 0xFF; /* just want one byte */
  763.   /* when ansi is the way of the world, this can be tolower */
  764. #ifdef ISO
  765.   return(tolower(ch));
  766. #else
  767.   return (((ch >= 'A') && (ch <= 'Z')) ? (ch + 'a' -'A') : ch);
  768. #endif
  769. }
  770.  
  771. char *string_downcase(word)
  772. char *word;
  773. {
  774.   long i = 0;
  775.  
  776.   if (word == NULL)
  777.     return(NULL);
  778.  
  779.   while(word[i] != '\0')
  780.    { word[i] = char_downcase((unsigned long)word[i]);
  781.      i++;
  782.    }
  783.  
  784.   return(word);
  785. }
  786.  
  787. /*----------------------------------------------------------------------*/
  788.  
  789.  
  790. /* parsing arguments functions */
  791.  
  792. char *next_arg(argc,argv)
  793. int *argc;
  794. char ***argv;
  795.  
  796.      /* Returns NULL when it is out of arguments,
  797.         This side effects both argc and argv.  argc always contains the number
  798.     of arguments left.
  799.     The first returned is the command name. 
  800.     */
  801. {
  802.   if((*argc)-- > 0)
  803.     return(*((*argv)++));
  804.   else
  805.     return(NULL);
  806. }
  807.  
  808. #ifdef FIELDS /* tung, 5/94 */
  809. char *field_next_arg(argc, number_of_files, argv)
  810. int *argc;
  811. int *number_of_files;
  812. char ***argv;
  813.  
  814.      /* Returns NULL when it is out of arguments,
  815.         This side effects both argc and argv.  argc always contains the number
  816.     of arguments left.
  817.     The first returned is the command name. 
  818.     */
  819. {
  820.   if((*argc)-- > 0) {
  821.     ++(*number_of_files);
  822.     return(*((*argv) + (*number_of_files - 1)));
  823.   }
  824.   else
  825.     return(NULL);
  826. }
  827.  
  828. #endif
  829. /*----------------------------------------------------------------------*/
  830.  
  831. char *peek_arg(argc,argv)
  832. int *argc;
  833.     char ***argv;
  834.  
  835.      /* Returns the next argument without popping it.
  836.        Returns NULL when it is out of arguments.
  837.        */
  838. {
  839.   if((*argc) > 0)
  840.     return(**argv);
  841.   else
  842.     return(NULL);
  843. }
  844.  
  845. /*----------------------------------------------------------------------*/
  846.  
  847.  
  848. #ifdef THINK_C
  849. #include <EventMgr.h>
  850. #undef MAX_FILE_NAME_LEN 
  851. #ifdef WAIStation
  852. #include "CRetrievalApp.h"
  853. #endif /* def WAIStation */
  854. #endif /* def THINK_C */
  855.  
  856. void
  857. beFriendly()
  858. /* this routine is called during time intensive operations
  859.    on single processing machines (macs and DOS).  It gives
  860.    time to other processes
  861.  */
  862. { 
  863. #ifdef never
  864. #ifdef THINK_C
  865.    EventRecord      macEvent;    /* an event */
  866.  
  867.    static RgnHandle    mouseRgn = NULL; /* region for mouse moved events */
  868.    long                sleepTime;     /* max time between events */
  869.    
  870. #ifdef WAIStation
  871.    gApplication->FrobWaitCursor();
  872. #endif /* def WAIStation */
  873.    
  874.    if (mouseRgn == NULL)
  875.      mouseRgn = NewRgn(); /* do we need to set its value? */
  876.      
  877.    sleepTime = 5; /* arbitrary - a tech note recommends < 50 */
  878.    
  879.    WaitNextEvent(everyEvent,&macEvent,sleepTime,mouseRgn); 
  880. #endif /* def THINK_C */
  881. #endif
  882. }
  883.  
  884.  
  885. #if defined(BSD) || defined(BSD43)
  886. #define NEED_VPRINTF
  887. #endif
  888.  
  889. #ifdef NEED_VPRINTF
  890. /* Portable vsprintf  by Robert A. Larson <blarson@skat.usc.edu> */
  891.  
  892. /* Copyright 1989 Robert A. Larson.
  893.  * Distribution in any form is allowed as long as the author
  894.  * retains credit, changes are noted by their author and the
  895.  * copyright message remains intact.  This program comes as-is
  896.  * with no warentee of fitness for any purpouse.
  897.  *
  898.  * Thanks to Doug Gwen, Chris Torek, and others who helped clarify
  899.  * the ansi printf specs.
  900.  *
  901.  * Please send any bug fixes and improvments to blarson@skat.usc.edu .
  902.  * The use of goto is NOT a bug.
  903.  */
  904.  
  905. /* Feb    7, 1989        blarson        First usenet release */
  906.  
  907. /* This code implements the vsprintf function, without relying on
  908.  * the existance of _doprint or other system specific code.
  909.  *
  910.  * Define NOVOID if void * is not a supported type.
  911.  *
  912.  * Two compile options are available for efficency:
  913.  *    INTSPRINTF    should be defined if sprintf is int and returns
  914.  *            the number of chacters formated.
  915.  *    LONGINT        should be defined if sizeof(long) == sizeof(int)
  916.  *
  917.  *    They only make the code smaller and faster, they need not be
  918.  *    defined.
  919.  *
  920.  * UNSIGNEDSPECIAL should be defined if unsigned is treated differently
  921.  * than int in argument passing.  If this is definded, and LONGINT is not,
  922.  * the compiler must support the type unsingned long.
  923.  *
  924.  * Most quirks and bugs of the available sprintf fuction are duplicated,
  925.  * however * in the width and precision fields will work correctly
  926.  * even if sprintf does not support this, as will the n format.
  927.  *
  928.  * Bad format strings, or those with very long width and precision
  929.  * fields (including expanded * fields) will cause undesired results.
  930.  */
  931.  
  932. #ifdef OSK        /* os9/68k can take advantage of both */
  933. #define LONGINT
  934. #define INTSPRINTF
  935. #endif
  936.  
  937. /* This must be a typedef not a #define! */
  938. #ifdef NOVOID
  939. typedef char *pointer;
  940. #else
  941. typedef void *pointer;
  942. #endif
  943.  
  944. #ifdef    INTSPRINTF
  945. #define Sprintf(string,format,arg)    (sprintf((string),(format),(arg)))
  946. #else
  947. #define Sprintf(string,format,arg)    (\
  948.     sprintf((string),(format),(arg)),\
  949.     strlen(string)\
  950. )
  951. #endif
  952.  
  953. typedef int *intp;
  954.  
  955. int vsprintf(dest, format, args)
  956. char *dest;
  957. register char *format;
  958. va_list args;
  959. {
  960.     register char *dp = dest;
  961.     register char c;
  962.     register char *tp;
  963.     char tempfmt[64];
  964. #ifndef LONGINT
  965.     int longflag;
  966. #endif
  967.  
  968.     tempfmt[0] = '%';
  969.     while( (c = *format++) != 0) {
  970.     if(c=='%') {
  971.         tp = &tempfmt[1];
  972. #ifndef LONGINT
  973.         longflag = 0;
  974. #endif
  975. continue_format:
  976.         switch(c = *format++) {
  977.         case 's':
  978.             *tp++ = c;
  979.             *tp = '\0';
  980.             dp += Sprintf(dp, tempfmt, va_arg(args, char *));
  981.             break;
  982.         case 'u':
  983.         case 'x':
  984.         case 'o':
  985.         case 'X':
  986. #ifdef UNSIGNEDSPECIAL
  987.             *tp++ = c;
  988.             *tp = '\0';
  989. #ifndef LONGINT
  990.             if(longflag)
  991.             dp += Sprintf(dp, tempfmt, va_arg(args, unsigned long));
  992.             else
  993. #endif
  994.             dp += Sprintf(dp, tempfmt, va_arg(args, unsigned));
  995.             break;
  996. #endif
  997.         case 'd':
  998.         case 'c':
  999.         case 'i':
  1000.             *tp++ = c;
  1001.             *tp = '\0';
  1002. #ifndef LONGINT
  1003.             if(longflag)
  1004.             dp += Sprintf(dp, tempfmt, va_arg(args, long));
  1005.             else
  1006. #endif
  1007.             dp += Sprintf(dp, tempfmt, va_arg(args, int));
  1008.             break;
  1009.         case 'f':
  1010.         case 'e':
  1011.         case 'E':
  1012.         case 'g':
  1013.         case 'G':
  1014.             *tp++ = c;
  1015.             *tp = '\0';
  1016.             dp += Sprintf(dp, tempfmt, va_arg(args, double));
  1017.             break;
  1018.         case 'p':
  1019.             *tp++ = c;
  1020.             *tp = '\0';
  1021.             dp += Sprintf(dp, tempfmt, va_arg(args, pointer));
  1022.             break;
  1023.         case '-':
  1024.         case '+':
  1025.         case '0':
  1026.         case '1':
  1027.         case '2':
  1028.         case '3':
  1029.         case '4':
  1030.         case '5':
  1031.         case '6':
  1032.         case '7':
  1033.         case '8':
  1034.         case '9':
  1035.         case '.':
  1036.         case ' ':
  1037.         case '#':
  1038.         case 'h':
  1039.             *tp++ = c;
  1040.             goto continue_format;
  1041.         case 'l':
  1042. #ifndef LONGINT
  1043.             longflag = 1;
  1044.             *tp++ = c;
  1045. #endif
  1046.             goto continue_format;
  1047.         case '*':
  1048.             tp += Sprintf(tp, "%d", va_arg(args, int));
  1049.             goto continue_format;
  1050.         case 'n':
  1051.             *va_arg(args, intp) = dp - dest;
  1052.             break;
  1053.         case '%':
  1054.         default:
  1055.             *dp++ = c;
  1056.             break;
  1057.         }
  1058.     } else *dp++ = c;
  1059.     }
  1060.     *dp = '\0';
  1061.     return dp - dest;
  1062. }
  1063.  
  1064.  
  1065. int vfprintf(dest, format, args)
  1066. FILE *dest;
  1067. register char *format;
  1068. va_list args;
  1069. {
  1070.     register char c;
  1071.     register char *tp;
  1072.     register int count = 0;
  1073.     char tempfmt[64];
  1074. #ifndef LONGINT
  1075.     int longflag;
  1076. #endif
  1077.  
  1078.     tempfmt[0] = '%';
  1079.     while(c = *format++) {
  1080.     if(c=='%') {
  1081.         tp = &tempfmt[1];
  1082. #ifndef LONGINT
  1083.         longflag = 0;
  1084. #endif
  1085. continue_format:
  1086.         switch(c = *format++) {
  1087.         case 's':
  1088.             *tp++ = c;
  1089.             *tp = '\0';
  1090.             count += fprintf(dest, tempfmt, va_arg(args, char *));
  1091.             break;
  1092.         case 'u':
  1093.         case 'x':
  1094.         case 'o':
  1095.         case 'X':
  1096. #ifdef UNSIGNEDSPECIAL
  1097.             *tp++ = c;
  1098.             *tp = '\0';
  1099. #ifndef LONGINT
  1100.             if(longflag)
  1101.             count += fprintf(dest, tempfmt, va_arg(args, unsigned long));
  1102.             else
  1103. #endif
  1104.             count += fprintf(dest, tempfmt, va_arg(args, unsigned));
  1105.             break;
  1106. #endif
  1107.         case 'd':
  1108.         case 'c':
  1109.         case 'i':
  1110.             *tp++ = c;
  1111.             *tp = '\0';
  1112. #ifndef LONGINT
  1113.             if(longflag)
  1114.             count += fprintf(dest, tempfmt, va_arg(args, long));
  1115.             else
  1116. #endif
  1117.             count += fprintf(dest, tempfmt, va_arg(args, int));
  1118.             break;
  1119.         case 'f':
  1120.         case 'e':
  1121.         case 'E':
  1122.         case 'g':
  1123.         case 'G':
  1124.             *tp++ = c;
  1125.             *tp = '\0';
  1126.             count += fprintf(dest, tempfmt, va_arg(args, double));
  1127.             break;
  1128.         case 'p':
  1129.             *tp++ = c;
  1130.             *tp = '\0';
  1131.             count += fprintf(dest, tempfmt, va_arg(args, pointer));
  1132.             break;
  1133.         case '-':
  1134.         case '+':
  1135.         case '0':
  1136.         case '1':
  1137.         case '2':
  1138.         case '3':
  1139.         case '4':
  1140.         case '5':
  1141.         case '6':
  1142.         case '7':
  1143.         case '8':
  1144.         case '9':
  1145.         case '.':
  1146.         case ' ':
  1147.         case '#':
  1148.         case 'h':
  1149.             *tp++ = c;
  1150.             goto continue_format;
  1151.         case 'l':
  1152. #ifndef LONGINT
  1153.             longflag = 1;
  1154.             *tp++ = c;
  1155. #endif
  1156.             goto continue_format;
  1157.         case '*':
  1158.             tp += Sprintf(tp, "%d", va_arg(args, int));
  1159.             goto continue_format;
  1160.         case 'n':
  1161.             *va_arg(args, intp) = count;
  1162.             break;
  1163.         case '%':
  1164.         default:
  1165.             putc(c, dest);
  1166.             count++;
  1167.             break;
  1168.         }
  1169.     } else {
  1170.         putc(c, dest);
  1171.         count++;
  1172.     }
  1173.     }
  1174.     return count;
  1175. }
  1176.  
  1177. vprintf(format, args)
  1178. char *format;
  1179. va_list args;
  1180. {
  1181.     return vfprintf(stdout, format, args);
  1182. }
  1183.  
  1184. #endif
  1185.  
  1186. #ifndef HAVE_STRDUP
  1187. char* strdup(s)
  1188. char* s;
  1189.  
  1190. /* return a copy of s.  This is identical to the standard library routine
  1191.    strdup(), except that it is safe.  If s == NULL or malloc fails, 
  1192.    appropriate action is taken.
  1193.  */
  1194. {
  1195.   unsigned long len;
  1196.   char* copy = NULL;
  1197.   
  1198.   if (s == NULL)        /* saftey check to postpone stupid errors */
  1199.     return(NULL);
  1200.     
  1201.   len = strlen(s);        /* length of string - terminator */
  1202.   copy = (char*)s_malloc((size_t)(sizeof(char)*(len + 1)));
  1203.   strncpy(copy,s,len + 1);
  1204.   return(copy);
  1205. }
  1206. #endif
  1207. /*----------------------------------------------------------------------*/
  1208.  
  1209. #ifdef NEED_MYBCOPY
  1210. void
  1211. mybcopy(b1, b2, length)
  1212.      char *b1, *b2;
  1213.      int length;
  1214. {
  1215.   int i;
  1216.   if (b1 > b2) {
  1217.     for (i=0;i<length;i++) {
  1218.       b2[i] = b1[i];
  1219.     }
  1220.   } else {
  1221.     for (i=length-1;i>=0;i--) {
  1222.       b2[i] = b1[i];
  1223.     }
  1224.   }
  1225. }
  1226. #endif /* NEED_MYBCOPY */
  1227.