 @@ -1,14 +1,14 @@
-/*	$NetBSD: var.c,v 1.640 2020/11/01 22:48:41 rillig Exp $	*/
+/*	$NetBSD: var.c,v 1.641 2020/11/01 23:17:40 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.
 @@ -120,27 +120,27 @@
 #include <regex.h>
 #endif
 #include <errno.h>
 #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.640 2020/11/01 22:48:41 rillig Exp $");
+MAKE_RCSID("$NetBSD: var.c,v 1.641 2020/11/01 23:17:40 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).
  */
 @@ -3244,26 +3244,103 @@ ApplyModifier(const char **pp, ApplyModi
     case 'O':
 	return ApplyModifier_Order(pp, st);
     case 'u':
 	return ApplyModifier_Unique(pp, st);
 #ifdef SUNSHCMD
     case 's':
 	return ApplyModifier_SunShell(pp, st);
 #endif
     default:
 	return AMR_UNKNOWN;
+    }
+}
 static char *ApplyModifiers(const char **, char *, char, char, Var *,
 			    VarExprFlags *, GNode *, VarEvalFlags, void **);
 typedef enum ApplyModifiersIndirectResult {
     AMIR_CONTINUE,
     AMIR_APPLY_MODS,
     AMIR_OUT
 } ApplyModifiersIndirectResult;
 /* While expanding a variable expression, expand and apply indirect
  * modifiers. */
 static ApplyModifiersIndirectResult
 ApplyModifiersIndirect(
 	ApplyModifiersState *const st,
 	const char **inout_p,
 	void **const out_freeIt
 ) {
     const char *p = *inout_p;
     const char *nested_p = p;
     void *freeIt;
     const char *rval;
     char c;
     (void)Var_Parse(&nested_p, st->ctxt, st->eflags, &rval, &freeIt);
     /* TODO: handle errors */
     /*
      * If we have not parsed up to st->endc or ':', we are not
      * interested.  This means the expression ${VAR:${M_1}${M_2}}
      * is not accepted, but ${VAR:${M_1}:${M_2}} is.
      */
     if (rval[0] != '\0' &&
 	(c = *nested_p) != '\0' && c != ':' && c != st->endc) {
 	if (DEBUG(LINT))
 	    Parse_Error(PARSE_FATAL,
 			"Missing delimiter ':' after indirect modifier \"%.*s\"",
 			(int)(nested_p - p), p);
 	free(freeIt);
 	/* XXX: apply_mods doesn't sound like "not interested". */
 	/* XXX: Why is the indirect modifier parsed again by
 	 * apply_mods?  If any, p should be advanced to nested_p. */
 	return AMIR_APPLY_MODS;
+    }
     VAR_DEBUG3("Indirect modifier \"%s\" from \"%.*s\"\n",
 	       rval, (int)(size_t)(nested_p - p), p);
     p = nested_p;
     if (rval[0] != '\0') {
 	const char *rval_pp = rval;
 	st->val = ApplyModifiers(&rval_pp, st->val, '\0', '\0', st->v,
 				&st->exprFlags, st->ctxt, st->eflags, out_freeIt);
 	if (st->val == var_Error
 	    || (st->val == varUndefined && !(st->eflags & VARE_UNDEFERR))
 	    || *rval_pp != '\0') {
 	    free(freeIt);
 	    *inout_p = p;
 	    return AMIR_OUT;	/* error already reported */
+	}
+    }
     free(freeIt);
     if (*p == ':')
 	p++;
     else if (*p == '\0' && st->endc != '\0') {
 	Error("Unclosed variable specification after complex "
 	      "modifier (expecting '%c') for %s", st->endc, st->v->name);
 	*inout_p = p;
 	return AMIR_OUT;
+    }
     *inout_p = p;
     return AMIR_CONTINUE;
+}
 /* Apply any modifiers (such as :Mpattern or :@var@loop@ or :Q or ::=value). */
 static char *
 ApplyModifiers(
     const char **pp,		/* the parsing position, updated upon return */
     char *const val,		/* the current value of the expression */
     char const startc,		/* '(' or '{', or '\0' for indirect modifiers */
     char const endc,		/* ')' or '}', or '\0' for indirect modifiers */
     Var * const v,
     VarExprFlags *exprFlags,
     GNode * const ctxt,		/* for looking up and modifying variables */
     VarEvalFlags const eflags,
     void ** const out_freeIt	/* free this after using the return value */
 ) {
 @@ -3277,84 +3354,33 @@ ApplyModifiers(
     };
     const char *p;
     const char *mod;
     ApplyModifierResult res;
     assert(startc == '(' || startc == '{' || startc == '\0');
     assert(endc == ')' || endc == '}' || endc == '\0');
     assert(val != NULL);
     p = *pp;
     while (*p != '\0' && *p != endc) {
 	if (*p == '$') {
-	    /*
+	    ApplyModifiersIndirectResult amir;
-	     * We may have some complex modifiers in a variable.
+	    amir = ApplyModifiersIndirect(&st, &p, out_freeIt);
-	     */
+	    if (amir == AMIR_CONTINUE)
-	    const char *nested_p = p;
+		continue;
-	    void *freeIt;
+	    if (amir == AMIR_OUT)
-	    const char *rval;
+	        goto out;
 	    char c;
 	    (void)Var_Parse(&nested_p, st.ctxt, st.eflags, &rval, &freeIt);
 	    /* TODO: handle errors */
 	    /*
 	     * If we have not parsed up to st.endc or ':', we are not
 	     * interested.  This means the expression ${VAR:${M_1}${M_2}}
 	     * is not accepted, but ${VAR:${M_1}:${M_2}} is.
 	     */
 	    if (rval[0] != '\0' &&
 		(c = *nested_p) != '\0' && c != ':' && c != st.endc) {
 		if (DEBUG(LINT))
 		    Parse_Error(PARSE_FATAL,
 				"Missing delimiter ':' after indirect modifier \"%.*s\"",
 				(int)(nested_p - p), p);
 		free(freeIt);
 		/* XXX: apply_mods doesn't sound like "not interested". */
 		/* XXX: Why is the indirect modifier parsed again by
 		 * apply_mods?  If any, p should be advanced to nested_p. */
 		goto apply_mods;
 	    VAR_DEBUG3("Indirect modifier \"%s\" from \"%.*s\"\n",
 		       rval, (int)(size_t)(nested_p - p), p);
 	    p = nested_p;
 	    if (rval[0] != '\0') {
 		const char *rval_pp = rval;
 		st.val = ApplyModifiers(&rval_pp, st.val, '\0', '\0', v,
 					&st.exprFlags, ctxt, eflags, out_freeIt);
 		if (st.val == var_Error
 		    || (st.val == varUndefined && !(st.eflags & VARE_UNDEFERR))
 		    || *rval_pp != '\0') {
 		    free(freeIt);
 		    goto out;	/* error already reported */
 	    free(freeIt);
 	    if (*p == ':')
 		p++;
 	    else if (*p == '\0' && endc != '\0') {
 		Error("Unclosed variable specification after complex "
 		      "modifier (expecting '%c') for %s", st.endc, st.v->name);
 		goto out;
 	    continue;
+	}
     apply_mods:
 	st.newVal = var_Error;	/* default value, in case of errors */
 	mod = p;
 	if (DEBUG(VAR))
 	    LogBeforeApply(&st, mod, endc);
 	res = ApplyModifier(&p, &st);
 #ifdef SYSVVARSUB
 	if (res == AMR_UNKNOWN) {
 	    assert(p == mod);
 	    res = ApplyModifier_SysV(&p, &st);
+	}