refactor: use MaxStack as depth limit instead of fixed constant

Flo354 · Flo354 · commit 99bd6d153498 · 2026-03-23T20:38:59.000+01:00
diff --git a/builtins.go b/builtins.go
@@ -1733,11 +1733,9 @@ func tomlAddToPath(path []string, tail string) []string {
 	return result
 }
 
-const maxManifestDepth = 500
-
 // tomlRenderValue returns a rendered value as string, with proper indenting
 func tomlRenderValue(i *interpreter, val value, sindent string, indexedPath []string, inline bool, cindent string, depth int) (string, error) {
-	if depth > maxManifestDepth {
+	if depth <= 0 {
 		return "", i.Error("max manifest depth exceeded, possible infinite recursion")
 	}
 	switch v := val.(type) {
@@ -1781,7 +1779,7 @@ func tomlRenderValue(i *interpreter, val value, sindent string, indexedPath []st
 			}
 
 			res = res + newIndent
-			value, err := tomlRenderValue(i, thunkValue, sindent, childIndexedPath, true, "", depth+1)
+			value, err := tomlRenderValue(i, thunkValue, sindent, childIndexedPath, true, "", depth-1)
 			if err != nil {
 				return "", err
 			}
@@ -1812,7 +1810,7 @@ func tomlRenderValue(i *interpreter, val value, sindent string, indexedPath []st
 
 			childIndexedPath := tomlAddToPath(indexedPath, fieldName)
 
-			value, err := tomlRenderValue(i, fieldValue, sindent, childIndexedPath, true, "", depth+1)
+			value, err := tomlRenderValue(i, fieldValue, sindent, childIndexedPath, true, "", depth-1)
 			if err != nil {
 				return "", err
 			}
@@ -1831,7 +1829,7 @@ func tomlRenderValue(i *interpreter, val value, sindent string, indexedPath []st
 }
 
 func tomlRenderTableArray(i *interpreter, v *valueArray, sindent string, path []string, indexedPath []string, cindent string, depth int) (string, error) {
-	if depth > maxManifestDepth {
+	if depth <= 0 {
 		return "", i.Error("max manifest depth exceeded, possible infinite recursion")
 	}
 
@@ -1866,7 +1864,7 @@ func tomlRenderTableArray(i *interpreter, v *valueArray, sindent string, path []
 			childIndexedPath := tomlAddToPath(indexedPath, strconv.FormatInt(int64(j), 10))
 
 			// render the table and add it to result
-			table, err := tomlTableInternal(i, tv, sindent, path, childIndexedPath, cindent+sindent, depth+1)
+			table, err := tomlTableInternal(i, tv, sindent, path, childIndexedPath, cindent+sindent, depth-1)
 			if err != nil {
 				return "", err
 			}
@@ -1883,7 +1881,7 @@ func tomlRenderTableArray(i *interpreter, v *valueArray, sindent string, path []
 }
 
 func tomlRenderTable(i *interpreter, v *valueObject, sindent string, path []string, indexedPath []string, cindent string, depth int) (string, error) {
-	if depth > maxManifestDepth {
+	if depth <= 0 {
 		return "", i.Error("max manifest depth exceeded, possible infinite recursion")
 	}
 	res := cindent + "["
@@ -1898,7 +1896,7 @@ func tomlRenderTable(i *interpreter, v *valueObject, sindent string, path []stri
 		res = res + "\n"
 	}
 
-	table, err := tomlTableInternal(i, v, sindent, path, indexedPath, cindent+sindent, depth+1)
+	table, err := tomlTableInternal(i, v, sindent, path, indexedPath, cindent+sindent, depth-1)
 	if err != nil {
 		return "", err
 	}
@@ -1908,7 +1906,7 @@ func tomlRenderTable(i *interpreter, v *valueObject, sindent string, path []stri
 }
 
 func tomlTableInternal(i *interpreter, v *valueObject, sindent string, path []string, indexedPath []string, cindent string, depth int) (string, error) {
-	if depth > maxManifestDepth {
+	if depth <= 0 {
 		return "", i.Error("max manifest depth exceeded, possible infinite recursion")
 	}
 	resFields := []string{}
@@ -1937,13 +1935,13 @@ func tomlTableInternal(i *interpreter, v *valueObject, sindent string, path []st
 
 			switch fv := fieldValue.(type) {
 			case *valueObject:
-				section, err := tomlRenderTable(i, fv, sindent, childPath, childIndexedPath, cindent, depth+1)
+				section, err := tomlRenderTable(i, fv, sindent, childPath, childIndexedPath, cindent, depth-1)
 				if err != nil {
 					return "", err
 				}
 				resSections = append(resSections, section)
 			case *valueArray:
-				section, err := tomlRenderTableArray(i, fv, sindent, childPath, childIndexedPath, cindent, depth+1)
+				section, err := tomlRenderTableArray(i, fv, sindent, childPath, childIndexedPath, cindent, depth-1)
 				if err != nil {
 					return "", err
 				}
@@ -1954,7 +1952,7 @@ func tomlTableInternal(i *interpreter, v *valueObject, sindent string, path []st
 		} else {
 			// render as value and append to result fields
 
-			renderedValue, err := tomlRenderValue(i, fieldValue, sindent, childIndexedPath, false, "", depth+1)
+			renderedValue, err := tomlRenderValue(i, fieldValue, sindent, childIndexedPath, false, "", depth-1)
 			if err != nil {
 				return "", err
 			}
@@ -1982,7 +1980,7 @@ func builtinManifestTomlEx(i *interpreter, arguments []value) (value, error) {
 
 	switch v := val.(type) {
 	case *valueObject:
-		res, err := tomlTableInternal(i, v, sindent, []string{}, []string{}, "", 0)
+		res, err := tomlTableInternal(i, v, sindent, []string{}, []string{}, "", i.stack.limit)
 		if err != nil {
 			return nil, err
 		}
@@ -2022,7 +2020,7 @@ func builtinManifestJSONEx(i *interpreter, arguments []value) (value, error) {
 
 	var aux func(ov value, path []string, cindent string, depth int) (string, error)
 	aux = func(ov value, path []string, cindent string, depth int) (string, error) {
-		if depth > maxManifestDepth {
+		if depth <= 0 {
 			return "", i.Error("max manifest depth exceeded, possible infinite recursion")
 		}
 		if ov == nil {
@@ -2057,7 +2055,7 @@ func builtinManifestJSONEx(i *interpreter, arguments []value) (value, error) {
 				}
 
 				newPath := append(path, strconv.FormatInt(int64(aI), 10))
-				s, err := aux(cTv, newPath, newIndent, depth+1)
+				s, err := aux(cTv, newPath, newIndent, depth-1)
 				if err != nil {
 					return "", err
 				}
@@ -2085,7 +2083,7 @@ func builtinManifestJSONEx(i *interpreter, arguments []value) (value, error) {
 				}
 
 				newPath := append(path, fieldName)
-				mvs, err := aux(fieldValue, newPath, newIndent, depth+1)
+				mvs, err := aux(fieldValue, newPath, newIndent, depth-1)
 				if err != nil {
 					return "", err
 				}
@@ -2101,7 +2099,7 @@ func builtinManifestJSONEx(i *interpreter, arguments []value) (value, error) {
 		}
 	}
 
-	finalString, err := aux(val, path, "", 0)
+	finalString, err := aux(val, path, "", i.stack.limit)
 	if err != nil {
 		return nil, err
 	}
@@ -2191,7 +2189,7 @@ func builtinManifestYamlDoc(i *interpreter, arguments []value) (value, error) {
 
 	var aux func(ov value, buf *bytes.Buffer, cindent string, depth int) error
 	aux = func(ov value, buf *bytes.Buffer, cindent string, depth int) error {
-		if depth > maxManifestDepth {
+		if depth <= 0 {
 			return i.Error("max manifest depth exceeded, possible infinite recursion")
 		}
 		switch v := ov.(type) {
@@ -2251,7 +2249,7 @@ func builtinManifestYamlDoc(i *interpreter, arguments []value) (value, error) {
 					cindent = cindent + yamlIndent
 				}
 
-				if err := aux(thunkValue, buf, cindent, depth+1); err != nil {
+				if err := aux(thunkValue, buf, cindent, depth-1); err != nil {
 					return err
 				}
 				cindent = prevIndent
@@ -2301,7 +2299,7 @@ func builtinManifestYamlDoc(i *interpreter, arguments []value) (value, error) {
 				} else {
 					buf.WriteByte(' ')
 				}
-				if err := aux(fieldValue, buf, cindent, depth+1); err != nil {
+				if err := aux(fieldValue, buf, cindent, depth-1); err != nil {
 					return err
 				}
 				cindent = prevIndent
@@ -2310,7 +2308,7 @@ func builtinManifestYamlDoc(i *interpreter, arguments []value) (value, error) {
 		return nil
 	}
 
-	if err := aux(val, &buf, "", 0); err != nil {
+	if err := aux(val, &buf, "", i.stack.limit); err != nil {
 		return nil, err
 	}
 

Original file line number	Diff line number	Diff line change
`@@ -1733,11 +1733,9 @@ func tomlAddToPath(path []string, tail string) []string {`
`1733`	`1733`	`return result`
`1734`	`1734`	`}`
`1735`	`1735`
`1736`		`-const maxManifestDepth = 500`
`1737`		`-`
`1738`	`1736`	`// tomlRenderValue returns a rendered value as string, with proper indenting`
`1739`	`1737`	`func tomlRenderValue(i *interpreter, val value, sindent string, indexedPath []string, inline bool, cindent string, depth int) (string, error) {`
`1740`		`- if depth > maxManifestDepth {`
	`1738`	`+ if depth <= 0 {`
`1741`	`1739`	`return "", i.Error("max manifest depth exceeded, possible infinite recursion")`
`1742`	`1740`	`}`
`1743`	`1741`	`switch v := val.(type) {`
`@@ -1781,7 +1779,7 @@ func tomlRenderValue(i *interpreter, val value, sindent string, indexedPath []st`
`1781`	`1779`	`}`
`1782`	`1780`
`1783`	`1781`	`res = res + newIndent`
`1784`		`- value, err := tomlRenderValue(i, thunkValue, sindent, childIndexedPath, true, "", depth+1)`
	`1782`	`+ value, err := tomlRenderValue(i, thunkValue, sindent, childIndexedPath, true, "", depth-1)`
`1785`	`1783`	`if err != nil {`
`1786`	`1784`	`return "", err`
`1787`	`1785`	`}`
`@@ -1812,7 +1810,7 @@ func tomlRenderValue(i *interpreter, val value, sindent string, indexedPath []st`
`1812`	`1810`
`1813`	`1811`	`childIndexedPath := tomlAddToPath(indexedPath, fieldName)`
`1814`	`1812`
`1815`		`- value, err := tomlRenderValue(i, fieldValue, sindent, childIndexedPath, true, "", depth+1)`
	`1813`	`+ value, err := tomlRenderValue(i, fieldValue, sindent, childIndexedPath, true, "", depth-1)`
`1816`	`1814`	`if err != nil {`
`1817`	`1815`	`return "", err`
`1818`	`1816`	`}`
`@@ -1831,7 +1829,7 @@ func tomlRenderValue(i *interpreter, val value, sindent string, indexedPath []st`
`1831`	`1829`	`}`
`1832`	`1830`
`1833`	`1831`	`func tomlRenderTableArray(i interpreter, v valueArray, sindent string, path []string, indexedPath []string, cindent string, depth int) (string, error) {`
`1834`		`- if depth > maxManifestDepth {`
	`1832`	`+ if depth <= 0 {`
`1835`	`1833`	`return "", i.Error("max manifest depth exceeded, possible infinite recursion")`
`1836`	`1834`	`}`
`1837`	`1835`
`@@ -1866,7 +1864,7 @@ func tomlRenderTableArray(i interpreter, v valueArray, sindent string, path []`
`1866`	`1864`	`childIndexedPath := tomlAddToPath(indexedPath, strconv.FormatInt(int64(j), 10))`
`1867`	`1865`
`1868`	`1866`	`// render the table and add it to result`
`1869`		`- table, err := tomlTableInternal(i, tv, sindent, path, childIndexedPath, cindent+sindent, depth+1)`
	`1867`	`+ table, err := tomlTableInternal(i, tv, sindent, path, childIndexedPath, cindent+sindent, depth-1)`
`1870`	`1868`	`if err != nil {`
`1871`	`1869`	`return "", err`
`1872`	`1870`	`}`
`@@ -1883,7 +1881,7 @@ func tomlRenderTableArray(i interpreter, v valueArray, sindent string, path []`
`1883`	`1881`	`}`
`1884`	`1882`
`1885`	`1883`	`func tomlRenderTable(i interpreter, v valueObject, sindent string, path []string, indexedPath []string, cindent string, depth int) (string, error) {`
`1886`		`- if depth > maxManifestDepth {`
	`1884`	`+ if depth <= 0 {`
`1887`	`1885`	`return "", i.Error("max manifest depth exceeded, possible infinite recursion")`
`1888`	`1886`	`}`
`1889`	`1887`	`res := cindent + "["`
`@@ -1898,7 +1896,7 @@ func tomlRenderTable(i interpreter, v valueObject, sindent string, path []stri`
`1898`	`1896`	`res = res + "\n"`
`1899`	`1897`	`}`
`1900`	`1898`
`1901`		`- table, err := tomlTableInternal(i, v, sindent, path, indexedPath, cindent+sindent, depth+1)`
	`1899`	`+ table, err := tomlTableInternal(i, v, sindent, path, indexedPath, cindent+sindent, depth-1)`
`1902`	`1900`	`if err != nil {`
`1903`	`1901`	`return "", err`
`1904`	`1902`	`}`
`@@ -1908,7 +1906,7 @@ func tomlRenderTable(i interpreter, v valueObject, sindent string, path []stri`
`1908`	`1906`	`}`
`1909`	`1907`
`1910`	`1908`	`func tomlTableInternal(i interpreter, v valueObject, sindent string, path []string, indexedPath []string, cindent string, depth int) (string, error) {`
`1911`		`- if depth > maxManifestDepth {`
	`1909`	`+ if depth <= 0 {`
`1912`	`1910`	`return "", i.Error("max manifest depth exceeded, possible infinite recursion")`
`1913`	`1911`	`}`
`1914`	`1912`	`resFields := []string{}`
`@@ -1937,13 +1935,13 @@ func tomlTableInternal(i interpreter, v valueObject, sindent string, path []st`
`1937`	`1935`
`1938`	`1936`	`switch fv := fieldValue.(type) {`
`1939`	`1937`	`case *valueObject:`
`1940`		`- section, err := tomlRenderTable(i, fv, sindent, childPath, childIndexedPath, cindent, depth+1)`
	`1938`	`+ section, err := tomlRenderTable(i, fv, sindent, childPath, childIndexedPath, cindent, depth-1)`
`1941`	`1939`	`if err != nil {`
`1942`	`1940`	`return "", err`
`1943`	`1941`	`}`
`1944`	`1942`	`resSections = append(resSections, section)`
`1945`	`1943`	`case *valueArray:`
`1946`		`- section, err := tomlRenderTableArray(i, fv, sindent, childPath, childIndexedPath, cindent, depth+1)`
	`1944`	`+ section, err := tomlRenderTableArray(i, fv, sindent, childPath, childIndexedPath, cindent, depth-1)`
`1947`	`1945`	`if err != nil {`
`1948`	`1946`	`return "", err`
`1949`	`1947`	`}`
`@@ -1954,7 +1952,7 @@ func tomlTableInternal(i interpreter, v valueObject, sindent string, path []st`
`1954`	`1952`	`} else {`
`1955`	`1953`	`// render as value and append to result fields`
`1956`	`1954`
`1957`		`- renderedValue, err := tomlRenderValue(i, fieldValue, sindent, childIndexedPath, false, "", depth+1)`
	`1955`	`+ renderedValue, err := tomlRenderValue(i, fieldValue, sindent, childIndexedPath, false, "", depth-1)`
`1958`	`1956`	`if err != nil {`
`1959`	`1957`	`return "", err`
`1960`	`1958`	`}`
`@@ -1982,7 +1980,7 @@ func builtinManifestTomlEx(i *interpreter, arguments []value) (value, error) {`
`1982`	`1980`
`1983`	`1981`	`switch v := val.(type) {`
`1984`	`1982`	`case *valueObject:`
`1985`		`- res, err := tomlTableInternal(i, v, sindent, []string{}, []string{}, "", 0)`
	`1983`	`+ res, err := tomlTableInternal(i, v, sindent, []string{}, []string{}, "", i.stack.limit)`
`1986`	`1984`	`if err != nil {`
`1987`	`1985`	`return nil, err`
`1988`	`1986`	`}`
`@@ -2022,7 +2020,7 @@ func builtinManifestJSONEx(i *interpreter, arguments []value) (value, error) {`
`2022`	`2020`
`2023`	`2021`	`var aux func(ov value, path []string, cindent string, depth int) (string, error)`
`2024`	`2022`	`aux = func(ov value, path []string, cindent string, depth int) (string, error) {`
`2025`		`- if depth > maxManifestDepth {`
	`2023`	`+ if depth <= 0 {`
`2026`	`2024`	`return "", i.Error("max manifest depth exceeded, possible infinite recursion")`
`2027`	`2025`	`}`
`2028`	`2026`	`if ov == nil {`
`@@ -2057,7 +2055,7 @@ func builtinManifestJSONEx(i *interpreter, arguments []value) (value, error) {`
`2057`	`2055`	`}`
`2058`	`2056`
`2059`	`2057`	`newPath := append(path, strconv.FormatInt(int64(aI), 10))`
`2060`		`- s, err := aux(cTv, newPath, newIndent, depth+1)`
	`2058`	`+ s, err := aux(cTv, newPath, newIndent, depth-1)`
`2061`	`2059`	`if err != nil {`
`2062`	`2060`	`return "", err`
`2063`	`2061`	`}`
`@@ -2085,7 +2083,7 @@ func builtinManifestJSONEx(i *interpreter, arguments []value) (value, error) {`
`2085`	`2083`	`}`
`2086`	`2084`
`2087`	`2085`	`newPath := append(path, fieldName)`
`2088`		`- mvs, err := aux(fieldValue, newPath, newIndent, depth+1)`
	`2086`	`+ mvs, err := aux(fieldValue, newPath, newIndent, depth-1)`
`2089`	`2087`	`if err != nil {`
`2090`	`2088`	`return "", err`
`2091`	`2089`	`}`
`@@ -2101,7 +2099,7 @@ func builtinManifestJSONEx(i *interpreter, arguments []value) (value, error) {`
`2101`	`2099`	`}`
`2102`	`2100`	`}`
`2103`	`2101`
`2104`		`- finalString, err := aux(val, path, "", 0)`
	`2102`	`+ finalString, err := aux(val, path, "", i.stack.limit)`
`2105`	`2103`	`if err != nil {`
`2106`	`2104`	`return nil, err`
`2107`	`2105`	`}`
`@@ -2191,7 +2189,7 @@ func builtinManifestYamlDoc(i *interpreter, arguments []value) (value, error) {`
`2191`	`2189`
`2192`	`2190`	`var aux func(ov value, buf *bytes.Buffer, cindent string, depth int) error`
`2193`	`2191`	`aux = func(ov value, buf *bytes.Buffer, cindent string, depth int) error {`
`2194`		`- if depth > maxManifestDepth {`
	`2192`	`+ if depth <= 0 {`
`2195`	`2193`	`return i.Error("max manifest depth exceeded, possible infinite recursion")`
`2196`	`2194`	`}`
`2197`	`2195`	`switch v := ov.(type) {`
`@@ -2251,7 +2249,7 @@ func builtinManifestYamlDoc(i *interpreter, arguments []value) (value, error) {`
`2251`	`2249`	`cindent = cindent + yamlIndent`
`2252`	`2250`	`}`
`2253`	`2251`
`2254`		`- if err := aux(thunkValue, buf, cindent, depth+1); err != nil {`
	`2252`	`+ if err := aux(thunkValue, buf, cindent, depth-1); err != nil {`
`2255`	`2253`	`return err`
`2256`	`2254`	`}`
`2257`	`2255`	`cindent = prevIndent`
`@@ -2301,7 +2299,7 @@ func builtinManifestYamlDoc(i *interpreter, arguments []value) (value, error) {`
`2301`	`2299`	`} else {`
`2302`	`2300`	`buf.WriteByte(' ')`
`2303`	`2301`	`}`
`2304`		`- if err := aux(fieldValue, buf, cindent, depth+1); err != nil {`
	`2302`	`+ if err := aux(fieldValue, buf, cindent, depth-1); err != nil {`
`2305`	`2303`	`return err`
`2306`	`2304`	`}`
`2307`	`2305`	`cindent = prevIndent`
`@@ -2310,7 +2308,7 @@ func builtinManifestYamlDoc(i *interpreter, arguments []value) (value, error) {`
`2310`	`2308`	`return nil`
`2311`	`2309`	`}`
`2312`	`2310`
`2313`		`- if err := aux(val, &buf, "", 0); err != nil {`
	`2311`	`+ if err := aux(val, &buf, "", i.stack.limit); err != nil {`
`2314`	`2312`	`return nil, err`
`2315`	`2313`	`}`
`2316`	`2314`