 @@ -1,14 +1,14 @@
-/*	$NetBSD: var.c,v 1.329 2020/07/26 19:44:04 rillig Exp $	*/
+/*	$NetBSD: var.c,v 1.330 2020/07/26 19:55:24 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.
 @@ -59,34 +59,34 @@
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #ifndef MAKE_NATIVE
-static char rcsid[] = "$NetBSD: var.c,v 1.329 2020/07/26 19:44:04 rillig Exp $";
+static char rcsid[] = "$NetBSD: var.c,v 1.330 2020/07/26 19:55:24 rillig Exp $";
 #else
 #include <sys/cdefs.h>
 #ifndef lint
 #if 0
 static char sccsid[] = "@(#)var.c	8.3 (Berkeley) 3/19/94";
 #else
-__RCSID("$NetBSD: var.c,v 1.329 2020/07/26 19:44:04 rillig Exp $");
+__RCSID("$NetBSD: var.c,v 1.330 2020/07/26 19:55:24 rillig Exp $");
 #endif
 #endif /* not lint */
 #endif
 /*-
  * var.c --
  *	Variable-handling functions
+ *
  * Interface:
  *	Var_Set		    Set the value of a variable in the given
  *			    context. The variable is created if it doesn't
  *			    yet exist.
+ *
 @@ -1828,37 +1828,37 @@ ParseModifierPart(const char **tstr, int
 	    cp[1] == delim || cp[1] == '\\' || cp[1] == '$' ||
 	    (cp[1] == '&' && subst != NULL));
 	if (is_escaped) {
 	    Buf_AddByte(&buf, cp[1]);
 	    cp++;
 	} else if (*cp == '$') {
 	    if (cp[1] == delim) {	/* Unescaped $ at end of pattern */
 		if (out_pflags != NULL)
 		    *out_pflags |= VARP_ANCHOR_END;
 		else
 		    Buf_AddByte(&buf, *cp);
 	    } else {
 		if (eflags & VARE_WANTRES) {
 		    char   *cp2;
 		    int     len;
 		    void   *freeIt;
 		    /*
 		     * If unescaped dollar sign not before the
 		     * delimiter, assume it's a variable
 		     * substitution and recurse.
 		     */
-		    VarEvalFlags sub_eflags = errnum | (eflags & VARE_WANTRES);
+		    cp2 = Var_Parse(cp, ctxt, errnum | (eflags & VARE_WANTRES),
-		    const char *cp2 = Var_Parse(cp, ctxt, sub_eflags,
+				    &len, &freeIt);
 						&len, &freeIt);
 		    Buf_AddStr(&buf, cp2);
 		    free(freeIt);
 		    cp += len - 1;
 		} else {
 		    const char *cp2 = &cp[1];
 		    if (*cp2 == PROPEN || *cp2 == BROPEN) {
 			/*
 			 * Find the end of this variable reference
 			 * and suck it in without further ado.
 			 * It will be interpreted later.
 			 */
 			int have = *cp2;
 @@ -2135,31 +2135,31 @@ ApplyModifier_Defined(const char *mod, A
     for (st->cp = mod + 1;
 	 *st->cp != st->endc && *st->cp != ':' && *st->cp != '\0';
 	 st->cp++) {
 	if (*st->cp == '\\' &&
 	    (st->cp[1] == ':' || st->cp[1] == '$' || st->cp[1] == st->endc ||
 	     st->cp[1] == '\\')) {
 	    Buf_AddByte(&buf, st->cp[1]);
 	    st->cp++;
 	} else if (*st->cp == '$') {
 	    /*
 	     * If unescaped dollar sign, assume it's a
 	     * variable substitution and recurse.
 	     */
 	    char    *cp2;
 	    int	    len;
 	    void    *freeIt;
-	    const char *cp2 = Var_Parse(st->cp, st->ctxt, neflags,
+	    cp2 = Var_Parse(st->cp, st->ctxt, neflags, &len, &freeIt);
 					&len, &freeIt);
 	    Buf_AddStr(&buf, cp2);
 	    free(freeIt);
 	    st->cp += len - 1;
 	} else {
 	    Buf_AddByte(&buf, *st->cp);
+	}
+    }
     st->termc = *st->cp;
     if (st->v->flags & VAR_JUNK)
 	st->v->flags |= VAR_KEEP;
     if (neflags & VARE_WANTRES) {
 @@ -3067,31 +3067,31 @@ ApplyModifiers(char *nstr, const char *t
 	startc, endc, v, ctxt, eflags, lengthPtr, freePtr,
 	nstr, tstr, tstr,
 	'\0', '\0', 0, ' ', FALSE, NULL
     };
     const char *p = tstr;
     while (*p != '\0' && *p != endc) {
 	if (*p == '$') {
 	    /*
 	     * We may have some complex modifiers in a variable.
 	     */
 	    void *freeIt;
 	    char *rval;
 	    int rlen;
 	    int c;
-	    const char *rval = Var_Parse(p, st.ctxt, st.eflags,
+	    rval = Var_Parse(p, st.ctxt, st.eflags, &rlen, &freeIt);
 					 &rlen, &freeIt);
 	    /*
 	     * If we have not parsed up to st.endc or ':',
 	     * we are not interested.
 	     */
 	    if (rval != NULL && *rval &&
 		(c = p[rlen]) != '\0' &&
 		c != ':' &&
 		c != st.endc) {
 		free(freeIt);
 		goto apply_mods;
+	    }
 @@ -3373,27 +3373,27 @@ cleanup:
  *	The (possibly-modified) value of the variable or var_Error if the
  *	specification is invalid. The length of the specification is
  *	placed in *lengthPtr (for invalid specifications, this is just
  *	2...?).
  *	If *freePtr is non-NULL then it's a pointer that the caller
  *	should pass to free() to free memory used by the result.
+ *
  * Side Effects:
  *	None.
+ *
  *-----------------------------------------------------------------------
  */
 /* coverity[+alloc : arg-*4] */
-const char *
+char *
 Var_Parse(const char * const str, GNode *ctxt, VarEvalFlags flags,
 	  int *lengthPtr, void **freePtr)
+{
     const char	*tstr;		/* Pointer into str */
     Var		*v;		/* Variable in invocation */
     Boolean 	 haveModifier;	/* TRUE if have modifiers for the variable */
     char	 endc;		/* Ending character when variable in parens
 				 * or braces */
     char	 startc;	/* Starting character when variable in parens
 				 * or braces */
     char	*nstr;		/* New string, used during expansion */
     Boolean	 dynamic;	/* TRUE if the variable is local and we're
 				 * expanding it in a non-local context. This
 @@ -3426,33 +3426,33 @@ Var_Parse(const char * const str, GNode
 	    if ((ctxt == VAR_CMD) || (ctxt == VAR_GLOBAL)) {
 		/*
 		 * If substituting a local variable in a non-local context,
 		 * assume it's for dynamic source stuff. We have to handle
 		 * this specially and return the longhand for the variable
 		 * with the dollar sign escaped so it makes it back to the
 		 * caller. Only four of the local variables are treated
 		 * specially as they are the only four that will be set
 		 * when dynamic sources are expanded.
 		 */
 		switch (str[1]) {
 		case '@':
-		    return "$(.TARGET)";
+		    return UNCONST("$(.TARGET)");
 		case '%':
-		    return "$(.MEMBER)";
+		    return UNCONST("$(.MEMBER)");
 		case '*':
-		    return "$(.PREFIX)";
+		    return UNCONST("$(.PREFIX)");
 		case '!':
-		    return "$(.ARCHIVE)";
+		    return UNCONST("$(.ARCHIVE)");
+		}
+	    }
 	    return (flags & VARE_UNDEFERR) ? var_Error : varNoError;
 	} else {
 	    haveModifier = FALSE;
 	    tstr = str + 1;
 	    endc = str[1];
+	}
     } else {
 	Buffer buf;		/* Holds the variable name */
 	int depth = 1;
 	endc = startc == PROPEN ? PRCLOSE : BRCLOSE;
 @@ -3465,28 +3465,27 @@ Var_Parse(const char * const str, GNode
 	    /* Track depth so we can spot parse errors. */
 	    if (*tstr == startc)
 		depth++;
 	    if (*tstr == endc) {
 		if (--depth == 0)
 		    break;
+	    }
 	    if (depth == 1 && *tstr == ':')
 		break;
 	    /* A variable inside a variable, expand. */
 	    if (*tstr == '$') {
 		int rlen;
 		void *freeIt;
-		const char *rval = Var_Parse(tstr, ctxt, flags,
+		char *rval = Var_Parse(tstr, ctxt, flags, &rlen, &freeIt);
 					     &rlen, &freeIt);
 		if (rval != NULL)
 		    Buf_AddStr(&buf, rval);
 		free(freeIt);
 		tstr += rlen - 1;
 	    } else
 		Buf_AddByte(&buf, *tstr);
+	}
 	if (*tstr == ':') {
 	    haveModifier = TRUE;
 	} else if (*tstr == endc) {
 	    haveModifier = FALSE;
 	} else {
 	    /*
 @@ -3704,27 +3703,27 @@ Var_Parse(const char * const str, GNode
  *			VARE_ASSIGN	if we are in a := assignment
+ *
  * Results:
  *	The resulting string.
+ *
  * Side Effects:
  *	None.
  *-----------------------------------------------------------------------
  */
 char *
 Var_Subst(const char *var, const char *str, GNode *ctxt, VarEvalFlags flags)
+{
     Buffer	buf;		/* Buffer for forming things */
-    const char	*val;		/* Value to substitute for a variable */
+    char	*val;		/* Value to substitute for a variable */
     int		length;		/* Length of the variable invocation */
     Boolean	trailingBslash;	/* variable ends in \ */
     void	*freeIt = NULL;	/* Set if it should be freed */
     static Boolean errorReported; /* Set true if an error has already
 				 * been reported to prevent a plethora
 				 * of messages when recursing */
     Buf_Init(&buf, 0);
     errorReported = FALSE;
     trailingBslash = FALSE;
     while (*str) {
 	if (*str == '\n' && trailingBslash)

 @@ -1,14 +1,14 @@
-/*	$NetBSD: nonints.h,v 1.84 2020/07/26 19:44:04 rillig Exp $	*/
+/*	$NetBSD: nonints.h,v 1.85 2020/07/26 19:55:24 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.
 @@ -181,27 +181,27 @@ void Targ_Propagate_Wait(void);
 typedef enum {
     /* Treat undefined variables as errors. */
     VARE_UNDEFERR	= 0x01,
     /* Expand and evaluate variables during parsing. */
     VARE_WANTRES	= 0x02,
     VARE_ASSIGN		= 0x04
 } VarEvalFlags;
 void Var_Delete(const char *, GNode *);
 void Var_Set(const char *, const char *, GNode *);
 void Var_Append(const char *, const char *, GNode *);
 Boolean Var_Exists(const char *, GNode *);
 char *Var_Value(const char *, GNode *, char **);
-const char *Var_Parse(const char *, GNode *, VarEvalFlags, int *, void **);
+char *Var_Parse(const char *, GNode *, VarEvalFlags, int *, void **);
 char *Var_Subst(const char *, const char *, GNode *, VarEvalFlags);
 char *Var_GetTail(const char *);
 char *Var_GetHead(const char *);
 void Var_Init(void);
 void Var_End(void);
 void Var_Stats(void);
 void Var_Dump(GNode *);
 void Var_ExportVars(void);
 void Var_Export(char *, int);
 void Var_UnExport(char *);
 /* util.c */
 void (*bmake_signal(int, void (*)(int)))(int);