[BACK]Return to eval.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / m4

Diff for /src/usr.bin/m4/eval.c between version 1.48 and 1.49

version 1.48, 2003/06/18 21:08:07 version 1.49, 2003/06/30 21:42:50
Line 61 
Line 61 
 #include "extern.h"  #include "extern.h"
 #include "pathnames.h"  #include "pathnames.h"
   
 #define BUILTIN_MARKER  "__builtin_"  
   
 static void     setup_definition(ndptr, const char *);  
 static void     dodefn(const char *);  static void     dodefn(const char *);
 static void     dopushdef(const char *, const char *);  static void     dopushdef(const char *, const char *);
 static void     dodump(const char *[], int);  static void     dodump(const char *[], int);
Line 82 
Line 79 
 static const char *handledash(char *, char *, const char *);  static const char *handledash(char *, char *, const char *);
 static void     expand_builtin(const char *[], int, int);  static void     expand_builtin(const char *[], int, int);
 static void     expand_macro(const char *[], int);  static void     expand_macro(const char *[], int);
 static void     dump_one_def(ndptr);  static void     dump_one_def(const char *, struct macro_definition *);
   
 unsigned long   expansion_id;  unsigned long   expansion_id;
   
Line 91 
Line 88 
  *        argc - number of elements in argv.   *        argc - number of elements in argv.
  *        argv - element vector :   *        argv - element vector :
  *                      argv[0] = definition of a user   *                      argv[0] = definition of a user
  *                                macro or nil if built-in.   *                                macro or NULL if built-in.
  *                      argv[1] = name of the macro or   *                      argv[1] = name of the macro or
  *                                built-in.   *                                built-in.
  *                      argv[2] = parameters to user-defined   *                      argv[2] = parameters to user-defined
Line 196 
Line 193 
          * another definition           * another definition
          */           */
                 if (argc > 3) {                  if (argc > 3) {
                         if (lookup(argv[2]) != nil)                          if (lookup_macro_definition(argv[2]) != NULL)
                                 pbstr(argv[3]);                                  pbstr(argv[3]);
                         else if (argc > 4)                          else if (argc > 4)
                                 pbstr(argv[4]);                                  pbstr(argv[4]);
Line 344 
Line 341 
          */           */
                 if (argc > 2)                  if (argc > 2)
                         for (n = 2; n < argc; n++)                          for (n = 2; n < argc; n++)
                                 remhash(argv[n], ALL);                                  macro_undefine(argv[n]);
                 break;                  break;
   
         case POPDTYPE:          case POPDTYPE:
Line 355 
Line 352 
          */           */
                 if (argc > 2)                  if (argc > 2)
                         for (n = 2; n < argc; n++)                          for (n = 2; n < argc; n++)
                                 remhash(argv[n], TOP);                                  macro_popdef(argv[n]);
                 break;                  break;
   
         case MKTMTYPE:          case MKTMTYPE:
Line 563 
Line 560 
   
   
 /*  /*
  * common part to dodefine and dopushdef  
  */  
 static void  
 setup_definition(ndptr p, const char *defn)  
 {  
         int n;  
   
         if (strncmp(defn, BUILTIN_MARKER, sizeof(BUILTIN_MARKER)-1) == 0) {  
                 n = builtin_type(defn+sizeof(BUILTIN_MARKER)-1);  
                 if (n != -1) {  
                         p->type = n & TYPEMASK;  
                         if ((n & NOARGS) == 0)  
                                 p->type |= NEEDARGS;  
                         p->defn = xstrdup(defn+sizeof(BUILTIN_MARKER)-1);  
                         return;  
                 }  
         }  
         if (!*defn)  
                 p->defn = null;  
         else  
                 p->defn = xstrdup(defn);  
         p->type = MACRTYPE;  
 }  
   
 /*  
  * dodefine - install definition in the table   * dodefine - install definition in the table
  */   */
 void  void
 dodefine(const char *name, const char *defn)  dodefine(const char *name, const char *defn)
 {  {
         ndptr p;  
   
         if (!*name)          if (!*name)
                 errx(1, "%s at line %lu: null definition.", CURRENT_NAME,                  errx(1, "%s at line %lu: null definition.", CURRENT_NAME,
                     CURRENT_LINE);                      CURRENT_LINE);
         if ((p = lookup(name)) == nil)          macro_define(name, defn);
                 p = addent(name);  
         else if (p->defn != null)  
                 free((char *) p->defn);  
         setup_definition(p, defn);  
         if (STREQ(name, defn))  
                 p->type |= RECDEF;  
 }  }
   
 /*  /*
Line 614 
Line 578 
 static void  static void
 dodefn(const char *name)  dodefn(const char *name)
 {  {
         ndptr p;          struct macro_definition *p;
         char *real;          char *real;
   
         if ((p = lookup(name)) != nil) {          if ((p = lookup_macro_definition(name)) != NULL) {
                 if ((p->type & TYPEMASK) == MACRTYPE) {                  if ((p->type & TYPEMASK) == MACRTYPE) {
                         pbstr(rquote);                          pbstr(rquote);
                         pbstr(p->defn);                          pbstr(p->defn);
Line 639 
Line 603 
 static void  static void
 dopushdef(const char *name, const char *defn)  dopushdef(const char *name, const char *defn)
 {  {
         ndptr p;  
   
         if (!*name)          if (!*name)
                 errx(1, "%s at line %lu: null definition", CURRENT_NAME,                  errx(1, "%s at line %lu: null definition", CURRENT_NAME,
                     CURRENT_LINE);                      CURRENT_LINE);
         p = addent(name);          macro_pushdef(name, defn);
         setup_definition(p, defn);  
         if (STREQ(name, defn))  
                 p->type |= RECDEF;  
 }  }
   
 /*  /*
  * dump_one_def - dump the specified definition.   * dump_one_def - dump the specified definition.
  */   */
 static void  static void
 dump_one_def(ndptr p)  dump_one_def(const char *name, struct macro_definition *p)
 {  {
         if (mimic_gnu) {          if (mimic_gnu) {
                 if ((p->type & TYPEMASK) == MACRTYPE)                  if ((p->type & TYPEMASK) == MACRTYPE)
                         fprintf(traceout, "%s:\t%s\n", p->name, p->defn);                          fprintf(traceout, "%s:\t%s\n", name, p->defn);
                 else {                  else {
                         fprintf(traceout, "%s:\t<%s>\n", p->name, p->defn);                          fprintf(traceout, "%s:\t<%s>\n", name, p->defn);
                 }                  }
         } else          } else
                 fprintf(traceout, "`%s'\t`%s'\n", p->name, p->defn);                  fprintf(traceout, "`%s'\t`%s'\n", name, p->defn);
 }  }
   
 /*  /*
Line 675 
Line 634 
 dodump(const char *argv[], int argc)  dodump(const char *argv[], int argc)
 {  {
         int n;          int n;
         ndptr p;          struct macro_definition *p;
   
         if (argc > 2) {          if (argc > 2) {
                 for (n = 2; n < argc; n++)                  for (n = 2; n < argc; n++)
                         if ((p = lookup(argv[n])) != nil)                          if ((p = lookup_macro_definition(argv[n])) != NULL)
                                 dump_one_def(p);                                  dump_one_def(argv[n], p);
         } else {          } else
                 for (n = 0; n < HASHSIZE; n++)                  macro_for_all(dump_one_def);
                         for (p = hashtab[n]; p != nil; p = p->nxtptr)  
                                 dump_one_def(p);  
         }  
 }  }
   
 /*  /*
Legend:
Removed from v.1.48  
changed lines
  Added in v.1.49