home *** CD-ROM | disk | FTP | other *** search
/ CD Actual 14 / CDACTUAL.iso / cdactual / demobin / share / program / c / ZCPP_JAE.ZIP / MACRO.C < prev    next >
Encoding:
C/C++ Source or Header  |  1990-07-06  |  12.8 KB  |  490 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.  * Edit history
  17.  * Created: LGO 30-Mar-89 -- Initial design and implementation.
  18.  *
  19.  * MACRO defmacro
  20.  *
  21.  * CPP defmacro for building macros which can include cpp directives.
  22.  * MACRO works like #define, except the macro body is NOT limited to a
  23.  * single line, and may contain arbitrary cpp directives.  Optional,
  24.  * keyword and body parameters are accepted.
  25.  *
  26.  * To define a macro, the following must have been encountered in the input
  27.  * stream: 
  28.  *     #pragma defmacro MACRO "macro" delimiter=}
  29.  *
  30.  * A macro definition has the form:
  31.  *    MACRO name(arglist) { body }
  32.  *
  33.  * where name is the name of the macro, arglist are argument
  34.  * specifiers seperated by comma's and body is what is substituted on a 
  35.  * call to the macro. arglist may specify positional, optional,
  36.  * optional keyword, required keyword, rest and body arguments.
  37.  * The syntax is:
  38.  * arglist := [KEY: | REST: | BODY] identifier [= identifier] [, arglist]
  39.  *
  40.  * The equals sign indicates a default argument value.
  41.  * When KEY: is encountered, the rest of the arguments are all keyword
  42.  * arguments. A rest parameter will be set to all remaining parameter
  43.  * values during macro expansion.  REST: parm=name indicates that "parm"
  44.  * will hold the rest of the parameters, and "name" will hold the number
  45.  * of parameters in "parm".  BODY: parm indicates that "parm" will expand to
  46.  * the text within braces {} after the macro call. The braces are removed.
  47.  *
  48.  * Example 1:
  49.  *    MACRO set_val (size, value=NULL, KEY: low = 0, high = 100)
  50.  *    { set_val_internal(size, val, low, high-low) }
  51.  *
  52.  *    set_val    is the macro name
  53.  *    size    is a required positional parameter
  54.  *    val    is an optional positional parameter
  55.  *    low    is an optional keyword parameter
  56.  *    high    is a required keyword parameter
  57.  *
  58.  * Example 2:
  59.  *   // Build a table of char*'s
  60.  *   MACRO build_table(name, REST: rest)
  61.  *   { char* name[] = { build_table_internal(rest) NULL} }
  62.  *
  63.  *   MACRO build_table_internal(first, REST: rest=count)
  64.  *   {#first,
  65.  *   #if count // recurse on rest args
  66.  *   build_table_internal(rest)
  67.  *   #endif
  68.  *   }
  69.  *
  70.  *   build_table(table, 1,2,3,4,5,6,7);   // expands to
  71.  *   char* table[] = {"1", "2", "3", "4", "5", "6", "7"};
  72.  * 
  73.  * Example 3:
  74.  *
  75.  *   MACRO LOOP (type, variable, sequence, BODY: body) {
  76.  *   { type varible;
  77.  *     for(sequence.reset; sequence.next;) {
  78.  *       variable = sequence.value();
  79.  *       body
  80.  *       }
  81.  *   }}
  82.  *
  83.  *   LOOP(char, elt, list) { print(elt) } // Expands to:
  84.  *
  85.  *   { char varible;
  86.  *     for(list.reset; list.next;) {
  87.  *       elt = list.value();
  88.  *       print(elt)
  89.  *     }
  90.  *   }
  91.  *
  92.  * Error messages: (first %s is macro name)
  93.  *    %s: Can't find argument list
  94.  *    %s: REST and BODY args must be last
  95.  *    %s: Unknown parameter keyword: %s:
  96.  *    %s: Syntax error, '%c' found after %s=%s
  97.  *    %s: Syntax error, '%c' found after %s
  98.  *    %s: The required argument %s is missing
  99.  *    %s: Keyword missing for %s
  100.  *    %s: The required keyword argument %s is missing
  101.  *    %s: body argument not found
  102.  *    %s: Unknown argument: %s
  103.  *    %s: Missing ; after macro body
  104.  */
  105.  
  106. #include "defmacio.h"
  107. #include "macro.h"
  108.  
  109. typedef struct mac_def {
  110.   char* name;
  111.   Arg* args;
  112.   char* body;
  113. } Mac_Def;
  114.  
  115. #define BSIZE 512
  116. #define MAXPARM 32
  117.  
  118. Arg arg_error;                  /* Global error flag */
  119. /*
  120.  * Parse macro args
  121.  */
  122. Arg*
  123. macro_args(macname)
  124.    char* macname;
  125. {
  126.   char c;
  127.   char* name;
  128.   char* value;
  129.   Type type = p_positional;
  130.   Arg* result = NULL;
  131.   Arg* next = NULL;
  132.   Arg* new;
  133.   Boolean rest_or_body = FALSE;
  134.  
  135.   c = skip_blanks();
  136.   if(c != '(') {
  137.     fprintf(stderr, "%s: Can't find argument list", macname);
  138.     return &arg_error;
  139.   }
  140.   do {
  141.     if(type==p_body || type==p_rest)
  142.       rest_or_body = TRUE;
  143.     else if (rest_or_body) {
  144.       fprintf(stderr, "%s: REST and BODY args must be last", macname);
  145.       return &arg_error;
  146.     }
  147.     value="";
  148.     name=scan_token(",):=");
  149.     c = getchar();
  150.     if (c==':') {
  151.       if(!strcmp(name, "KEY"))
  152.     type=p_key;
  153.       else if (!strcmp(name, "REST"))
  154.     type=p_rest;
  155.       else if (!strcmp(name, "BODY"))
  156.     type=p_body;
  157.       else {
  158.     fprintf(stderr, "%s: Unknown parameter keyword: %s", macname, name);
  159.     return &arg_error;
  160.       }
  161.       name=scan_token(",):=");
  162.       c = getchar();
  163.     }
  164.     switch (c) {
  165.     case ')': break;
  166.     case ',': break;
  167.     case '=':
  168.       value=scan_token(",)");
  169.       c=getchar();
  170.       if(c == ',' || c == ')') break;
  171.       fprintf(stderr, "%s: Syntax error, '%c' found after %s=%s",
  172.           macname, c, name, value);
  173.       return &arg_error;
  174.     default:
  175.       fprintf(stderr, "%s: Syntax error, '%c' found after %s", macname, c, name);
  176.       return &arg_error;
  177.     }
  178.     new = (Arg*) getmem(sizeof(Arg));      /* Create new Arg structure */
  179.     if (result == NULL)
  180.       result = new;
  181.     else 
  182.       next->next = new;
  183.     next = new;
  184.     new->next = NULL;
  185.     new->name = name;
  186.     new->value = value;
  187.     new->type = type;      
  188.   } while (c != ')');
  189.   return result;
  190. }
  191. /*
  192.  * Write body returning when a token is found
  193.  */
  194. static char*
  195. get_token(body, tokenbuf, modifier)
  196.   char* body;
  197.   char* tokenbuf;
  198.   Modifier* modifier;
  199. {
  200.   char c;
  201.   char p = EOS;
  202.   char* bodyp = body;
  203.   char* tokenp = tokenbuf;
  204.   *modifier = mod_none;
  205.   while((c = *bodyp++) != EOS) {
  206.     if(isalnum(c) || c=='_' || c=='$') {
  207.       *tokenp++ = c;
  208.       while((c = *bodyp++) != EOS) {
  209.     if((isalnum(c) || c=='_' || c=='$'))
  210.       *tokenp++ = c;
  211.     else {                  /* End of token */
  212.       *tokenp = EOS;
  213.       return bodyp-1;
  214.     }
  215.       }                      /* End of body with token */
  216.       *tokenp = EOS;
  217.       return bodyp-1;
  218.     }
  219.     else if(c == '#') {
  220.       if (*bodyp == '#') {          /* token catenation */
  221.     *modifier = mod_concat;
  222.     bodyp++;
  223.     while(isspace(*bodyp)) bodyp++;
  224.       } else {
  225.     if (p != EOS) putchar(p);
  226.     if (isalnum(*bodyp)) {          /* token quoting */
  227.       *modifier = mod_quote;
  228.     } else if(*bodyp == '~') {      /* Special hack #~ for unquote */
  229.       bodyp++;
  230.       *modifier = mod_unquote;
  231.     } else {
  232.       putchar(c);
  233.     }
  234.       }
  235.     } else {
  236.       if (*bodyp == '#')
  237.     p = c;
  238.       else {
  239.     putchar(c);
  240.     p = EOS;
  241.       }
  242.     }
  243.   }
  244.   *tokenp = EOS;
  245.   return bodyp-1;              /* End of body no token */
  246. }
  247. /* 
  248.  * Write body substituting args for values
  249.  */
  250. void
  251. macro_substitute(body, nparm, parnames, parvalues)
  252.   char* body;
  253.   int nparm;
  254.   char** parnames;
  255.   char** parvalues;
  256. { 
  257.   Modifier modifier;
  258.   char tokenbuf[BSIZE];
  259.   int i;
  260.   Boolean prev_match = FALSE;
  261.   do {
  262.     body = get_token(body, tokenbuf, &modifier);
  263.     for(i=nparm; i--;) {
  264.       if(!strcmp(tokenbuf, parnames[i])) {
  265.     char* val = parvalues[i];
  266.     prev_match = TRUE;
  267.     switch (modifier) {
  268.     case mod_quote:
  269.       put_string(val);
  270.       break;
  271.     case mod_unquote:
  272.       { char c;
  273.         val++;
  274.         while((c=*val++) != EOS)
  275.           if(*val == EOS) break;
  276.           else if(!(c == '\\' && *val == '"'))
  277.         putchar(c);
  278.       }
  279.       break;
  280.     default:
  281.       puts(val);
  282.       break;
  283.     }
  284.     goto next;
  285.       }
  286.     }
  287.     switch (modifier) {
  288.     case mod_concat:
  289.       if (prev_match) break;
  290.       putchar('#');
  291.     case mod_quote: putchar('#'); break;
  292.     case mod_unquote: puts("#~"); break;
  293.     }
  294.     puts(tokenbuf);
  295.     prev_match = FALSE;
  296.   next:
  297.     ;
  298.   }
  299.   while (*body != EOS);
  300. }
  301. /*
  302.  * Expand a macro defined by define_macro
  303.  */
  304. expand_macro(argc, argv)
  305.      int argc;
  306.      char* argv[];
  307. {
  308.   Mac_Def* mac = (Mac_Def*) argv[1];
  309.   char c;
  310.   Arg* call_argp;
  311.   Arg* def_argp = mac->args;
  312.   Arg* args = NULL;
  313.   Arg* argp;
  314.   char* bodyarg = NULL;
  315.   int nparm = 0;
  316.   char* parnames[MAXPARM];
  317.   char* parvalues[MAXPARM];
  318.   char junk[BSIZE];
  319.   int n;
  320.   char nstr[4];
  321.  
  322.   if(copytoken(junk) == NULL)      /* Skip macro name */
  323.     return(1);
  324.     
  325.   if(def_argp && def_argp->type != p_body) {
  326.     if((args = macro_args(mac->name)) == &arg_error) {  /* Gather arguments */
  327.       fprintf(stderr, " in %s\n", junk);
  328.       return(1);
  329.     }
  330.   }
  331.   call_argp = args;              /* Match calling and defining args */
  332.   for (; def_argp != NULL; def_argp = def_argp->next) {
  333.     switch (def_argp->type) {
  334.     case p_positional:
  335.       parnames[nparm] = def_argp->name;
  336.       if(call_argp != NULL) {
  337.     parvalues[nparm] = (*call_argp->value != EOS) ?
  338.       call_argp->value : call_argp->name;
  339.     call_argp = call_argp ->next;
  340.       } else if (*def_argp->value != EOS)
  341.     parvalues[nparm] = def_argp->value;
  342.       else {
  343.     fprintf(stderr, "%s: The required argument %s is missing\n",
  344.         mac->name, def_argp->name);
  345.     return 1;
  346.       }
  347.       break;
  348.     case p_rest:
  349.       parnames[nparm] = def_argp->name;
  350.       *junk = EOS;
  351.       n = 0;
  352.       for(;call_argp != NULL; call_argp = call_argp->next) {
  353.     strcat(junk, call_argp->name);
  354.     if (*call_argp->value != EOS) {
  355.       strcat(junk, "=");
  356.       strcat(junk, call_argp->value);
  357.     }
  358.     if (call_argp->next)
  359.       strcat(junk, ", ");
  360.     n++;
  361.       }
  362.       parvalues[nparm] = junk;
  363.       /* If rest arg has a default value */
  364.       if (*def_argp->value != EOS) {      /* Use it as the name of a parameter */
  365.     sprintf(nstr, "%d", n);          /* which holds the number of rest args */
  366.     nparm++;
  367.     parnames[nparm] = def_argp->value;
  368.     parvalues[nparm] = nstr;
  369.       }
  370.       break;
  371.     case p_key:
  372.       parnames[nparm] = def_argp->name;
  373.       parvalues[nparm] = def_argp->value;
  374.       { Arg* argp = call_argp;
  375.     for(;argp != NULL; argp = argp->next) {
  376.       if(*argp->name == EOS) {
  377.         fprintf(stderr, "%s: Keyword missing for %s\n",
  378.             mac->name, argp->value);
  379.         return 1;
  380.       }
  381.       if(!strcmp(argp->name, def_argp->name)) {
  382.         parvalues[nparm] = argp->value;
  383.         argp->type = p_key;          /* Munge type to indicate used */
  384.         break;
  385.       }
  386.     }
  387.       }
  388.       if (*parvalues[nparm] == EOS) {
  389.     fprintf(stderr, "%s: The required keyword argument %s is missing\n",
  390.         mac->name, def_argp->name);
  391.     return 1;
  392.       }
  393.       break;
  394.     case p_body:
  395.       c = skip_blanks();
  396.       if (c != '{') {
  397.     fprintf(stderr, "%s: body argument not found\n", mac->name);
  398.     do { putchar(c); }          /* error recovery */
  399.     while ((c=getchar()) != EOF);
  400.     return 1;
  401.       }
  402.       unget();
  403.       bodyarg = scan_next('}');          /* Grab the macro body */
  404.       {char* bp = bodyarg + strlen(bodyarg) - 1;
  405.        *bp = EOS;}              /* Strip {} from body */
  406.       parnames[nparm] = def_argp->name;
  407.       parvalues[nparm] = bodyarg+1;
  408.       break;
  409.     }
  410.     nparm++;
  411.   }
  412.   if (call_argp != NULL) {          /* Check for unused keyargs */
  413.     for(argp = call_argp; argp != NULL; argp = argp->next)
  414.       if (argp->type != p_key) {
  415.     fprintf(stderr, "%s: Unknown argument: %s\n",
  416.         mac->name, argp->name);
  417.     return 1;
  418.       }
  419.   } 
  420.                       /* Substitute args for values */
  421.   macro_substitute(mac->body, nparm, parnames, parvalues);
  422.   for(argp = args; argp != NULL;) {
  423.     Arg* old = argp;
  424.     argp = argp->next;
  425.     free(old->name);
  426.     if (*old->value) free(old->value);
  427.     free(old);
  428.   }
  429.   return 0;
  430. }
  431. /*
  432.  * Define a new macro
  433.  */
  434. int
  435. define_macro(argc, argv)
  436.      int argc;
  437.      char* argv[];
  438. {
  439.   char* name;
  440.   Arg* args;
  441.   char* body;
  442.   Mac_Def* mac;
  443.   char expanding = 0;
  444.  
  445.   { char macname[BSIZE];
  446.     if(copytoken(macname) == NULL)      /* Skip macro name */
  447.       return(1);
  448.     if(copytoken(macname) == NULL)      /* Copy the macro name */
  449.       return(1);
  450.     if(!strcmp(macname, "EXPANDING")) {
  451.       expanding = 1;
  452.       if(copytoken(macname) == NULL)      /* Copy the macro name */
  453.     return(1);
  454.     }
  455.     name = savestring(macname);
  456.   }
  457.   if((args = macro_args("MACRO")) == &arg_error) {  /* Gather arguments */
  458.     fprintf(stderr, " in %s\n", name);
  459.     return(1);
  460.   }
  461.   skip_blanks();
  462.   unget();
  463.   body = savestring(scan_next('}'));          /* Grab the macro body */
  464.   { char* bp;
  465.     while(*body++ != '{');          /* strip start of body */
  466.     bp = body + strlen(body);          /* Strip end of body */
  467.     *--bp = EOS;
  468.   }
  469.   mac = (Mac_Def*) getmem(sizeof(Mac_Def));  /* Create new macro structure */
  470.   mac->name = name;
  471.   mac->args = args;
  472.   mac->body = body;
  473.   { char delim = ')';
  474.     Boolean recursive = FALSE;
  475.     char* arglist[3];
  476.     arglist[0] = name;
  477.     arglist[1] = (char*) mac;
  478.     arglist[2] = NULL;
  479.     if (args != NULL) {
  480.       Arg* a = args;
  481.       while(a->next!=NULL) a = a->next;      /* Find last parameter */
  482.       if(a->type == p_body) delim = '}';
  483.       if(a->type == p_rest || a->type == p_body) recursive = TRUE;
  484.     }
  485.     new_defmacro(name, expanding, recursive, delim, EOS,
  486.          expand_macro, name, arglist);
  487.   }
  488.   return 0;
  489. }
  490.