i86/elks/elkscmd/m4/serv.c

   1 /*
   2  * serv.c
   3  * Facility: m4 macro processor
   4  * by: oz
   5  */
   6
   7 #include "mdef.h"
   8 #include "extr.h"
   9
  10 extern ndptr lookup();
  11 extern ndptr addent();
  12 extern char  *strsave();
  13
  14 char *dumpfmt = "`%s'\t`%s'\n"; /* format string for dumpdef   */
  15
  16 /*
  17  * expand - user-defined macro expansion
  18  *
  19  */
  20 expand(argv, argc)
  21 register char *argv[];
  22 register int argc;
  23 {
  24         register char *t;
  25         register char *p;
  26         register int  n;
  27         register int  argno;
  28
  29         t = argv[0];    /* defn string as a whole */
  30         p = t;
  31         while (*p)
  32                 p++;
  33         p--;            /* last character of defn */
  34         while (p > t) {
  35                 if (*(p-1) != ARGFLAG)
  36                         putback(*p);
  37                 else {
  38                         switch (*p) {
  39
  40                         case '#':
  41                                 pbnum(argc-2);
  42                                 break;
  43                         case '0':
  44                         case '1':
  45                         case '2':
  46                         case '3':
  47                         case '4':
  48                         case '5':
  49                         case '6':
  50                         case '7':
  51                         case '8':
  52                         case '9':
  53                                 if ((argno = *p - '0') < argc-1)
  54                                         pbstr(argv[argno+1]);
  55                                 break;
  56                         case '*':
  57                                 for (n = argc - 1; n > 2; n--) {
  58                                         pbstr(argv[n]);
  59                                         putback(',');
  60                                 }
  61                                 pbstr(argv[2]);
  62                                 break;
  63                         default :
  64                                 putback(*p);
  65                                 break;
  66                         }
  67                         p--;
  68                 }
  69                 p--;
  70         }
  71         if (p == t)         /* do last character */
  72                 putback(*p);
  73 }
  74
  75 /*
  76  * dodefine - install definition in the table
  77  *
  78  */
  79 dodefine(name, defn)
  80 register char *name;
  81 register char *defn;
  82 {
  83         register ndptr p;
  84
  85         if (!*name)
  86                 error("m4: null definition.");
  87         if (strcmp(name, defn) == 0)
  88                 error("m4: recursive definition.");
  89         if ((p = lookup(name)) == nil)
  90                 p = addent(name);
  91         else if (p->defn != null)
  92                 free(p->defn);
  93         if (!*defn)
  94                 p->defn = null;
  95         else
  96                 p->defn = strsave(defn);
  97         p->type = MACRTYPE;
  98 }
  99
 100 /*
 101  * dodefn - push back a quoted definition of
 102  *      the given name.
 103  */
 104
 105 dodefn(name)
 106 char *name;
 107 {
 108         register ndptr p;
 109
 110         if ((p = lookup(name)) != nil && p->defn != null) {
 111                 putback(rquote);
 112                 pbstr(p->defn);
 113                 putback(lquote);
 114         }
 115 }
 116
 117 /*
 118  * dopushdef - install a definition in the hash table
 119  *      without removing a previous definition. Since
 120  *      each new entry is entered in *front* of the
 121  *      hash bucket, it hides a previous definition from
 122  *      lookup.
 123  */
 124 dopushdef(name, defn)
 125 register char *name;
 126 register char *defn;
 127 {
 128         register ndptr p;
 129
 130         if (!*name)
 131                 error("m4: null definition");
 132         if (strcmp(name, defn) == 0)
 133                 error("m4: recursive definition.");
 134         p = addent(name);
 135         if (!*defn)
 136                 p->defn = null;
 137         else
 138                 p->defn = strsave(defn);
 139         p->type = MACRTYPE;
 140 }
 141
 142 /*
 143  * dodumpdef - dump the specified definitions in the hash
 144  *      table to stderr. If nothing is specified, the entire
 145  *      hash table is dumped.
 146  *
 147  */
 148 dodump(argv, argc)
 149 register char *argv[];
 150 register int argc;
 151 {
 152         register int n;
 153         ndptr p;
 154
 155         if (argc > 2) {
 156                 for (n = 2; n < argc; n++)
 157                         if ((p = lookup(argv[n])) != nil)
 158                                 fprintf(stderr, dumpfmt, p->name,
 159                                 p->defn);
 160         }
 161         else {
 162                 for (n = 0; n < HASHSIZE; n++)
 163                         for (p = hashtab[n]; p != nil; p = p->nxtptr)
 164                                 fprintf(stderr, dumpfmt, p->name,
 165                                 p->defn);
 166         }
 167 }
 168
 169 /*
 170  * doifelse - select one of two alternatives - loop.
 171  *
 172  */
 173 doifelse(argv,argc)
 174 register char *argv[];
 175 register int argc;
 176 {
 177         cycle {
 178                 if (strcmp(argv[2], argv[3]) == 0)
 179                         pbstr(argv[4]);
 180                 else if (argc == 6)
 181                         pbstr(argv[5]);
 182                 else if (argc > 6) {
 183                         argv += 3;
 184                         argc -= 3;
 185                         continue;
 186                 }
 187                 break;
 188         }
 189 }
 190
 191 /*
 192  * doinclude - include a given file.
 193  *
 194  */
 195 doincl(ifile)
 196 char *ifile;
 197 {
 198         if (ilevel+1 == MAXINP)
 199                 error("m4: too many include files.");
 200         if ((infile[ilevel+1] = fopen(ifile, "r")) != NULL) {
 201                 ilevel++;
 202                 return (1);
 203         }
 204         else
 205                 return (0);
 206 }
 207
 208 #ifdef EXTENDED
 209 /*
 210  * dopaste - include a given file without any
 211  *           macro processing.
 212  */
 213 dopaste(pfile)
 214 char *pfile;
 215 {
 216         FILE *pf;
 217         register int c;
 218
 219         if ((pf = fopen(pfile, "r")) != NULL) {
 220                 while((c = getc(pf)) != EOF)
 221                         putc(c, active);
 222                 (void) fclose(pf);
 223                 return(1);
 224         }
 225         else
 226                 return(0);
 227 }
 228 #endif
 229
 230 /*
 231  * dochq - change quote characters
 232  *
 233  */
 234 dochq(argv, argc)
 235 register char *argv[];
 236 register int argc;
 237 {
 238         if (argc > 2) {
 239                 if (*argv[2])
 240                         lquote = *argv[2];
 241                 if (argc > 3) {
 242                         if (*argv[3])
 243                                 rquote = *argv[3];
 244                 }
 245                 else
 246                         rquote = lquote;
 247         }
 248         else {
 249                 lquote = LQUOTE;
 250                 rquote = RQUOTE;
 251         }
 252 }
 253
 254 /*
 255  * dochc - change comment characters
 256  *
 257  */
 258 dochc(argv, argc)
 259 register char *argv[];
 260 register int argc;
 261 {
 262         if (argc > 2) {
 263                 if (*argv[2])
 264                         scommt = *argv[2];
 265                 if (argc > 3) {
 266                         if (*argv[3])
 267                                 ecommt = *argv[3];
 268                 }
 269                 else
 270                         ecommt = ECOMMT;
 271         }
 272         else {
 273                 scommt = SCOMMT;
 274                 ecommt = ECOMMT;
 275         }
 276 }
 277
 278 /*
 279  * dodivert - divert the output to a temporary file
 280  *
 281  */
 282 dodiv(n)
 283 register int n;
 284 {
 285         if (n < 0 || n >= MAXOUT)
 286                 n = 0;                  /* bitbucket */
 287         if (outfile[n] == NULL) {
 288                 m4temp[UNIQUE] = n + '0';
 289                 if ((outfile[n] = fopen(m4temp, "w")) == NULL)
 290                         error("m4: cannot divert.");
 291         }
 292         oindex = n;
 293         active = outfile[n];
 294 }
 295
 296 /*
 297  * doundivert - undivert a specified output, or all
 298  *              other outputs, in numerical order.
 299  */
 300 doundiv(argv, argc)
 301 register char *argv[];
 302 register int argc;
 303 {
 304         register int ind;
 305         register int n;
 306
 307         if (argc > 2) {
 308                 for (ind = 2; ind < argc; ind++) {
 309                         n = atoi(argv[ind]);
 310                         if (n > 0 && n < MAXOUT && outfile[n] != NULL)
 311                                 getdiv(n);
 312
 313                 }
 314         }
 315         else
 316                 for (n = 1; n < MAXOUT; n++)
 317                         if (outfile[n] != NULL)
 318                                 getdiv(n);
 319 }
 320
 321 /*
 322  * dosub - select substring
 323  *
 324  */
 325 dosub (argv, argc)
 326 register char *argv[];
 327 register int  argc;
 328 {
 329         register char *ap, *fc, *k;
 330         register int nc;
 331
 332         if (argc < 5)
 333                 nc = MAXTOK;
 334         else
 335 #ifdef EXPR
 336                 nc = expr(argv[4]);
 337 #else
 338                 nc = atoi(argv[4]);
 339 #endif
 340         ap = argv[2];                   /* target string */
 341 #ifdef EXPR
 342         fc = ap + expr(argv[3]);        /* first char */
 343 #else
 344         fc = ap + atoi(argv[3]);        /* first char */
 345 #endif
 346         if (fc >= ap && fc < ap+strlen(ap))
 347                 for (k = fc+min(nc,strlen(fc))-1; k >= fc; k--)
 348                         putback(*k);
 349 }
 350
 351 /*
 352  * map:
 353  * map every character of s1 that is specified in from
 354  * into s3 and replace in s. (source s1 remains untouched)
 355  *
 356  * This is a standard implementation of map(s,from,to) function of ICON
 357  * language. Within mapvec, we replace every character of "from" with
 358  * the corresponding character in "to". If "to" is shorter than "from",
 359  * than the corresponding entries are null, which means that those
 360  * characters dissapear altogether. Furthermore, imagine
 361  * map(dest, "sourcestring", "srtin", "rn..*") type call. In this case,
 362  * `s' maps to `r', `r' maps to `n' and `n' maps to `*'. Thus, `s'
 363  * ultimately maps to `*'. In order to achieve this effect in an efficient
 364  * manner (i.e. without multiple passes over the destination string), we
 365  * loop over mapvec, starting with the initial source character. if the
 366  * character value (dch) in this location is different than the source
 367  * character (sch), sch becomes dch, once again to index into mapvec, until
 368  * the character value stabilizes (i.e. sch = dch, in other words
 369  * mapvec[n] == n). Even if the entry in the mapvec is null for an ordinary
 370  * character, it will stabilize, since mapvec[0] == 0 at all times. At the
 371  * end, we restore mapvec* back to normal where mapvec[n] == n for
 372  * 0 <= n <= 127. This strategy, along with the restoration of mapvec, is
 373  * about 5 times faster than any algorithm that makes multiple passes over
 374  * destination string.
 375  *
 376  */
 377
 378 map(dest,src,from,to)
 379 register char *dest;
 380 register char *src;
 381 register char *from;
 382 register char *to;
 383 {
 384         register char *tmp;
 385         register char sch, dch;
 386         static char mapvec[128] = {
 387                 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
 388                 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
 389                 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
 390                 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
 391                 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
 392                 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71,
 393                 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83,
 394                 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
 395                 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107,
 396                 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119,
 397                 120, 121, 122, 123, 124, 125, 126, 127
 398         };
 399
 400         if (*src) {
 401                 tmp = from;
 402         /*
 403          * create a mapping between "from" and "to"
 404          */
 405                 while (*from)
 406                         mapvec[*from++] = (*to) ? *to++ : (char) 0;
 407
 408                 while (*src) {
 409                         sch = *src++;
 410                         dch = mapvec[sch];
 411                         while (dch != sch) {
 412                                 sch = dch;
 413                                 dch = mapvec[sch];
 414                         }
 415                         if (*dest = dch)
 416                                 dest++;
 417                 }
 418         /*
 419          * restore all the changed characters
 420          */
 421                 while (*tmp) {
 422                         mapvec[*tmp] = *tmp;
 423                         tmp++;
 424                 }
 425         }
 426         *dest = (char) 0;
 427 }