home *** CD-ROM | disk | FTP | other *** search
/ ProfitPress Mega CDROM2 …eeware (MSDOS)(1992)(Eng) / ProfitPress-MegaCDROM2.B6I / TEXT / UTILITY / CAWF2.ZIP / MACSUP.C < prev    next >
Encoding:
C/C++ Source or Header  |  1991-06-04  |  3.9 KB  |  182 lines
  1. /*
  2.  *    macsup.c - macro processing support functions for cawf(1)
  3.  */
  4.  
  5. /*
  6.  *    Copyright (c) 1991 Purdue University Research Foundation,
  7.  *    West Lafayette, Indiana 47907.  All rights reserved.
  8.  *
  9.  *    Written by Victor A. Abell <abe@mace.cc.purdue.edu>,  Purdue
  10.  *    University Computing Center.  Not derived from licensed software;
  11.  *    derived from awf(1) by Henry Spencer of the University of Toronto.
  12.  *
  13.  *    Permission is granted to anyone to use this software for any
  14.  *    purpose on any computer system, and to alter it and redistribute
  15.  *    it freely, subject to the following restrictions:
  16.  *
  17.  *    1. The author is not responsible for any consequences of use of
  18.  *       this software, even if they arise from flaws in it.
  19.  *
  20.  *    2. The origin of this software must not be misrepresented, either
  21.  *       by explicit claim or by omission.  Credits must appear in the
  22.  *       documentation.
  23.  *
  24.  *    3. Altered versions must be plainly marked as such, and must not
  25.  *       be misrepresented as being the original software.  Credits must
  26.  *       appear in the documentation.
  27.  *
  28.  *    4. This notice may not be removed or altered.
  29.  */
  30.  
  31. #include "cawf.h"
  32. #ifdef    UNIX
  33. #else
  34. #include <malloc.h>
  35. #endif
  36.  
  37.  
  38. /*
  39.  * Delmacro(mx) - delete macro
  40.  */
  41.  
  42. Delmacro(mx)
  43.     int mx;                /* macro index */
  44. {
  45.     char buf[MAXLINE];        /* error message buffer */
  46.     int i, j;            /* temporary indexes */
  47.  
  48.     if (mx >= Nmac) {
  49.         (void) sprintf(buf, " bad Delmacro(%d) index", mx);
  50.         Error(FATAL, LINE, buf, NULL);
  51.     }
  52.     for (i = Macrotab[mx].bx, j = i + Macrotab[mx].ct; i < j; i++) {
  53.         Free(&Macrotxt[i]);
  54.     }
  55.     for (i = mx; i < (Nmac - 1); i++) {
  56.         Macrotab[i] = Macrotab[i+1];
  57.     }
  58.     Nmac--;
  59. }
  60.  
  61.  
  62. /*
  63.  * Field(n, p, c) - skip to field n in p and optionally return a copy
  64.  */
  65.  
  66. char *
  67. Field(n, p, c)
  68.     int n;                /* field number */
  69.     char *p;            /* point to line containing fields */
  70.     int c;                /* 1: make a copy of the field */
  71. {
  72.     char *fs, *fe, *s;
  73.  
  74.     if (c)
  75.         Free(&F);
  76.     fe = p;
  77.     while (n) {
  78.         while (*fe == ' ' || *fe == '\t')
  79.             fe++;
  80.         fs = fe;
  81.         while (*fe && *fe != ' ' && *fe != '\t')
  82.             fe++;
  83.         if (fs == fe)
  84.             return(NULL);
  85.         if (n == 1) {
  86.             if ( ! c)
  87.                 return(fs);
  88.             if ((F = malloc((size_t)(fe - fs + 1))) == NULL)
  89.                 Error(FATAL, LINE, " Field out of string space",
  90.                     NULL);
  91.             (void) strncpy(F, fs, (fe - fs));
  92.             F[fe -fs] = '\0';
  93.             return(F);
  94.         }
  95.         n--;
  96.     }
  97.     return(NULL);
  98. }
  99.  
  100. /*
  101.  * Findmacro(p, e) - find macro and optionally enter it
  102.  *
  103.  * return = Macrotab[] index or -1 if not found
  104.  */
  105.  
  106.  
  107. Findmacro(p, e)
  108.     char *p;                /* pointer to 2 character macro name  */
  109.     int e;            /* 0 = find, don't enter
  110.                  * 1 = enter, don't find */
  111. {
  112.     char c[3];
  113.     int cmp, hi, low, mid;
  114.  
  115.     c[0] = p[0];
  116.     c[1] = (p[1] == ' ' || p[1] == '\t') ? '\0' : p[1];
  117.     c[2] = '\0';
  118.     low = mid = 0;
  119.     hi = Nmac - 1;
  120.     while (low <= hi) {
  121.         mid = (low + hi) / 2;
  122.         if ((cmp = strncmp(c, Macrotab[mid].name, 2)) < 0)
  123.             hi = mid - 1;
  124.         else if (cmp > 0)
  125.             low = mid + 1;
  126.         else {
  127.             if ( ! e)
  128.                 return(mid);
  129.              Error(WARN, LINE, " duplicate macro ", c);
  130.              hi = Macrotab[mid].bx + Macrotab[mid].ct;
  131.              for (low = Macrotab[mid].bx; low < hi; low++) {
  132.                 Free(&Macrotxt[low]);
  133.              }
  134.              goto new_macro;
  135.         }
  136.     }
  137.     if ( ! e)
  138.         return(-1);
  139.     if (Nmac >= MAXMACRO)
  140.         Error(FATAL, LINE, " macro table full at ", c);
  141.     if (Nmac) {
  142.         if (cmp > 0)
  143.             mid++;
  144.         for (hi = Nmac - 1; hi >= mid; hi--)
  145.             Macrotab[hi+1] = Macrotab[hi];
  146.     }
  147.     Nmac++;
  148.     Macrotab[mid].name[0] = c[0];
  149.     Macrotab[mid].name[1] = c[1];
  150.  
  151. new_macro:
  152.  
  153.     Macrotab[mid].bx = -1;
  154.     Macrotab[mid].ct = 0;
  155.     return(mid);
  156. }
  157.  
  158. Free(p)
  159.     char **p;
  160. {
  161.     if (*p != NULL) {
  162.         (void) free(*p);
  163.         *p = NULL;
  164.     }
  165. }
  166.  
  167. /*
  168.  * Newstr(s) - allocate space for string
  169.  */
  170.  
  171. char *
  172. Newstr(s)
  173.     char *s;
  174. {
  175.     char *ns;
  176.  
  177.     if ((ns = malloc((size_t)(strlen(s) + 1))) == NULL)
  178.         Error(FATAL, LINE, " Newstr out of malloc space at ", s);
  179.     (void) strcpy(ns, s);
  180.     return(ns);
  181. }
  182.