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