[BACK]Return to cond.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / usr.bin / make

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/usr.bin/make/cond.c between version 1.44 and 1.53

version 1.44, 2008/11/22 18:47:47 version 1.53, 2009/01/23 20:22:50
Line 92  __RCSID("$NetBSD$");
Line 92  __RCSID("$NetBSD$");
  */   */
   
 #include    <ctype.h>  #include    <ctype.h>
   #include    <errno.h>    /* For strtoul() error checking */
   
 #include    "make.h"  #include    "make.h"
 #include    "hash.h"  #include    "hash.h"
Line 146  static Boolean CondDoMake(int, char *);
Line 147  static Boolean CondDoMake(int, char *);
 static Boolean CondDoExists(int, char *);  static Boolean CondDoExists(int, char *);
 static Boolean CondDoTarget(int, char *);  static Boolean CondDoTarget(int, char *);
 static Boolean CondDoCommands(int, char *);  static Boolean CondDoCommands(int, char *);
 static char * CondCvtArg(char *, double *);  static Boolean CondCvtArg(char *, double *);
 static Token CondToken(Boolean);  static Token CondToken(Boolean);
 static Token CondT(Boolean);  static Token CondT(Boolean);
 static Token CondF(Boolean);  static Token CondF(Boolean);
Line 257  CondGetArg(char **linePtr, char **argPtr
Line 258  CondGetArg(char **linePtr, char **argPtr
      * Create a buffer for the argument and start it out at 16 characters       * Create a buffer for the argument and start it out at 16 characters
      * long. Why 16? Why not?       * long. Why 16? Why not?
      */       */
     buf = Buf_Init(16);      Buf_Init(&buf, 16);
   
     while ((strchr(" \t)&|", *cp) == NULL) && (*cp != '\0')) {      while ((strchr(" \t)&|", *cp) == NULL) && (*cp != '\0')) {
         if (*cp == '$') {          if (*cp == '$') {
Line 272  CondGetArg(char **linePtr, char **argPtr
Line 273  CondGetArg(char **linePtr, char **argPtr
             void        *freeIt;              void        *freeIt;
   
             cp2 = Var_Parse(cp, VAR_CMD, TRUE, &len, &freeIt);              cp2 = Var_Parse(cp, VAR_CMD, TRUE, &len, &freeIt);
             Buf_AddBytes(buf, strlen(cp2), (Byte *)cp2);              Buf_AddBytes(&buf, strlen(cp2), cp2);
             if (freeIt)              if (freeIt)
                 free(freeIt);                  free(freeIt);
             cp += len;              cp += len;
         } else {          } else {
             Buf_AddByte(buf, (Byte)*cp);              Buf_AddByte(&buf, *cp);
             cp++;              cp++;
         }          }
     }      }
   
     Buf_AddByte(buf, (Byte)'\0');      *argPtr = Buf_GetAll(&buf, &argLen);
     *argPtr = (char *)Buf_GetAll(buf, &argLen);      Buf_Destroy(&buf, FALSE);
     Buf_Destroy(buf, FALSE);  
   
     while (*cp == ' ' || *cp == '\t') {      while (*cp == ' ' || *cp == '\t') {
         cp++;          cp++;
Line 293  CondGetArg(char **linePtr, char **argPtr
Line 293  CondGetArg(char **linePtr, char **argPtr
         Parse_Error(PARSE_WARNING, "Missing closing parenthesis for %s()",          Parse_Error(PARSE_WARNING, "Missing closing parenthesis for %s()",
                      func);                       func);
         return (0);          return (0);
     } else if (parens) {      }
   
       if (parens) {
         /*          /*
          * Advance pointer past close parenthesis.           * Advance pointer past close parenthesis.
          */           */
Line 320  CondGetArg(char **linePtr, char **argPtr
Line 322  CondGetArg(char **linePtr, char **argPtr
 static Boolean  static Boolean
 CondDoDefined(int argLen, char *arg)  CondDoDefined(int argLen, char *arg)
 {  {
     char    savec = arg[argLen];  
     char    *p1;      char    *p1;
     Boolean result;      Boolean result;
   
     arg[argLen] = '\0';  
     if (Var_Value(arg, VAR_CMD, &p1) != NULL) {      if (Var_Value(arg, VAR_CMD, &p1) != NULL) {
         result = TRUE;          result = TRUE;
     } else {      } else {
Line 332  CondDoDefined(int argLen, char *arg)
Line 332  CondDoDefined(int argLen, char *arg)
     }      }
     if (p1)      if (p1)
         free(p1);          free(p1);
     arg[argLen] = savec;  
     return (result);      return (result);
 }  }
   
Line 372  CondStrMatch(ClientData string, ClientDa
Line 371  CondStrMatch(ClientData string, ClientDa
 static Boolean  static Boolean
 CondDoMake(int argLen, char *arg)  CondDoMake(int argLen, char *arg)
 {  {
     char    savec = arg[argLen];      return Lst_Find(create, arg, CondStrMatch) != NULL;
     Boolean result;  
   
     arg[argLen] = '\0';  
     if (Lst_Find(create, arg, CondStrMatch) == NILLNODE) {  
         result = FALSE;  
     } else {  
         result = TRUE;  
     }  
     arg[argLen] = savec;  
     return (result);  
 }  }
   
 /*-  /*-
Line 401  CondDoMake(int argLen, char *arg)
Line 390  CondDoMake(int argLen, char *arg)
 static Boolean  static Boolean
 CondDoExists(int argLen, char *arg)  CondDoExists(int argLen, char *arg)
 {  {
     char    savec = arg[argLen];  
     Boolean result;      Boolean result;
     char    *path;      char    *path;
   
     arg[argLen] = '\0';  
     path = Dir_FindFile(arg, dirSearchPath);      path = Dir_FindFile(arg, dirSearchPath);
     if (path != NULL) {      if (path != NULL) {
         result = TRUE;          result = TRUE;
Line 413  CondDoExists(int argLen, char *arg)
Line 400  CondDoExists(int argLen, char *arg)
     } else {      } else {
         result = FALSE;          result = FALSE;
     }      }
     arg[argLen] = savec;  
     if (DEBUG(COND)) {      if (DEBUG(COND)) {
         fprintf(debug_file, "exists(%s) result is \"%s\"\n",          fprintf(debug_file, "exists(%s) result is \"%s\"\n",
                arg, path ? path : "");                 arg, path ? path : "");
Line 437  CondDoExists(int argLen, char *arg)
Line 423  CondDoExists(int argLen, char *arg)
 static Boolean  static Boolean
 CondDoTarget(int argLen, char *arg)  CondDoTarget(int argLen, char *arg)
 {  {
     char    savec = arg[argLen];  
     Boolean result;  
     GNode   *gn;      GNode   *gn;
   
     arg[argLen] = '\0';  
     gn = Targ_FindNode(arg, TARG_NOCREATE);      gn = Targ_FindNode(arg, TARG_NOCREATE);
     if ((gn != NILGNODE) && !OP_NOP(gn->type)) {      return (gn != NULL) && !OP_NOP(gn->type);
         result = TRUE;  
     } else {  
         result = FALSE;  
     }  
     arg[argLen] = savec;  
     return (result);  
 }  }
   
 /*-  /*-
Line 470  CondDoTarget(int argLen, char *arg)
Line 447  CondDoTarget(int argLen, char *arg)
 static Boolean  static Boolean
 CondDoCommands(int argLen, char *arg)  CondDoCommands(int argLen, char *arg)
 {  {
     char    savec = arg[argLen];  
     Boolean result;  
     GNode   *gn;      GNode   *gn;
   
     arg[argLen] = '\0';  
     gn = Targ_FindNode(arg, TARG_NOCREATE);      gn = Targ_FindNode(arg, TARG_NOCREATE);
     if ((gn != NILGNODE) && !OP_NOP(gn->type) && !Lst_IsEmpty(gn->commands)) {      return (gn != NULL) && !OP_NOP(gn->type) && !Lst_IsEmpty(gn->commands);
         result = TRUE;  
     } else {  
         result = FALSE;  
     }  
     arg[argLen] = savec;  
     return (result);  
 }  }
   
 /*-  /*-
  *-----------------------------------------------------------------------   *-----------------------------------------------------------------------
  * CondCvtArg --   * CondCvtArg --
  *      Convert the given number into a double. If the number begins   *      Convert the given number into a double.
  *      with 0x, it is interpreted as a hexadecimal integer   *      We try a base 10 or 16 integer conversion first, if that fails
  *      and converted to a double from there. All other strings just have   *      then we try a floating point conversion instead.
  *      strtod called on them.  
  *   *
  * Results:   * Results:
  *      Sets 'value' to double value of string.   *      Sets 'value' to double value of string.
  *      Returns NULL if string was fully consumed,   *      Returns 'true' if the convertion suceeded
  *      else returns remaining input.  
  *  
  * Side Effects:  
  *      Can change 'value' even if string is not a valid number.  
  *  
  *   *
  *-----------------------------------------------------------------------   *-----------------------------------------------------------------------
  */   */
 static char *  static Boolean
 CondCvtArg(char *str, double *value)  CondCvtArg(char *str, double *value)
 {  {
     if ((*str == '0') && (str[1] == 'x')) {      char *eptr, ech;
         long i;      unsigned long l_val;
       double d_val;
         for (str += 2, i = 0; *str; str++) {  
             int x;      errno = 0;
             if (isdigit((unsigned char) *str))      l_val = strtoul(str, &eptr, str[1] == 'x' ? 16 : 10);
                 x  = *str - '0';      ech = *eptr;
             else if (isxdigit((unsigned char) *str))      if (ech == 0 && errno != ERANGE) {
                 x = 10 + *str - isupper((unsigned char) *str) ? 'A' : 'a';          d_val = str[0] == '-' ? -(double)-l_val : (double)l_val;
             else  
                 break;  
             i = (i << 4) + x;  
         }  
         *value = (double) i;  
         return *str ? str : NULL;  
     } else {      } else {
         char *eptr;          if (ech != 0 && ech != '.' && ech != 'e' && ech != 'E')
         *value = strtod(str, &eptr);              return FALSE;
         return *eptr ? eptr : NULL;          d_val = strtod(str, &eptr);
           if (*eptr)
               return FALSE;
     }      }
   
       *value = d_val;
       return TRUE;
 }  }
   
 /*-  /*-
  *-----------------------------------------------------------------------   *-----------------------------------------------------------------------
  * CondGetString --   * CondGetString --
Line 558  CondGetString(Boolean doEval, Boolean *q
Line 519  CondGetString(Boolean doEval, Boolean *q
     int qt;      int qt;
     char *start;      char *start;
   
     buf = Buf_Init(0);      Buf_Init(&buf, 0);
     str = NULL;      str = NULL;
     *freeIt = NULL;      *freeIt = NULL;
     *quoted = qt = *condExpr == '"' ? 1 : 0;      *quoted = qt = *condExpr == '"' ? 1 : 0;
Line 569  CondGetString(Boolean doEval, Boolean *q
Line 530  CondGetString(Boolean doEval, Boolean *q
         case '\\':          case '\\':
             if (condExpr[1] != '\0') {              if (condExpr[1] != '\0') {
                 condExpr++;                  condExpr++;
                 Buf_AddByte(buf, (Byte)*condExpr);                  Buf_AddByte(&buf, *condExpr);
             }              }
             break;              break;
         case '"':          case '"':
Line 577  CondGetString(Boolean doEval, Boolean *q
Line 538  CondGetString(Boolean doEval, Boolean *q
                 condExpr++;             /* we don't want the quotes */                  condExpr++;             /* we don't want the quotes */
                 goto got_str;                  goto got_str;
             } else              } else
                 Buf_AddByte(buf, (Byte)*condExpr); /* likely? */                  Buf_AddByte(&buf, *condExpr); /* likely? */
             break;              break;
         case ')':          case ')':
         case '!':          case '!':
Line 589  CondGetString(Boolean doEval, Boolean *q
Line 550  CondGetString(Boolean doEval, Boolean *q
             if (!qt)              if (!qt)
                 goto got_str;                  goto got_str;
             else              else
                 Buf_AddByte(buf, (Byte)*condExpr);                  Buf_AddByte(&buf, *condExpr);
             break;              break;
         case '$':          case '$':
             /* if we are in quotes, then an undefined variable is ok */              /* if we are in quotes, then an undefined variable is ok */
Line 623  CondGetString(Boolean doEval, Boolean *q
Line 584  CondGetString(Boolean doEval, Boolean *q
              * Nope, we better copy str to buf               * Nope, we better copy str to buf
              */               */
             for (cp = str; *cp; cp++) {              for (cp = str; *cp; cp++) {
                 Buf_AddByte(buf, (Byte)*cp);                  Buf_AddByte(&buf, *cp);
             }              }
             if (*freeIt) {              if (*freeIt) {
                 free(*freeIt);                  free(*freeIt);
Line 633  CondGetString(Boolean doEval, Boolean *q
Line 594  CondGetString(Boolean doEval, Boolean *q
             condExpr--;                 /* don't skip over next char */              condExpr--;                 /* don't skip over next char */
             break;              break;
         default:          default:
             Buf_AddByte(buf, (Byte)*condExpr);              Buf_AddByte(&buf, *condExpr);
             break;              break;
         }          }
     }      }
  got_str:   got_str:
     Buf_AddByte(buf, (Byte)'\0');      str = Buf_GetAll(&buf, NULL);
     str = (char *)Buf_GetAll(buf, NULL);  
     *freeIt = str;      *freeIt = str;
  cleanup:   cleanup:
     Buf_Destroy(buf, FALSE);      Buf_Destroy(&buf, FALSE);
     return str;      return str;
 }  }
   
Line 762  do_string_compare:
Line 722  do_string_compare:
          * lhs and the rhs to a double and compare the two.           * lhs and the rhs to a double and compare the two.
          */           */
         double          left, right;          double          left, right;
         char    *cp;  
   
         if (CondCvtArg(lhs, &left))          if (!CondCvtArg(lhs, &left) || !CondCvtArg(rhs, &right))
             goto do_string_compare;  
         if ((cp = CondCvtArg(rhs, &right)) &&  
                 cp == rhs)  
             goto do_string_compare;              goto do_string_compare;
   
         if (DEBUG(COND)) {          if (DEBUG(COND)) {
Line 815  error:
Line 771  error:
     return t;      return t;
 }  }
   
   static int
   get_mpt_arg(char **linePtr, char **argPtr, const char *func, Boolean parens)
   {
       /*
        * Use Var_Parse to parse the spec in parens and return
        * True if the resulting string is empty.
        */
       int     length;
       void    *freeIt;
       char    *val;
       char    *cp = *linePtr;
   
       /* We do all the work here and return the result as the length */
       *argPtr = NULL;
   
       val = Var_Parse(cp - 1, VAR_CMD, FALSE, &length, &freeIt);
       /*
        * Advance *linePtr to beyond the closing ). Note that
        * we subtract one because 'length' is calculated from 'cp - 1'.
        */
       *linePtr = cp - 1 + length;
   
       if (val == var_Error) {
           free(freeIt);
           return -1;
       }
   
       /* A variable is empty when it just contains spaces... 4/15/92, christos */
       while (isspace(*(unsigned char *)val))
           val++;
   
       /*
        * For consistency with the other functions we can't generate the
        * true/false here.
        */
       length = *val ? 2 : 1;
       if (freeIt)
           free(freeIt);
       return length;
   }
   
   static Boolean
   CondDoEmpty(int arglen, char *arg)
   {
       return arglen == 1;
   }
   
 static Token  static Token
 compare_function(Boolean doEval)  compare_function(Boolean doEval)
 {  {
       static const struct fn_def {
           const char  *fn_name;
           int         fn_name_len;
           int         (*fn_getarg)(char **, char **, const char *, Boolean);
           Boolean     (*fn_proc)(int, char *);
       } fn_defs[] = {
           { "defined",   7, CondGetArg, CondDoDefined },
           { "make",      4, CondGetArg, CondDoMake },
           { "exists",    6, CondGetArg, CondDoExists },
           { "empty",     5, get_mpt_arg, CondDoEmpty },
           { "target",    6, CondGetArg, CondDoTarget },
           { "commands",  8, CondGetArg, CondDoCommands },
           { NULL,        0, NULL, NULL },
       };
       const struct fn_def *fn_def;
     Token       t;      Token       t;
     Boolean (*evalProc)(int, char *);  
     Boolean invert = FALSE;  
     char        *arg = NULL;      char        *arg = NULL;
     int arglen = 0;      int arglen;
       char *cp = condExpr;
     if (istoken(condExpr, "defined", 7)) {      char *cp1;
         /*  
          * Use CondDoDefined to evaluate the argument and      for (fn_def = fn_defs; fn_def->fn_name != NULL; fn_def++) {
          * CondGetArg to extract the argument from the 'function          if (!istoken(cp, fn_def->fn_name, fn_def->fn_name_len))
          * call'.              continue;
          */          cp += fn_def->fn_name_len;
         evalProc = CondDoDefined;          /* There can only be whitespace before the '(' */
         condExpr += 7;          while (isspace(*(unsigned char *)cp))
         arglen = CondGetArg(&condExpr, &arg, "defined", TRUE);              cp++;
         if (arglen == 0) {          if (*cp != '(')
             condExpr -= 7;              break;
             goto use_default;  
         }  
     } else if (istoken(condExpr, "make", 4)) {  
         /*  
          * Use CondDoMake to evaluate the argument and  
          * CondGetArg to extract the argument from the 'function  
          * call'.  
          */  
         evalProc = CondDoMake;  
         condExpr += 4;  
         arglen = CondGetArg(&condExpr, &arg, "make", TRUE);  
         if (arglen == 0) {  
             condExpr -= 4;  
             goto use_default;  
         }  
     } else if (istoken(condExpr, "exists", 6)) {  
         /*  
          * Use CondDoExists to evaluate the argument and  
          * CondGetArg to extract the argument from the  
          * 'function call'.  
          */  
         evalProc = CondDoExists;  
         condExpr += 6;  
         arglen = CondGetArg(&condExpr, &arg, "exists", TRUE);  
         if (arglen == 0) {  
             condExpr -= 6;  
             goto use_default;  
         }  
     } else if (istoken(condExpr, "empty", 5)) {  
         /*  
          * Use Var_Parse to parse the spec in parens and return  
          * True if the resulting string is empty.  
          */  
         int         did_warn, length;  
         void    *freeIt;  
         char    *val;  
   
         condExpr += 5;  
   
         did_warn = 0;  
         for (arglen = 0; condExpr[arglen] != '\0'; arglen += 1) {  
             if (condExpr[arglen] == '(')  
                 break;  
             if (!isspace((unsigned char)condExpr[arglen]) &&  
                 !did_warn) {  
   
                 Parse_Error(PARSE_WARNING,  
                     "Extra characters after \"empty\"");  
                 did_warn = 1;  
             }  
         }  
   
         if (condExpr[arglen] != '\0') {          arglen = fn_def->fn_getarg(&cp, &arg, fn_def->fn_name, TRUE);
             val = Var_Parse(&condExpr[arglen - 1], VAR_CMD,          if (arglen <= 0) {
                             FALSE, &length, &freeIt);              condExpr = cp;
             if (val == var_Error) {              return arglen < 0 ? Err : False;
                 t = Err;          }
             } else {          /* Evaluate the argument using the required function. */
                 /*          t = !doEval || fn_def->fn_proc(arglen, arg) ? True : False;
                  * A variable is empty when it just contains          if (arg)
                  * spaces... 4/15/92, christos              free(arg);
                  */          condExpr = cp;
                 char *p;  
                 for (p = val; *p && isspace((unsigned char)*p); p++)  
                     continue;  
                 t = (*p == '\0') ? True : False;  
             }  
             if (freeIt) {  
                 free(freeIt);  
             }  
             /*  
              * Advance condExpr to beyond the closing ). Note that  
              * we subtract one from arglen + length b/c length  
              * is calculated from condExpr[arglen - 1].  
              */  
             condExpr += arglen + length - 1;  
         } else {  
             condExpr -= 5;  
             goto use_default;  
         }  
         return t;          return t;
     } else if (istoken(condExpr, "target", 6)) {  
         /*  
          * Use CondDoTarget to evaluate the argument and  
          * CondGetArg to extract the argument from the  
          * 'function call'.  
          */  
         evalProc = CondDoTarget;  
         condExpr += 6;  
         arglen = CondGetArg(&condExpr, &arg, "target", TRUE);  
         if (arglen == 0) {  
             condExpr -= 6;  
             goto use_default;  
         }  
     } else if (istoken(condExpr, "commands", 8)) {  
         /*  
          * Use CondDoCommands to evaluate the argument and  
          * CondGetArg to extract the argument from the  
          * 'function call'.  
          */  
         evalProc = CondDoCommands;  
         condExpr += 8;  
         arglen = CondGetArg(&condExpr, &arg, "commands", TRUE);  
         if (arglen == 0) {  
             condExpr -= 8;  
             goto use_default;  
         }  
     } else {  
         /*  
          * The symbol is itself the argument to the default  
          * function. We advance condExpr to the end of the symbol  
          * by hand (the next whitespace, closing paren or  
          * binary operator) and set to invert the evaluation  
          * function if condInvert is TRUE.  
          */  
         if (isdigit((unsigned char)condExpr[0])) {  
             /*  
              * Variables may already be substituted  
              * by the time we get here.  
              */  
             return compare_expression(doEval);  
         }  
     use_default:  
         invert = condInvert;  
         evalProc = condDefProc;  
         arglen = CondGetArg(&condExpr, &arg, "", FALSE);  
     }      }
   
       /* Push anything numeric through the compare expression */
       cp = condExpr;
       if (isdigit((unsigned char)cp[0]) || strchr("+-", cp[0]))
           return compare_expression(doEval);
   
       /*
        * Most likely we have a naked token to apply the default function to.
        * However ".if a == b" gets here when the "a" is unquoted and doesn't
        * start with a '$'. This surprises people - especially given the way
        * that for loops get expanded.
        * If what follows the function argument is a '=' or '!' then the syntax
        * would be invalid if we did "defined(a)" - so instead treat as an
        * expression.
        */
       arglen = CondGetArg(&cp, &arg, "", FALSE);
       for (cp1 = cp; isspace(*(unsigned char *)cp1); cp1++)
           continue;
       if (*cp1 == '=' || *cp1 == '!')
           return compare_expression(doEval);
       condExpr = cp;
   
     /*      /*
      * Evaluate the argument using the set function. If invert       * Evaluate the argument using the default function. If invert
      * is TRUE, we invert the sense of the function.       * is TRUE, we invert the sense of the result.
      */       */
     t = (!doEval || (* evalProc) (arglen, arg) ?      t = !doEval || (* condDefProc)(arglen, arg) != condInvert ? True : False;
          (invert ? False : True) :  
          (invert ? True : False));  
     if (arg)      if (arg)
         free(arg);          free(arg);
     return t;      return t;
Line 978  compare_function(Boolean doEval)
Line 899  compare_function(Boolean doEval)
 static Token  static Token
 CondToken(Boolean doEval)  CondToken(Boolean doEval)
 {  {
     Token         t;      Token t;
   
       t = condPushBack;
       if (t != None) {
           condPushBack = None;
           return t;
       }
   
       while (*condExpr == ' ' || *condExpr == '\t') {
           condExpr++;
       }
   
       switch (*condExpr) {
   
       case '(':
           condExpr++;
           return LParen;
   
       case ')':
           condExpr++;
           return RParen;
   
     if (condPushBack == None) {      case '|':
         while (*condExpr == ' ' || *condExpr == '\t') {          if (condExpr[1] == '|') {
             condExpr++;              condExpr++;
         }          }
         switch (*condExpr) {          condExpr++;
             case '(':          return Or;
                 t = LParen;  
                 condExpr++;  
                 break;  
             case ')':  
                 t = RParen;  
                 condExpr++;  
                 break;  
             case '|':  
                 if (condExpr[1] == '|') {  
                     condExpr++;  
                 }  
                 condExpr++;  
                 t = Or;  
                 break;  
             case '&':  
                 if (condExpr[1] == '&') {  
                     condExpr++;  
                 }  
                 condExpr++;  
                 t = And;  
                 break;  
             case '!':  
                 t = Not;  
                 condExpr++;  
                 break;  
             case '#':  
             case '\n':  
             case '\0':  
                 t = EndOfFile;  
                 break;  
             case '"':  
             case '$':  
                 return compare_expression(doEval);  
   
             default:  
                 return compare_function(doEval);  
   
       case '&':
           if (condExpr[1] == '&') {
               condExpr++;
         }          }
     } else {          condExpr++;
         t = condPushBack;          return And;
         condPushBack = None;  
       case '!':
           condExpr++;
           return Not;
   
       case '#':
       case '\n':
       case '\0':
           return EndOfFile;
   
       case '"':
       case '$':
           return compare_expression(doEval);
   
       default:
           return compare_function(doEval);
     }      }
     return (t);  
 }  }
   
 /*-  /*-
  *-----------------------------------------------------------------------   *-----------------------------------------------------------------------
  * CondT --   * CondT --
Line 1211  Cond_EvalExpression(int dosetup, char *l
Line 1133  Cond_EvalExpression(int dosetup, char *l
     case True:      case True:
         if (CondToken(TRUE) == EndOfFile) {          if (CondToken(TRUE) == EndOfFile) {
             *value = TRUE;              *value = TRUE;
             break;              return COND_PARSE;
         }          }
         goto err;          break;
         /*FALLTHRU*/  
     case False:      case False:
         if (CondToken(TRUE) == EndOfFile) {          if (CondToken(TRUE) == EndOfFile) {
             *value = FALSE;              *value = FALSE;
             break;              return COND_PARSE;
         }          }
         /*FALLTHRU*/          break;
     case Err:      case Err:
 err:  
         if (eprint)  
             Parse_Error(PARSE_FATAL, "Malformed conditional (%s)",  
                          line);  
         return (COND_INVALID);  
     default:  
         break;          break;
       default:
           return COND_PARSE;
     }      }
   
     return COND_PARSE;      if (eprint)
           Parse_Error(PARSE_FATAL, "Malformed conditional (%s)", line);
       return COND_INVALID;
 }  }
   
   

Legend:
Removed from v.1.44  
changed lines
  Added in v.1.53

CVSweb <webmaster@jp.NetBSD.org>