 @@ -1,14 +1,14 @@
-/*	$NetBSD: var.c,v 1.622 2020/10/31 14:12:01 rillig Exp $	*/
+/*	$NetBSD: var.c,v 1.623 2020/10/31 14:40:34 rillig Exp $	*/
 /*
  * Copyright (c) 1988, 1989, 1990, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Adam de Boor.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -119,27 +119,27 @@
 #include    <sys/types.h>
 #include    <regex.h>
 #endif
 #include    <inttypes.h>
 #include    <limits.h>
 #include    <time.h>
 #include    "make.h"
 #include    "dir.h"
 #include    "job.h"
 #include    "metachar.h"
 /*	"@(#)var.c	8.3 (Berkeley) 3/19/94" */
-MAKE_RCSID("$NetBSD: var.c,v 1.622 2020/10/31 14:12:01 rillig Exp $");
+MAKE_RCSID("$NetBSD: var.c,v 1.623 2020/10/31 14:40:34 rillig Exp $");
 #define VAR_DEBUG1(fmt, arg1) DEBUG1(VAR, fmt, arg1)
 #define VAR_DEBUG2(fmt, arg1, arg2) DEBUG2(VAR, fmt, arg1, arg2)
 #define VAR_DEBUG3(fmt, arg1, arg2, arg3) DEBUG3(VAR, fmt, arg1, arg2, arg3)
 #define VAR_DEBUG4(fmt, arg1, arg2, arg3, arg4) DEBUG4(VAR, fmt, arg1, arg2, arg3, arg4)
 ENUM_FLAGS_RTTI_3(VarEvalFlags,
 		  VARE_UNDEFERR, VARE_WANTRES, VARE_ASSIGN);
 /*
  * This lets us tell if we have replaced the original environ
  * (which we cannot free).
  */
 @@ -3497,26 +3497,165 @@ ParseVarnameShort(char const startc, con
 	if (DEBUG(LINT) && *out_FALSE_val == var_Error) {
 	    Parse_Error(PARSE_FATAL, "Variable \"%s\" is undefined", name);
 	    *out_FALSE_res = VPR_UNDEF_MSG;
 	    return FALSE;
+	}
 	*out_FALSE_res = eflags & VARE_UNDEFERR ? VPR_UNDEF_SILENT : VPR_OK;
 	return FALSE;
+    }
     *out_TRUE_var = v;
     return TRUE;
