[BACK]Return to var.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/var.c between version 1.312 and 1.313

version 1.312, 2020/07/26 13:39:30 version 1.313, 2020/07/26 15:09:10
Line 279  typedef enum {
Line 279  typedef enum {
 static Var *  static Var *
 VarFind(const char *name, GNode *ctxt, VarFindFlags flags)  VarFind(const char *name, GNode *ctxt, VarFindFlags flags)
 {  {
     Hash_Entry          *var;  
     Var                 *v;  
   
     /*      /*
      * If the variable name begins with a '.', it could very well be one of       * If the variable name begins with a '.', it could very well be one of
      * the local ones.  We check the name against all the local variables       * the local ones.  We check the name against all the local variables
Line 330  VarFind(const char *name, GNode *ctxt, V
Line 327  VarFind(const char *name, GNode *ctxt, V
      * look for it in VAR_CMD, VAR_GLOBAL and the environment, in that order,       * look for it in VAR_CMD, VAR_GLOBAL and the environment, in that order,
      * depending on the FIND_* flags in 'flags'       * depending on the FIND_* flags in 'flags'
      */       */
     var = Hash_FindEntry(&ctxt->context, name);      Hash_Entry *var = Hash_FindEntry(&ctxt->context, name);
   
     if (var == NULL && (flags & FIND_CMD) && ctxt != VAR_CMD) {      if (var == NULL && (flags & FIND_CMD) && ctxt != VAR_CMD) {
         var = Hash_FindEntry(&VAR_CMD->context, name);          var = Hash_FindEntry(&VAR_CMD->context, name);
Line 348  VarFind(const char *name, GNode *ctxt, V
Line 345  VarFind(const char *name, GNode *ctxt, V
         char *env;          char *env;
   
         if ((env = getenv(name)) != NULL) {          if ((env = getenv(name)) != NULL) {
             int len;              Var *v = bmake_malloc(sizeof(Var));
   
             v = bmake_malloc(sizeof(Var));  
             v->name = bmake_strdup(name);              v->name = bmake_strdup(name);
   
             len = strlen(env);              int len = (int)strlen(env);
   
             Buf_Init(&v->val, len + 1);              Buf_Init(&v->val, len + 1);
             Buf_AddBytes(&v->val, len, env);              Buf_AddBytes(&v->val, len, env);
   
Line 428  VarFreeEnv(Var *v, Boolean destroy)
Line 422  VarFreeEnv(Var *v, Boolean destroy)
 static void  static void
 VarAdd(const char *name, const char *val, GNode *ctxt)  VarAdd(const char *name, const char *val, GNode *ctxt)
 {  {
     Var           *v;      Var *v = bmake_malloc(sizeof(Var));
     int           len;  
     Hash_Entry    *h;  
   
     v = bmake_malloc(sizeof(Var));  
   
     len = val != NULL ? strlen(val) : 0;      int len = val != NULL ? (int)strlen(val) : 0;
     Buf_Init(&v->val, len + 1);      Buf_Init(&v->val, len + 1);
     Buf_AddBytes(&v->val, len, val);      Buf_AddBytes(&v->val, len, val);
   
     v->flags = 0;      v->flags = 0;
   
     h = Hash_CreateEntry(&ctxt->context, name, NULL);      Hash_Entry *h = Hash_CreateEntry(&ctxt->context, name, NULL);
     Hash_SetValue(h, v);      Hash_SetValue(h, v);
     v->name = h->name;      v->name = h->name;
     if (DEBUG(VAR) && !(ctxt->flags & INTERNAL)) {      if (DEBUG(VAR) && !(ctxt->flags & INTERNAL)) {
Line 838  Var_Set_with_flags(const char *name, con
Line 828  Var_Set_with_flags(const char *name, con
     } else {      } else {
         Buf_Empty(&v->val);          Buf_Empty(&v->val);
         if (val)          if (val)
             Buf_AddBytes(&v->val, strlen(val), val);              Buf_AddStr(&v->val, val);
   
         if (DEBUG(VAR)) {          if (DEBUG(VAR)) {
             fprintf(debug_file, "%s:%s = %s\n", ctxt->name, name, val);              fprintf(debug_file, "%s:%s = %s\n", ctxt->name, name, val);
Line 960  Var_Append(const char *name, const char 
Line 950  Var_Append(const char *name, const char 
         Var_Set(name, val, ctxt);          Var_Set(name, val, ctxt);
     } else if (ctxt == VAR_CMD || !(v->flags & VAR_FROM_CMD)) {      } else if (ctxt == VAR_CMD || !(v->flags & VAR_FROM_CMD)) {
         Buf_AddByte(&v->val, ' ');          Buf_AddByte(&v->val, ' ');
         Buf_AddBytes(&v->val, strlen(val), val);          Buf_AddStr(&v->val, val);
   
         if (DEBUG(VAR)) {          if (DEBUG(VAR)) {
             fprintf(debug_file, "%s:%s = %s\n", ctxt->name, name,              fprintf(debug_file, "%s:%s = %s\n", ctxt->name, name,
Line 1700  VarOrder(const char *str, const char oty
Line 1690  VarOrder(const char *str, const char oty
     }      }
   
     for (i = 0; i < ac; i++) {      for (i = 0; i < ac; i++) {
         Buf_AddBytes(&buf, strlen(av[i]), av[i]);          Buf_AddStr(&buf, av[i]);
         if (i != ac - 1)          if (i != ac - 1)
             Buf_AddByte(&buf, ' ');              Buf_AddByte(&buf, ' ');
     }      }
Line 1747  VarUniq(const char *str)
Line 1737  VarUniq(const char *str)
     }      }
   
     for (i = 0; i < ac; i++) {      for (i = 0; i < ac; i++) {
         Buf_AddBytes(&buf, strlen(av[i]), av[i]);          Buf_AddStr(&buf, av[i]);
         if (i != ac - 1)          if (i != ac - 1)
             Buf_AddByte(&buf, ' ');              Buf_AddByte(&buf, ' ');
     }      }
Line 1862  ParseModifierPart(GNode *ctxt, const cha
Line 1852  ParseModifierPart(GNode *ctxt, const cha
                      */                       */
                     cp2 = Var_Parse(cp, ctxt, errnum | (eflags & VARE_WANTRES),                      cp2 = Var_Parse(cp, ctxt, errnum | (eflags & VARE_WANTRES),
                                     &len, &freeIt);                                      &len, &freeIt);
                     Buf_AddBytes(&buf, strlen(cp2), cp2);                      Buf_AddStr(&buf, cp2);
                     free(freeIt);                      free(freeIt);
                     cp += len - 1;                      cp += len - 1;
                 } else {                  } else {
Line 1886  ParseModifierPart(GNode *ctxt, const cha
Line 1876  ParseModifierPart(GNode *ctxt, const cha
                                     --depth;                                      --depth;
                             }                              }
                         }                          }
                         Buf_AddBytes(&buf, cp2 - cp, cp);                          Buf_AddBytesBetween(&buf, cp, cp2);
                         cp = --cp2;                          cp = --cp2;
                     } else                      } else
                         Buf_AddByte(&buf, *cp);                          Buf_AddByte(&buf, *cp);
Line 1937  VarQuote(char *str, Boolean quoteDollar)
Line 1927  VarQuote(char *str, Boolean quoteDollar)
             const char *newline = Shell_GetNewline();              const char *newline = Shell_GetNewline();
             if (newline == NULL)              if (newline == NULL)
                 newline = "\\\n";                  newline = "\\\n";
             Buf_AddBytes(&buf, strlen(newline), newline);              Buf_AddStr(&buf, newline);
             continue;              continue;
         }          }
         if (isspace((unsigned char)*str) || ismeta((unsigned char)*str))          if (isspace((unsigned char)*str) || ismeta((unsigned char)*str))
             Buf_AddByte(&buf, '\\');              Buf_AddByte(&buf, '\\');
         Buf_AddByte(&buf, *str);          Buf_AddByte(&buf, *str);
         if (quoteDollar && *str == '$')          if (quoteDollar && *str == '$')
             Buf_AddBytes(&buf, 2, "\\$");              Buf_AddStr(&buf, "\\$");
     }      }
   
     str = Buf_Destroy(&buf, FALSE);      str = Buf_Destroy(&buf, FALSE);
Line 2165  ApplyModifier_Defined(const char *mod, A
Line 2155  ApplyModifier_Defined(const char *mod, A
             void    *freeIt;              void    *freeIt;
   
             cp2 = Var_Parse(st->cp, st->ctxt, neflags, &len, &freeIt);              cp2 = Var_Parse(st->cp, st->ctxt, neflags, &len, &freeIt);
             Buf_AddBytes(&buf, strlen(cp2), cp2);              Buf_AddStr(&buf, cp2);
             free(freeIt);              free(freeIt);
             st->cp += len - 1;              st->cp += len - 1;
         } else {          } else {
Line 3497  Var_Parse(const char *str, GNode *ctxt, 
Line 3487  Var_Parse(const char *str, GNode *ctxt, 
                 void *freeIt;                  void *freeIt;
                 char *rval = Var_Parse(tstr, ctxt, flags, &rlen, &freeIt);                  char *rval = Var_Parse(tstr, ctxt, flags, &rlen, &freeIt);
                 if (rval != NULL)                  if (rval != NULL)
                     Buf_AddBytes(&buf, strlen(rval), rval);                      Buf_AddStr(&buf, rval);
                 free(freeIt);                  free(freeIt);
                 tstr += rlen - 1;                  tstr += rlen - 1;
             } else              } else
Line 3767  Var_Subst(const char *var, const char *s
Line 3757  Var_Subst(const char *var, const char *s
   
             for (cp = str++; *str != '$' && *str != '\0'; str++)              for (cp = str++; *str != '$' && *str != '\0'; str++)
                 continue;                  continue;
             Buf_AddBytes(&buf, str - cp, cp);              Buf_AddBytesBetween(&buf, cp, str);
         } else {          } else {
             if (var != NULL) {              if (var != NULL) {
                 int expand;                  int expand;
Line 3799  Var_Subst(const char *var, const char *s
Line 3789  Var_Subst(const char *var, const char *s
                          * the nested one                           * the nested one
                          */                           */
                         if (*p == '$') {                          if (*p == '$') {
                             Buf_AddBytes(&buf, p - str, str);                              Buf_AddBytesBetween(&buf, str, p);
                             str = p;                              str = p;
                             continue;                              continue;
                         }                          }
Line 3812  Var_Subst(const char *var, const char *s
Line 3802  Var_Subst(const char *var, const char *s
                              */                               */
                             for (; *p != '$' && *p != '\0'; p++)                              for (; *p != '$' && *p != '\0'; p++)
                                 continue;                                  continue;
                             Buf_AddBytes(&buf, p - str, str);                              Buf_AddBytesBetween(&buf, str, p);
                             str = p;                              str = p;
                             expand = FALSE;                              expand = FALSE;
                         } else                          } else
Legend:
Removed from v.1.312  
changed lines
  Added in v.1.313
CVSweb <webmaster@jp.NetBSD.org>