home *** CD-ROM | disk | FTP | other *** search
/ C!T ROM 2 / ctrom_ii_b.zip / ctrom_ii_b / PROGRAM / C / ZCPP_JAE / CPP7.C < prev    next >
C/C++ Source or Header  |  1990-07-06  |  25KB  |  843 lines
  1. /*
  2.  
  3.  
  4.  Copyright (C) 1990 Texas Instruments Incorporated.
  5.  
  6.  Permission is granted to any individual or institution to use, copy, modify,
  7.  and distribute this software, provided that this complete copyright and
  8.  permission notice is maintained, intact, in all copies and supporting
  9.  documentation.
  10.  
  11.  Texas Instruments Incorporated provides this software "as is" without
  12.  express or implied warranty.
  13.  
  14.  
  15.  *
  16.  *                C P P 7 . C
  17.  *
  18.  *               Process Internal/External defmacros
  19.  *
  20.  * Edit history
  21.  * 15-Mar-89    LGO    Initial design and implementation.
  22.  * 20-Oct-89    AFM     OS2 and XENIX port.
  23.  * 19-Jan-90    DKM     MVS support
  24.  */
  25.  
  26. #include    <stdio.h>
  27. #include    <ctype.h>
  28. #include    "cppdef.h"
  29.  
  30. #if HOST == SYS_VMS
  31. #include        <types.h>
  32. #else
  33. #if HOST != SYS_MVS
  34. #include        <sys/types.h>
  35. #endif
  36. #endif
  37.  
  38. #include    "cpp.h"
  39.  
  40. #if HOST == SYS_XENIX 
  41. #include        <string.h>
  42. #include        <sys/fcntl.h>
  43. #include        <sys/file.h>
  44. #else
  45. #if HOST == SYS_OS2
  46. #include        <string.h>
  47. #include        <fcntl.h>
  48. #else
  49. #if HOST == SYS_MVS
  50. #include        <string.h>
  51. #include        <fcntl.h>
  52. #else
  53. #if HOST == SYS_VMS
  54. #include        <file.h>
  55. #else
  56. #include        <sys/file.h>
  57. #endif
  58. #endif
  59. #endif
  60. #endif
  61.  
  62.  
  63.  
  64.  
  65. #if HOST == SYS_VMS
  66. #define F_OK            0      /* does file exist */
  67. #define X_OK            1      /* is file executable */
  68. #define W_OK            2      /* is file writable */
  69. #define R_OK            4      /* is file readable */
  70. #endif
  71.  
  72. int current_line;            /* line at start of defmacro global */
  73. char current_file[256];            /* file at start of defmacro global */
  74.  
  75. FILEINFO *MacInFile, *MacOutFile;
  76. char* MacOutEnd;
  77.  
  78. struct macroargs {
  79.   char* name;
  80.   char  expanding;        /* Non-zero when args are macro expanded */
  81.   char  recursive;        /* Non-zero when recursive */
  82.   char  delimiter;        /* Delimiter */
  83.   char  conditional;        /* Expand only if this char found after name */
  84.   internal_expander expander;    /* Macro expander or NULL if file */
  85.   char *program;        /* macro program pathname */
  86.   char *args[1];        /* arg list (vector of strings) */
  87. };
  88.  
  89. extern FILEINFO* getfile();
  90.  
  91. /* Getfile without side effects */
  92. FILEINFO*
  93. get_temp_file (bufsize, name)
  94.      int bufsize;
  95.      char* name;
  96. {
  97.   FILEINFO* file = getfile(bufsize, name);
  98.   infile = file->parent;
  99.   file->parent = NULL;
  100.   line = infile->line;
  101.   return(file);
  102. }
  103.  
  104. static FILEINFO*
  105. next_buffer(Buffer)
  106.    FILEINFO* Buffer;
  107. {
  108.   FILEINFO* new = get_temp_file(NBUFF, Buffer->filename);
  109.   new->parent = Buffer->parent;    /* When new ends read from infile */
  110.   Buffer->parent = new;            /* When Buffer dries up, read from new */
  111.   *Buffer->bptr = EOS;
  112.   Buffer->bptr = Buffer->buffer;
  113.   return new;
  114. }
  115.  
  116. /* Helper function for the getchar macro used by internal defmacros */
  117. char
  118. NextMacInChar() {
  119.   char c;
  120.   do {
  121.     if (MacInFile->parent == NULL) {
  122.       return(EOF);              /* End of file */
  123.     } else {
  124.       FILEINFO* new = MacInFile->parent;
  125.       free(MacInFile->filename);      /* Free name and    */
  126.       if (MacInFile->progname != NULL)      /* if a #line was seen, */
  127.     free(MacInFile->progname);      /* free it, too.    */
  128.       free(MacInFile->buffer);          /* Free buffer */
  129.       free((char *) MacInFile);          /* Free file space    */
  130.  
  131.       *new->bptr = EOS;
  132.       new->bptr = new->buffer;
  133.       c = *new->bptr++;
  134.       MacInFile = new;
  135.     }
  136.   }
  137.   while (c == EOS);
  138.   return (c);
  139. }
  140.  
  141. void
  142. NextMacOutBuffer()
  143. {
  144.   MacOutFile = next_buffer(MacOutFile);
  145.   MacOutEnd = MacOutFile->buffer + (NBUFF - 1);
  146. }
  147.  
  148. void
  149. NextMacOutString(s)
  150. char* s;
  151. { 
  152.   int slen = strlen(s);
  153.   int blen;
  154.   while ((blen = (MacOutEnd - MacOutFile->bptr) - 1) < slen) {
  155.     if(blen>0) {
  156.       strncpy(MacOutFile->bptr, s, blen);
  157.       MacOutFile->bptr += blen;
  158.       s += blen;
  159.       slen -= blen;
  160.     }
  161.     NextMacOutBuffer();
  162.   }
  163.   strcpy(MacOutFile->bptr, s);
  164.   MacOutFile->bptr += slen;
  165. }
  166.  
  167. static char* new_buffer (obuf, obufend, file)
  168.      char*      obuf;            /* Output Buffer */
  169.      char**     obufend;        /* End of Output Buffer */
  170.      FILEINFO    **file;            /* Funny #include    */
  171. {
  172.   FILEINFO* old = *file;
  173.   FILEINFO* new = get_temp_file(NBUFF, old->filename);
  174.   *obuf = EOS;
  175.   /* NOTE: this code leaves file->bptr pointing at the END of the */
  176.   /*       buffer.  This is to keep double_copy from having to use */
  177.   /*       strlen to get the number of bytes in the buffer */
  178.   old->bptr = obuf;
  179.   old->parent = new;          /* When file dries up, read from new */
  180.   *obufend = new->buffer + (NBUFF - 1);
  181.   *file = new;
  182.   return new->bptr;
  183. }
  184. /*
  185.  * Copy from the input stream to a buffer, stopping at the first
  186.  * delim, but including everything with matching {} [] ()
  187.  * <> "" '' and comments found along the way.
  188.  */
  189. static FILEINFO*
  190. copy_body(file, delim, is_string, is_top_level, expand)
  191.      FILEINFO    *file;            /* Funny #include    */
  192.      char delim;            /* Char to stop on */
  193.      int is_string;            /* True when inside a string */
  194.      int is_top_level;            /* True when the outer most call */
  195.      int expand;            /* if non-zero, macroexpand */
  196. {
  197.   register char* obuf;            /* Current output pointer */
  198.   register char c;            /* Current character */
  199.   char p;                /* Previous character */
  200.   char* obufend;            /* End of output buffer */
  201.   char newdelim;            /* New delimiter to look for */
  202.   int new_is_string = FALSE;        /* New is_string flag */
  203.  
  204.   obuf = file->bptr;            /* -> output buffer    */
  205.   obufend = file->buffer + (NBUFF - 1);    /* Note its end        */
  206.  
  207.   *obuf = EOS;
  208.   for (p = EOS; (c = get()) != EOF_CHAR; p = c) {
  209.     if (obuf >= obufend)        /* End of buffer, get a new one */
  210.       obuf = new_buffer(obuf, &obufend, &file);
  211.     if(expand && !is_string && type[c] == LET) {    /* expand macros */
  212.       c = macroid(c);            /* Grab the token    */
  213.       if (obuf >= obufend-strlen(tokenbuf)) /* End of buffer, get a new one */
  214.     obuf = new_buffer(obuf, &obufend, &file);
  215.       if(type[c] == LET) {
  216.     strcpy(obuf, tokenbuf);
  217.     obuf += strlen(tokenbuf);
  218.     continue;
  219.       }
  220.     }
  221.     *obuf++ = c;
  222.     if (c == delim)            /* Quit when delimeter found */
  223.       if (delim != '/' || p == '*') {    /* Special test for end of comment */
  224.     *obuf = EOS;
  225.     file->bptr = obuf;
  226.     return(file);
  227.       }
  228.     if (!is_string) {
  229.       switch (c) {           /* Look for new delimeters when not is_string */
  230.       case DEF_MAGIC:
  231.       case TOK_SEP:
  232.       case COM_SEP:
  233.     obuf--; continue;          /* Ignore magic characters */
  234.       case '{':  newdelim = '}'; break;
  235.       case '[':  newdelim = ']'; break;
  236.       case '(':  newdelim = ')'; break;
  237.       case '<':
  238.     if (delim != '>') continue;
  239.     newdelim = '>'; break;
  240.       case '\'':  newdelim = '\''; new_is_string = TRUE; break;
  241.       case '\"':  newdelim = '\"'; new_is_string = TRUE; break;
  242.       case '*':                  /* Start of C comment? */
  243.     if (p == '/') {
  244.       if (keepcomments) {
  245.         newdelim = '/';
  246.         new_is_string = TRUE;
  247.         break;
  248.       }                  /* Eat comment */
  249.       for (; (c = get()) != EOF_CHAR; p = c) {
  250.         if (c == '\n') {
  251.           if (obuf >= obufend)      /* End of buffer, get a new one */
  252.         obuf = new_buffer(obuf, &obufend, &file);
  253.           *obuf++ = c;          /* Preserve newlines */
  254.         } else if (c == '/' && p == '*') break;
  255.       }
  256.       if (obuf+2 >= obufend)      /* End of buffer, get a new one */
  257.         obuf = new_buffer(obuf, &obufend, &file);
  258.       *obuf++ = '*';          /* Terminate the comment */
  259.       *obuf++ = '/';
  260.     }
  261.     continue;
  262.  
  263.       case '/':                /* Start of C++ comment? */
  264.     if (p == '/') {
  265.       if (keepcomments) {
  266.         newdelim = '\n';
  267.         new_is_string = TRUE;
  268.         break;
  269.       }                  /* Eat comment */
  270.       while ((c = get()) != EOF_CHAR && c != '\n');
  271.       if (obuf >= obufend)      /* End of buffer, get a new one */
  272.         obuf = new_buffer(obuf, &obufend, &file);
  273.       *obuf++ = c;          /* Preserve newlines */
  274.     }
  275.     continue;
  276.  
  277.       default:
  278.       continue;    /* Loop to next character, unless break above */
  279.       }    /* end switch */
  280.       if (is_top_level && newdelim == delim) {
  281.     is_top_level = FALSE;
  282.     continue;        /* at top_level, with left side of delimiter */
  283.       }
  284.       file->bptr = obuf;
  285.       file = copy_body(file, newdelim, new_is_string, FALSE, expand);
  286.       if (file == NULL)
  287.     return(NULL);
  288.       obuf = file->bptr;        /* -> output buffer    */
  289.       obufend = file->buffer + (NBUFF - 1); /* Note its end        */
  290.       new_is_string = FALSE;
  291.       c = EOS; /* don't know what last character is anymore */
  292.     }  /* if !is_string */
  293.   } /* end while */
  294.   fprintf(stderr, "Searching for '%c'\n", delim); /* DEBUG */
  295.   infile = getfile(1, current_file);      /* Hack up infile */
  296.   infile->fp = stdin;              /* to print correct file */
  297.   line = current_line;              /* and line number */
  298.   cfatal("End of file during %s macro expansion.", file->filename);
  299.   return(NULL);
  300. } /* copy_body */
  301.  
  302. /* No external macros in DOS or VMS or MVS*/
  303. #if !(HOST == SYS_OS2 || HOST == SYS_VMS || HOST == SYS_MVS)
  304. /*
  305. / Copy two files in parallel: from in1 to out2 and in2 to out2 
  306. / Returns when both copies are complete, closing all files.
  307. / in1 and out2 will not block (i.e. they're files)
  308. / out1 and in2 may be pipes and can block for long periods
  309. */
  310. static void
  311. doublecopy (in1, out1, in2, out2)
  312.  
  313.   FILEINFO    *in1, *out2;  
  314.   int           out1, in2;
  315. {
  316.   fd_set readfds;
  317.   fd_set writefds;
  318.   fd_set errorfds;
  319.   int n, width;
  320.   int is_first = TRUE;
  321.   char* outptr = in1->buffer;
  322.  
  323.   width = 1 + ((in2 > out1) ? in2 : out1); /* width = max(in2, out1); */
  324.  
  325.   do {
  326.     FD_ZERO(&readfds);
  327.     FD_ZERO(&writefds);
  328.     FD_ZERO(&errorfds);
  329.     if (in2  >= 0) FD_SET(in2, &readfds);
  330.     if (out1 >= 0) FD_SET(out1, &writefds);
  331.  
  332.     if (select(width, &readfds, &writefds, &errorfds, NULL) <= 0)
  333.       perror("Select Error");
  334.  
  335.     if (out1>=0 && FD_ISSET(out1, &errorfds))
  336.       perror("Select output Error");
  337.  
  338.     if (in2>=0 && FD_ISSET(in2, &errorfds))
  339.       perror("Select input Error");
  340.  
  341.     if (!(out1>=0 && FD_ISSET(out1, &writefds)) &&
  342.     !(in2>=0 && FD_ISSET(in2, &readfds))) {
  343.       perror("Select when nothing happened");
  344.     }
  345.  
  346.     if (out1>=0 && FD_ISSET(out1, &writefds)) {
  347.       if (in1 == NULL) {
  348.     close(out1);
  349.     out1 = -1;
  350.       } else {
  351.     int nbytes = in1->bptr - outptr;
  352.     int wbytes = write(out1, outptr, nbytes);
  353.     if (wbytes < 0)
  354.       perror("Error writing to pipe");
  355.     outptr += wbytes;
  356.     if (nbytes == wbytes) {
  357.       in1 = in1->parent;
  358.       if (in1 != NULL)
  359.         outptr = in1->buffer;
  360.     }
  361.       }
  362.     }
  363.  
  364.     if (in2>=0 && FD_ISSET(in2, &readfds)) {
  365.       if (is_first)
  366.     is_first = FALSE;
  367.       else {                /* Chain in a new buffer */
  368.     FILEINFO* new = get_temp_file(NBUFF, out2->filename);
  369.     new->parent = out2->parent;    /* When new ends read from infile */
  370.     out2->parent = new;            /* When out2 dries up, read from new */
  371.     out2 = new;
  372.       }
  373.       n = read(in2, out2->buffer, NBUFF);
  374.       if (n <= 0) {
  375.     if(n<0)
  376.       perror("Error reading from pipe");
  377.     close(in2);
  378.     in2 = -1;
  379.       } else {
  380.     char* p = out2->buffer + n;
  381.     *p = EOS;    
  382.       }
  383.     }
  384.   } while (in2>=0 || out1>=0);
  385. } /* end doublecopy */
  386. #endif
  387.  
  388. /* No external macros in DOS or VMS MVS*/
  389. #if !(HOST == SYS_OS2 || HOST == SYS_VMS || HOST == SYS_MVS)
  390. /*
  391.  * Fork an external macro expander
  392.  */
  393. static void
  394. fork_macro (args, ifile, ofile)
  395.      struct macroargs* args;
  396.      FILEINFO *ifile, *ofile;
  397. {     
  398.   int inchannel, outchannel;
  399.   int forkin, forkout;
  400.   int pid, status;
  401.   {                    /* Create the pipes */
  402.     int sv[2];
  403.     pipe (sv);
  404.     forkin = sv[0];
  405.     outchannel = sv[1];
  406.     pipe (sv);
  407.     inchannel = sv[0];
  408.     forkout = sv[1];
  409.   }
  410.                     /* Fork the macro process */
  411.   if ((pid = fork ()) == 0) {
  412.     /* child process.  Move pipes to stdin and stdout then exec */
  413.     close(0); dup2(forkin, 0);
  414.     close(1); dup2(forkout, 1);
  415.     close(forkin);
  416.     close(forkout);
  417.     close(inchannel);  /* Close files used only by the parent */
  418.     close(outchannel);
  419.     execv(args->program, args->args);
  420.     /* execv never returns */
  421.   }
  422.   close(forkin);  /* Close files used only by the child */
  423.   close(forkout);
  424.   if (pid < 0) 
  425.     cfatal("Can't fork %s macro.", args->program);
  426.   /* Make output to the pipe non-blocking to avoid deadlocks */
  427.   fcntl(outchannel, F_SETFL, FNDELAY | fcntl(outchannel, F_GETFL, 0));
  428.   doublecopy (ifile, outchannel, inchannel, ofile);
  429.   wait(&status);
  430.   if(status != 0)
  431.     cerror("Error during %s macro expansion", args->program);
  432. }
  433. #endif   /* not DOS or VMS or MVS */
  434. /*
  435.  * Call an internal macro expander
  436.  */
  437. static void
  438. call_expander (args, ifile, ofile)
  439.      struct macroargs* args;
  440.      FILEINFO *ifile, *ofile;
  441. {     
  442.   int nargs = 0;
  443.   char** arg = args->args;
  444.   while(*arg++ != NULL) nargs++;    /* Count args */
  445.   *ifile->bptr = EOS;
  446.   ifile->bptr = ifile->buffer;
  447.   MacInFile = ifile;            /* Set global I/O buffers */
  448.   MacOutFile = ofile;
  449.   MacOutEnd = ofile->buffer + (NBUFF - 1);
  450.   if (((*args->expander)(nargs, args->args)) != 0)
  451.     cerror("Error during internal %s macro expansion", args->program);
  452.   *MacOutFile->bptr = EOS;
  453.   MacOutFile->bptr = MacOutFile->buffer;
  454. }
  455. /*
  456.  * Expand an external macro.
  457.  *   1. Grab the macro name and everything until the next semicolon
  458.  *      (includling all matching {} [] () <> "" '' and comments found along
  459.  *      the way), and put it in a macro buffer.  Commands found along
  460.  *      the way are processed.
  461.  *   2. Pipe this into the macro, and put the result in another macro buffer.
  462.  *   3. Process the macro expansion.
  463.  */
  464. void
  465. expand_external(dp)
  466.   char* dp;
  467. {
  468.   FILEINFO    *ifile, *ofile;    /* The first output file buffer */
  469.   struct macroargs* args = (struct macroargs*) dp; /* macro arguments */
  470.   char* name = args->name;        /* Macro name */
  471.   extern int macroid();            /* Get a macro-expanded character */
  472.  
  473.   if(!args->recursive) {
  474.     FILEINFO *f;            /* If recursion where it isn't allowed */
  475.     for (f = infile; (f->parent != NULL); f = f->parent) {
  476.       if(strcmp(f->filename, name) == 0) {
  477.     fputs(name, stdout);    /* Skip expansion */
  478.     return;}}}
  479.   /*
  480.    * Ensure the start is correct
  481.    */
  482.   strcpy(work, name);
  483.   workp = work + strlen(name);
  484.   { char c;            /* current character */
  485.     char d = args->conditional;
  486.     if(d != EOS) {        /* check for conditional character */
  487.       instring = TRUE;
  488.       while(isspace(c = get())) *workp++ = c;
  489.       *workp = EOS;
  490.       instring = FALSE;
  491.       unget();
  492.       if (c != d) {        /* When no conditional character, exit */
  493. #ifdef paranoia
  494.     cwarn("defmacro \"%s\" needs arguments", name);
  495. #endif
  496.                 /* Place macro name back in input stream */
  497.                 /* being careful to avoid recursion */
  498.     /* fputs(work, stdout); this isn't good enough */
  499.     ofile = get_temp_file(strlen(work)+1, name);
  500.     ofile->parent = infile;
  501.     ofile->buffer[0] = DEF_MAGIC;
  502.     strcpy(ofile->buffer+1, work);
  503.     infile = ofile;
  504.     return;
  505.       }
  506.     }
  507.   }
  508.   current_line = line;
  509.   strcpy(current_file,
  510.      (infile->progname != NULL) ? infile->progname : infile->filename);
  511.   /*
  512.    * Copy everything to the next ;
  513.    */
  514.   ifile = get_temp_file(NBUFF, name);
  515.   ofile = get_temp_file(NBUFF, name);
  516.   strcpy(ifile->buffer, work);    /* Send name to macro expander */
  517.   ifile->bptr = ifile->buffer + strlen(work);
  518.   instring = TRUE;        /* Ensure comments get copied too */
  519.   if (copy_body(ifile, args->delimiter, FALSE, TRUE, args->expanding) == NULL) {
  520.     instring = FALSE;
  521.     return;
  522.   }
  523.   instring = FALSE;
  524.   infile->line = line;
  525.   /*
  526.    * Expand the macro
  527.    */
  528.   ofile->parent = infile;
  529.   if (args->expander == NULL) {
  530. #if !(HOST == SYS_OS2 || HOST == SYS_VMS || HOST == SYS_MVS)
  531.     fork_macro(args, ifile, ofile);
  532. #else
  533.     cfatal("Internal cpp error - external macros not supported", "");
  534. #endif
  535.   }
  536.   else
  537.     call_expander(args, ifile, ofile);
  538.   infile = ofile;
  539. }
  540.  
  541. /*
  542.  * scanthing(delim)
  543.  *   Copy from input to work, stopping at delim
  544.  *   but including everything with matching {} [] ()
  545.  *   <> "" '' and comments found along the way.
  546.  */
  547. static int
  548. scanthing(delim, is_string, is_top_level)
  549.   char delim;                     /* Current delimiter */
  550.   int is_string, is_top_level;            /* flags */
  551. {
  552.   char c;                     /* Current character */
  553.   char newdelim;            /* New delimiter to look for */
  554.   int new_is_string = FALSE;        /* New is_string flag */
  555.  
  556.   if (is_top_level) {            /* Skip leading whitespace */
  557.     workp = work;
  558.     c = skipws();
  559.     unget();
  560.   }
  561.   while ((c = get()) != EOF_CHAR) {
  562.     save(c);
  563.     if (delim == c &&            /* Quit when delimeter found */
  564.     delim != ' ') {
  565.       *workp = EOS;
  566.       return FALSE;
  567.     }
  568.     if (!is_string) {
  569.       switch (c) {        /* Look for new delimeters when not is_string */
  570.       case ' ':
  571.       case ',':
  572.       case '\t':
  573.       case '\n':
  574.     if (delim == ' ') {
  575.       unget();
  576.       workp -= 1;
  577.       *workp = EOS;
  578.       return FALSE;
  579.     } else continue;
  580.       case '{':  newdelim = '}'; break;
  581.       case '[':  newdelim = ']'; break;
  582.       case '(':  newdelim = ')'; break;
  583.       case '\'':  newdelim = '\''; new_is_string = TRUE; break;
  584.       case '\"':  newdelim = '\"'; new_is_string = TRUE; break;
  585.       default: 
  586.     continue;        /* Loop to next character, unless break above */
  587.       }    /* end switch */
  588.       if (is_top_level && newdelim == delim) {
  589.     is_top_level = FALSE;
  590.     continue;        /* at top_level, with left side of delimiter */
  591.       }
  592.       scanthing(newdelim, new_is_string, FALSE);
  593.       new_is_string = FALSE;
  594.     }  /* if !is_string */
  595.   } /* end while */
  596.   return (c == EOF_CHAR);
  597. } 
  598. /*
  599.  * create a new defmacro (internal function)
  600.  */
  601. void
  602. new_defmacro(name, expanding, recursive, delimiter, conditional, 
  603.          expander, program, args)
  604.   char* name;
  605.   char  expanding;        /* Non-zero when args are macro expanded */
  606.   char  recursive;        /* Non-zero when recursive */
  607.   char  delimiter;        /* Delimiter */
  608.   char  conditional;        /* Expand only if this char found after name */
  609.   internal_expander expander;    /* Macro expander or NULL if file */
  610.   char *program;        /* macro program pathname */
  611.   char** args;            /* arg list (vector of strings) */
  612. {
  613.   struct macroargs* new;
  614.   int nargs = 1;
  615.   char** argp;
  616.  
  617.   if (args == NULL) {              /* Setup default args */
  618.     args = (char**) getmem(sizeof(char*)*2);
  619.     args[0] = program;
  620.     args[1] = NULL;
  621.   }
  622.   for(argp = args; *argp++!=NULL; nargs++);    /* Count arguments */
  623.  
  624.   new = (struct macroargs*) getmem(sizeof(struct macroargs) +
  625.                    (nargs*sizeof(char*)));
  626.   new->name = name;
  627.   new->expanding = expanding;
  628.   new->recursive = recursive;
  629.   new->delimiter = delimiter;
  630.   new->conditional = conditional;
  631.   new->expander = expander;
  632.   new->program = program;
  633.   while(nargs-- > 0)
  634.     new->args[nargs] = args[nargs];
  635.   define_builtin(name, expand_external, (char*) new);
  636. }
  637.  
  638. /*
  639.  * Define an external macro handler
  640.  *
  641.  *     Called when #pragma defmacro
  642.  *     is found in the input.
  643.  * The complete form is:
  644.  * #pragma defmacro name <file> options
  645.  * #pragma defmacro name "file" options
  646.  * #pragma defmacro name program options
  647.  *
  648.  * where "options" is zero or more of the following:
  649.  *  recursive    - when present, the macro is recursively expanded
  650.  *  delimiter=?  - the default delimiter of ; is replaced with ?
  651.  *  condition=?  - Expand only if this char found after name
  652.  *  other        - other options are passed as arguments to the
  653.  *                 macro expander
  654.  */
  655. void
  656. define_external()
  657. {
  658.   char c;
  659.   char delim;
  660.   char* name;
  661.   char* program;
  662.   int nargs = 1;
  663.   int maxargs = 32;
  664.   char* args[32];
  665.   int recursive = 0;
  666.   int expanding = 0;
  667.   int delimiter = ';';
  668.   int conditional = EOS;
  669.   internal_expander expander = NULL;
  670.  
  671.   c = skipws();
  672.   scanid(c);
  673.   name = savestring(tokenbuf);
  674.   program = name;
  675.         /* Parse_include returns EOS for internal macros (no " or <) */
  676.   delim = parse_include();          /* Get program to work */
  677.   strcpy(tokenbuf, work); /* Keep copy because findinclude mangles it */
  678.  
  679.   if (delim == EOS || findinclude(work, (delim == '"'), X_OK) == FALSE) {
  680.     struct expander_pair* p = internal_macros; /* Macro file not found */
  681.     strcpy(work, tokenbuf);                    /* restore progam name */
  682.     for (; p->name != NULL; p++)           /* Search for internal macro */
  683.       if (strcmp(p->name, work) == 0) {
  684.     expander = p->function;
  685.     goto found_internal;
  686.       }    
  687.     cerror("Cannot open macro file \"%s\"", work);
  688.     goto macerr;
  689.   }
  690. #if HOST == SYS_OS2 || HOST == SYS_VMS || HOST == SYS_MVS 
  691.   else {
  692.     cerror("External macros not supported for \"%s\"", work);
  693.     goto macerr;
  694.   }
  695. #endif
  696. found_internal:
  697.   program = args[0] = savestring(work);
  698.  
  699.   c = skipws();
  700.   while (c != '\n' && c != EOF_CHAR) {
  701.     while (c == ',') {
  702.       args[nargs++] = ",";
  703.       c = skipws();
  704.     }
  705.     unget();
  706.     if (scanthing(' ', FALSE, TRUE))
  707.       cfatal("End of file during #pragma defmacro %s processing.", name);
  708.     if(strcmp(work, "recursive") == 0) {
  709.       recursive = 1;
  710.       c = skipws();
  711.       continue;
  712.     }
  713.     if(strcmp(work, "expanding") == 0) {
  714.       expanding = 1;
  715.       continue;
  716.     } 
  717.     {
  718.       int* option = NULL;
  719.       if(strncmp(work, "delimiter", 9) == 0) option = &delimiter;
  720.       if(strncmp(work, "condition", 9) == 0) option = &conditional;
  721.       if(option != NULL) {
  722.     if (work[9] != '=' && (c = skipws()) != '=') {
  723.       cerror("In #pragma defmacro, Missing = after %s", work);
  724.       goto macerr;
  725.     }
  726.     if(strlen(work) == 11)
  727.       *option = work[10];
  728.     else 
  729.       *option = skipws();
  730.     if(*option != '\n') c = skipws();
  731.     continue;
  732.       }
  733.     }                /* must be a program option */
  734.     if (nargs >= maxargs) {
  735.       cerror("In #pragma defmacro %s, too many arguments.", name);
  736.       goto macerr;
  737.     }
  738.     args[nargs] = savestring(work);
  739.     nargs++;
  740.     c = skipws();
  741.   } /* end while not newline */
  742.   unget();            /* Force nl after includee    */
  743.   args[nargs] = NULL;
  744.   new_defmacro(name, expanding, recursive, delimiter, conditional, 
  745.            expander, program, args);
  746.   return;
  747.  
  748.  macerr:
  749.   skipnl();            /* Skip to end of line */
  750.   unget();            /* Force nl */
  751.   return;
  752. }
  753.  
  754. /*-----------------------------------------------------------------------------
  755.  * Process DEFPACKAGE command.
  756.  * format is: defpackage NAME <path> options
  757.  * where options are optional and seperated by comma's.
  758.  *
  759.  * This really should be an internal defmacro, but
  760.  * it was so much easier to handle it here...
  761.  */
  762. static char* defpackage_options[] = {
  763.   "length", "case",
  764.   "start", "increment", "template", "max", "use_first", "nospace", NULL};
  765.  
  766. void
  767. define_package(dp)
  768.   char* dp;
  769. {
  770.   extern void package_define();
  771.   char c;
  772.   char delim;
  773.   char* pkgname;
  774.   char* pkgfile;
  775.   char* options[8];
  776.   long loptions[6];
  777.   int np;
  778.   char errmsg[100];
  779.  
  780.   options[0]=""; options[1]=""; options[2]=""; options[3]="";
  781.   options[4]=""; options[5]=""; options[6]=""; options[7]="";
  782.   c = skipws();
  783.   scanid(c);
  784.   pkgname = savestring(tokenbuf);
  785.   if((delim = parse_include()) == EOS) {
  786.     cerror("DEFPACKAGE syntax error", NULLST);
  787.     goto macerr;
  788.   }
  789.   if (findinclude(work, (delim == '"'), R_OK) == FALSE) {
  790.     cerror("Cannot open package header file \"%s\"", work);
  791.     goto macerr;
  792.   }
  793.   pkgfile = savestring(work);
  794.                       /* Get options */
  795.   while ((c=skipws()) != '\n' && c != EOF_CHAR) {
  796.     char** p;
  797.     if (c == ',')              /* Skip over commas */
  798.       if ((c=skipws()) == '\n' || c == EOF_CHAR)
  799.     break;
  800.     scanid(c);
  801.     np = 0;
  802.     p = defpackage_options;
  803.     for (; *p != NULL; p++, np++) 
  804.       if(strcmp(tokenbuf, *p) == 0) break;
  805.     if (*p == NULL) {
  806.       sprintf(errmsg, "In DEFPACKAGE %s, unknown option \"%s\"",
  807.           pkgname, tokenbuf);
  808.       cerror(errmsg, NULLST);
  809.       goto macerr;
  810.     } else if ((c = skipws()) != '=') {
  811.       sprintf(errmsg, "In DEFPACKAGE %s, Missing = after %s option",
  812.           pkgname, tokenbuf);
  813.       cerror(errmsg, NULLST);
  814.       goto macerr;
  815.     } else {
  816.       c = skipws();
  817.       scanid(c);
  818.       options[np] = savestring(tokenbuf);
  819.     }
  820.   }
  821.   unget();  /* Force nl after includee */
  822.                       /* Convert numeric options */
  823.   for(np=2; np<8; np++) {
  824.     char* endp[1];
  825.     long val = strtol(options[np], endp, 0);
  826.     if(**endp != EOS) {
  827.       sprintf(errmsg, "In DEFPACKAGE %s, Illegal value %s for %s option",
  828.           pkgname, options[np], defpackage_options[np]);
  829.       cwarn(errmsg, NULLST);
  830.     }
  831.     loptions[np-2] = val;
  832.   }
  833.   package_define(pkgname, pkgfile, 
  834.          options[0], options[1], loptions[0], loptions[1],
  835.          loptions[2], loptions[3], loptions[4], loptions[5]);
  836.   return;
  837.  
  838.  macerr:
  839.   skipnl();            /* Skip to end of line */
  840.   unget();            /* Force nl */
  841.   return;
  842. }
  843.