+}
 /* Parse a long variable name enclosed in braces or parentheses such as $(VAR)
  * or ${VAR}, up to the closing brace or parenthesis, or in the case of
  * ${VAR:Modifiers}, up to the ':' that starts the modifiers.
  * Return whether to continue parsing. */
 static Boolean
 ParseVarnameLong(
 	const char **const pp,
 	char const startc,
 	GNode *const ctxt,
 	VarEvalFlags const eflags,
 	VarParseResult *const out_FALSE_res,
 	const char **const out_FALSE_val,
 	void **const out_FALSE_freePtr,
 	char *const out_TRUE_endc,
 	const char **const out_TRUE_p,
 	Var **const out_TRUE_v,
 	Boolean *const out_TRUE_haveModifier,
 	const char **const out_TRUE_extraModifiers,
 	Boolean *const out_TRUE_dynamic,
 	VarExprFlags *const out_TRUE_exprFlags
 ) {
     size_t namelen;
     char *varname;
     Var *v;
     Boolean haveModifier;
     Boolean dynamic = FALSE;
     const char *const start = *pp;
     char endc = startc == '(' ? ')' : '}';
     const char *p = start + 2;
     varname = ParseVarname(&p, startc, endc, ctxt, eflags, &namelen);
     if (*p == ':') {
 	haveModifier = TRUE;
     } else if (*p == endc) {
 	haveModifier = FALSE;
     } else {
 	Parse_Error(PARSE_FATAL, "Unclosed variable \"%s\"", varname);
 	*pp = p;
 	free(varname);
 	*out_FALSE_val = var_Error;
 	*out_FALSE_res = VPR_PARSE_MSG;
 	return FALSE;
+    }
     v = VarFind(varname, ctxt, TRUE);
     /* At this point, p points just after the variable name,
      * either at ':' or at endc. */
     /*
      * Check also for bogus D and F forms of local variables since we're
      * in a local context and the name is the right length.
      */
     if (v == NULL && ctxt != VAR_CMDLINE && ctxt != VAR_GLOBAL &&
 	namelen == 2 && (varname[1] == 'F' || varname[1] == 'D') &&
 	strchr("@%?*!<>", varname[0]) != NULL)
+    {
 	/*
 	 * Well, it's local -- go look for it.
 	 */
 	char name[] = { varname[0], '\0' };
 	v = VarFind(name, ctxt, 0);
 	if (v != NULL) {
 	    if (varname[1] == 'D') {
 		*out_TRUE_extraModifiers = "H:";
 	    } else { /* F */
 		*out_TRUE_extraModifiers = "T:";
+	    }
+	}
+    }
     if (v == NULL) {
 	dynamic = VarIsDynamic(ctxt, varname, namelen);
 	if (!haveModifier) {
 	    p++;		/* skip endc */
 	    *pp = p;
 	    if (dynamic) {
 		char *pstr = bmake_strsedup(start, p);
 		free(varname);
 		*out_FALSE_res = VPR_OK;
 		*out_FALSE_freePtr = pstr;
 		*out_FALSE_val = pstr;
 		return FALSE;
+	    }
 	    if ((eflags & VARE_UNDEFERR) && (eflags & VARE_WANTRES) &&
 		DEBUG(LINT))
+	    {
 		Parse_Error(PARSE_FATAL, "Variable \"%s\" is undefined",
 			    varname);
 		free(varname);
 		*out_FALSE_res = VPR_UNDEF_MSG;
 		*out_FALSE_val = var_Error;
 		return FALSE;
+	    }
 	    if (eflags & VARE_UNDEFERR) {
 		free(varname);
 		*out_FALSE_res = VPR_UNDEF_SILENT;
 		*out_FALSE_val = var_Error;
 		return FALSE;
+	    }
 	    free(varname);
 	    *out_FALSE_res = VPR_OK;
 	    *out_FALSE_val = varUndefined;
 	    return FALSE;
+	}
 	/* The variable expression is based on an undefined variable.
 	 * Nevertheless it needs a Var, for modifiers that access the
 	 * variable name, such as :L or :?.
+	 *
 	 * Most modifiers leave this expression in the "undefined" state
 	 * (VEF_UNDEF), only a few modifiers like :D, :U, :L, :P turn this
 	 * undefined expression into a defined expression (VEF_DEF).
+	 *
 	 * At the end, after applying all modifiers, if the expression
 	 * is still undefined, Var_Parse will return an empty string
 	 * instead of the actually computed value. */
 	v = VarNew(varname, varname, "", 0);
 	*out_TRUE_exprFlags = VEF_UNDEF;
     } else
 	free(varname);
     *out_TRUE_endc = endc;
     *out_TRUE_p = p;
     *out_TRUE_v = v;
     *out_TRUE_haveModifier = haveModifier;
     *out_TRUE_dynamic = dynamic;
     return TRUE;
+}
 /*-
  *-----------------------------------------------------------------------
  * Var_Parse --
  *	Given the start of a variable expression (such as $v, $(VAR),
  *	${VAR:Mpattern}), extract the variable name, possibly some
  *	modifiers and find its value by applying the modifiers to the
  *	original value.
+ *
  *	When parsing a condition in ParseEmptyArg, pp may also point to
  *	the "y" of "empty(VARNAME:Modifiers)", which is syntactically
  *	identical.
+ *
  * Input:
 @@ -3579,130 +3718,38 @@ Var_Parse(const char **pp, GNode *ctxt,
 	       Enum_FlagsToString(eflags_str, sizeof eflags_str, eflags,
 				  VarEvalFlags_ToStringSpecs));
     *freePtr = NULL;
     extramodifiers = NULL;	/* extra modifiers to apply first */
     dynamic = FALSE;
     /* Appease GCC, which thinks that the variable might not be
      * initialized. */
     endc = '\0';
     startc = start[1];
     if (startc != '(' && startc != '{') {
-        VarParseResult res;
+	VarParseResult res;
 	if (!ParseVarnameShort(startc, pp, ctxt, eflags, out_val, &res, &v))
 	    return res;
 	haveModifier = FALSE;
 	p = start + 1;
     } else {
-	size_t namelen;
+	VarParseResult res;
-	char *varname;
+	if (!ParseVarnameLong(pp, startc, ctxt, eflags,
 			      &res, out_val, freePtr,
-	endc = startc == '(' ? ')' : '}';
+			      &endc, &p, &v, &haveModifier, &extramodifiers,
 			      &dynamic, &exprFlags))
-	p = start + 2;
+	    return res;
 	varname = ParseVarname(&p, startc, endc, ctxt, eflags, &namelen);
 	if (*p == ':') {
 	    haveModifier = TRUE;
 	} else if (*p == endc) {
 	    haveModifier = FALSE;
 	} else {
 	    Parse_Error(PARSE_FATAL, "Unclosed variable \"%s\"", varname);
 	    *pp = p;
 	    free(varname);
 	    *out_val = var_Error;
 	    return VPR_PARSE_MSG;
 	v = VarFind(varname, ctxt, TRUE);
 	/* At this point, p points just after the variable name,
 	 * either at ':' or at endc. */
 	/*
 	 * Check also for bogus D and F forms of local variables since we're
 	 * in a local context and the name is the right length.
 	 */
 	if (v == NULL && ctxt != VAR_CMDLINE && ctxt != VAR_GLOBAL &&
 	    namelen == 2 && (varname[1] == 'F' || varname[1] == 'D') &&
 	    strchr("@%?*!<>", varname[0]) != NULL)
 	    /*
 	     * Well, it's local -- go look for it.
 	     */
 	    char name[] = { varname[0], '\0' };
 	    v = VarFind(name, ctxt, 0);
 	    if (v != NULL) {
 		if (varname[1] == 'D') {
 		    extramodifiers = "H:";
 		} else { /* F */
 		    extramodifiers = "T:";
 	if (v == NULL) {
 	    dynamic = VarIsDynamic(ctxt, varname, namelen);
 	    if (!haveModifier) {
 		p++;		/* skip endc */
 		*pp = p;
 		if (dynamic) {
 		    char *pstr = bmake_strsedup(start, p);
 		    *freePtr = pstr;
 		    free(varname);
 		    *out_val = pstr;
 		    return VPR_OK;
 		if ((eflags & VARE_UNDEFERR) && (eflags & VARE_WANTRES) &&
 		    DEBUG(LINT))
 		    Parse_Error(PARSE_FATAL, "Variable \"%s\" is undefined",
 				varname);
 		    free(varname);
 		    *out_val = var_Error;
 		    return VPR_UNDEF_MSG;
 		if (eflags & VARE_UNDEFERR) {
 		    free(varname);
 		    *out_val = var_Error;
 		    return VPR_UNDEF_SILENT;
 		free(varname);
 		*out_val = varUndefined;
 		return VPR_OK;
 	    /* The variable expression is based on an undefined variable.
 	     * Nevertheless it needs a Var, for modifiers that access the
 	     * variable name, such as :L or :?.
 	     * Most modifiers leave this expression in the "undefined" state
 	     * (VEF_UNDEF), only a few modifiers like :D, :U, :L, :P turn this
 	     * undefined expression into a defined expression (VEF_DEF).
 	     * At the end, after applying all modifiers, if the expression
 	     * is still undefined, Var_Parse will return an empty string
 	     * instead of the actually computed value. */
 	    v = VarNew(varname, varname, "", 0);
 	    exprFlags = VEF_UNDEF;
 	} else
 	    free(varname);
+    }
     if (v->flags & VAR_IN_USE)
 	Fatal("Variable %s is recursive.", v->name);
     /*
      * Before doing any modification, we have to make sure the value
      * has been fully expanded. If it looks like recursion might be
      * necessary (there's a dollar sign somewhere in the variable's value)
      * we just call Var_Subst to do any other substitutions that are
      * necessary. Note that the value returned by Var_Subst will have
      * been dynamically-allocated, so it will need freeing when we
      * return.