ecpg: put all string-valued tokens returned by pgc.l in local storage.

tglsfdc · tglsfdc · commit 85312d95e959 · 2024-11-27T12:50:23.000-05:00
This didn't work earlier in the patch series (I think some of the strings were ending up in data-type-related structures), but apparently we're now clean enough for it. This considerably reduces process-lifespan memory leakage. Discussion: https://postgr.es/m/2011420.1713493114@sss.pgh.pa.us
diff --git a/src/interfaces/ecpg/preproc/parser.c b/src/interfaces/ecpg/preproc/parser.c
@@ -203,7 +203,9 @@ filtered_base_yylex(void)
 				base_yytext = cur_yytext;
 
 				/* Combine 3 tokens into 1 */
-				base_yylval.str = psprintf("%s UESCAPE %s", base_yylval.str, escstr);
+				base_yylval.str = make3_str(base_yylval.str,
+											" UESCAPE ",
+											escstr);
 				base_yylloc = loc_strdup(base_yylval.str);
 
 				/* Clear have_lookahead, thereby consuming all three tokens */
diff --git a/src/interfaces/ecpg/preproc/pgc.l b/src/interfaces/ecpg/preproc/pgc.l
@@ -641,26 +641,26 @@ cppline			{space}*#([^i][A-Za-z]*|{if}|{ifdef}|{ifndef}|{import})((\/\*[^*/]*\*+
 						case xb:
 							if (literalbuf[strspn(literalbuf, "01")] != '\0')
 								mmerror(PARSE_ERROR, ET_ERROR, "invalid bit string literal");
-							base_yylval.str = psprintf("b'%s'", literalbuf);
+							base_yylval.str = make3_str("b'", literalbuf, "'");
 							return BCONST;
 						case xh:
 							if (literalbuf[strspn(literalbuf, "0123456789abcdefABCDEF")] != '\0')
 								mmerror(PARSE_ERROR, ET_ERROR, "invalid hexadecimal string literal");
-							base_yylval.str = psprintf("x'%s'", literalbuf);
+							base_yylval.str = make3_str("x'", literalbuf, "'");
 							return XCONST;
 						case xq:
 							/* fallthrough */
 						case xqc:
-							base_yylval.str = psprintf("'%s'", literalbuf);
+							base_yylval.str = make3_str("'", literalbuf, "'");
 							return SCONST;
 						case xe:
-							base_yylval.str = psprintf("E'%s'", literalbuf);
+							base_yylval.str = make3_str("E'", literalbuf, "'");
 							return SCONST;
 						case xn:
-							base_yylval.str = psprintf("N'%s'", literalbuf);
+							base_yylval.str = make3_str("N'", literalbuf, "'");
 							return SCONST;
 						case xus:
-							base_yylval.str = psprintf("U&'%s'", literalbuf);
+							base_yylval.str = make3_str("U&'", literalbuf, "'");
 							return USCONST;
 						default:
 							mmfatal(PARSE_ERROR, "unhandled previous state in xqs\n");
@@ -724,7 +724,7 @@ cppline			{space}*#([^i][A-Za-z]*|{if}|{ifdef}|{ifndef}|{import})((\/\*[^*/]*\*+
 						free(dolqstart);
 						dolqstart = NULL;
 						BEGIN(SQL);
-						base_yylval.str = mm_strdup(literalbuf);
+						base_yylval.str = loc_strdup(literalbuf);
 						return SCONST;
 					}
 					else
@@ -778,12 +778,12 @@ cppline			{space}*#([^i][A-Za-z]*|{if}|{ifdef}|{ifndef}|{import})((\/\*[^*/]*\*+
 					 * PREPARE and EXECUTE IMMEDIATE, which can certainly be
 					 * longer than NAMEDATALEN.
 					 */
-					base_yylval.str = mm_strdup(literalbuf);
+					base_yylval.str = loc_strdup(literalbuf);
 					return CSTRING;
 				}
 <xdc>{xdstop}	{
 					BEGIN(state_before_str_start);
-					base_yylval.str = mm_strdup(literalbuf);
+					base_yylval.str = loc_strdup(literalbuf);
 					return CSTRING;
 				}
 <xui>{dquote}	{
@@ -795,7 +795,7 @@ cppline			{space}*#([^i][A-Za-z]*|{if}|{ifdef}|{ifndef}|{import})((\/\*[^*/]*\*+
 					 * The backend will truncate the identifier here. We do
 					 * not as it does not change the result.
 					 */
-					base_yylval.str = psprintf("U&\"%s\"", literalbuf);
+					base_yylval.str = make3_str("U&\"", literalbuf, "\"");
 					return UIDENT;
 				}
 <xd,xui>{xddouble} {
@@ -971,7 +971,7 @@ cppline			{space}*#([^i][A-Za-z]*|{if}|{ifdef}|{ifndef}|{import})((\/\*[^*/]*\*+
 						}
 					}
 
-					base_yylval.str = mm_strdup(yytext);
+					base_yylval.str = loc_strdup(yytext);
 					return Op;
 				}
 
@@ -990,7 +990,7 @@ cppline			{space}*#([^i][A-Za-z]*|{if}|{ifdef}|{ifndef}|{import})((\/\*[^*/]*\*+
 				}
 
 {ip}			{
-					base_yylval.str = mm_strdup(yytext);
+					base_yylval.str = loc_strdup(yytext);
 					return IP;
 				}
 }  /* <SQL> */
@@ -1003,7 +1003,7 @@ cppline			{space}*#([^i][A-Za-z]*|{if}|{ifdef}|{ifndef}|{import})((\/\*[^*/]*\*+
 					return process_integer_literal(yytext, &base_yylval, 16);
 				}
 {numeric}		{
-					base_yylval.str = mm_strdup(yytext);
+					base_yylval.str = loc_strdup(yytext);
 					return FCONST;
 				}
 {numericfail}	{
@@ -1012,7 +1012,7 @@ cppline			{space}*#([^i][A-Za-z]*|{if}|{ifdef}|{ifndef}|{import})((\/\*[^*/]*\*+
 					return process_integer_literal(yytext, &base_yylval, 10);
 				}
 {real}			{
-					base_yylval.str = mm_strdup(yytext);
+					base_yylval.str = loc_strdup(yytext);
 					return FCONST;
 				}
 {realfail}		{
@@ -1048,7 +1048,7 @@ cppline			{space}*#([^i][A-Za-z]*|{if}|{ifdef}|{ifndef}|{import})((\/\*[^*/]*\*+
 				}
 
 :{identifier}((("->"|\.){identifier})|(\[{array}\]))*	{
-					base_yylval.str = mm_strdup(yytext + 1);
+					base_yylval.str = loc_strdup(yytext + 1);
 					return CVARIABLE;
 				}
 
@@ -1085,7 +1085,7 @@ cppline			{space}*#([^i][A-Za-z]*|{if}|{ifdef}|{ifndef}|{import})((\/\*[^*/]*\*+
 						 * to do so; that's just another way that ecpg could
 						 * get out of step with the backend.
 						 */
-						base_yylval.str = mm_strdup(yytext);
+						base_yylval.str = loc_strdup(yytext);
 						return IDENT;
 					}
 				}
@@ -1124,7 +1124,7 @@ cppline			{space}*#([^i][A-Za-z]*|{if}|{ifdef}|{ifndef}|{import})((\/\*[^*/]*\*+
 					}
 					else
 					{
-						base_yylval.str = mm_strdup(yytext);
+						base_yylval.str = loc_strdup(yytext);
 						return CPP_LINE;
 					}
 				}
@@ -1136,12 +1136,12 @@ cppline			{space}*#([^i][A-Za-z]*|{if}|{ifdef}|{ifndef}|{import})((\/\*[^*/]*\*+
 					}
 					else
 					{
-						base_yylval.str = mm_strdup(yytext);
+						base_yylval.str = loc_strdup(yytext);
 						return CPP_LINE;
 					}
 				}
 <C,SQL>{cppline} {
-					base_yylval.str = mm_strdup(yytext);
+					base_yylval.str = loc_strdup(yytext);
 					return CPP_LINE;
 				}
 <C>{identifier}	{
@@ -1167,7 +1167,7 @@ cppline			{space}*#([^i][A-Za-z]*|{if}|{ifdef}|{ifndef}|{import})((\/\*[^*/]*\*+
 							return kwvalue;
 						else
 						{
-							base_yylval.str = mm_strdup(yytext);
+							base_yylval.str = loc_strdup(yytext);
 							return IDENT;
 						}
 					}
@@ -1685,7 +1685,7 @@ process_integer_literal(const char *token, YYSTYPE *lval, int base)
 	if (*endptr != '\0' || errno == ERANGE)
 	{
 		/* integer too large (or contains decimal pt), treat it as a float */
-		lval->str = mm_strdup(token);
+		lval->str = loc_strdup(token);
 		return FCONST;
 	}
 	lval->ival = val;

Original file line number	Diff line number	Diff line change
`@@ -641,26 +641,26 @@ cppline {space}#([^i][A-Za-z]\|{if}\|{ifdef}\|{ifndef}\|{import})((\/\[^/]\+`
`641`	`641`	`case xb:`
`642`	`642`	`if (literalbuf[strspn(literalbuf, "01")] != '\0')`
`643`	`643`	`mmerror(PARSE_ERROR, ET_ERROR, "invalid bit string literal");`
`644`		`- base_yylval.str = psprintf("b'%s'", literalbuf);`
	`644`	`+ base_yylval.str = make3_str("b'", literalbuf, "'");`
`645`	`645`	`return BCONST;`
`646`	`646`	`case xh:`
`647`	`647`	`if (literalbuf[strspn(literalbuf, "0123456789abcdefABCDEF")] != '\0')`
`648`	`648`	`mmerror(PARSE_ERROR, ET_ERROR, "invalid hexadecimal string literal");`
`649`		`- base_yylval.str = psprintf("x'%s'", literalbuf);`
	`649`	`+ base_yylval.str = make3_str("x'", literalbuf, "'");`
`650`	`650`	`return XCONST;`
`651`	`651`	`case xq:`
`652`	`652`	`/* fallthrough */`
`653`	`653`	`case xqc:`
`654`		`- base_yylval.str = psprintf("'%s'", literalbuf);`
	`654`	`+ base_yylval.str = make3_str("'", literalbuf, "'");`
`655`	`655`	`return SCONST;`
`656`	`656`	`case xe:`
`657`		`- base_yylval.str = psprintf("E'%s'", literalbuf);`
	`657`	`+ base_yylval.str = make3_str("E'", literalbuf, "'");`
`658`	`658`	`return SCONST;`
`659`	`659`	`case xn:`
`660`		`- base_yylval.str = psprintf("N'%s'", literalbuf);`
	`660`	`+ base_yylval.str = make3_str("N'", literalbuf, "'");`
`661`	`661`	`return SCONST;`
`662`	`662`	`case xus:`
`663`		`- base_yylval.str = psprintf("U&'%s'", literalbuf);`
	`663`	`+ base_yylval.str = make3_str("U&'", literalbuf, "'");`
`664`	`664`	`return USCONST;`
`665`	`665`	`default:`
`666`	`666`	`mmfatal(PARSE_ERROR, "unhandled previous state in xqs\n");`
`@@ -724,7 +724,7 @@ cppline {space}#([^i][A-Za-z]\|{if}\|{ifdef}\|{ifndef}\|{import})((\/\[^/]\+`
`724`	`724`	`free(dolqstart);`
`725`	`725`	`dolqstart = NULL;`
`726`	`726`	`BEGIN(SQL);`
`727`		`- base_yylval.str = mm_strdup(literalbuf);`
	`727`	`+ base_yylval.str = loc_strdup(literalbuf);`
`728`	`728`	`return SCONST;`
`729`	`729`	`}`
`730`	`730`	`else`
`@@ -778,12 +778,12 @@ cppline {space}#([^i][A-Za-z]\|{if}\|{ifdef}\|{ifndef}\|{import})((\/\[^/]\+`
`778`	`778`	`* PREPARE and EXECUTE IMMEDIATE, which can certainly be`
`779`	`779`	`* longer than NAMEDATALEN.`
`780`	`780`	`*/`
`781`		`- base_yylval.str = mm_strdup(literalbuf);`
	`781`	`+ base_yylval.str = loc_strdup(literalbuf);`
`782`	`782`	`return CSTRING;`
`783`	`783`	`}`
`784`	`784`	`<xdc>{xdstop} {`
`785`	`785`	`BEGIN(state_before_str_start);`
`786`		`- base_yylval.str = mm_strdup(literalbuf);`
	`786`	`+ base_yylval.str = loc_strdup(literalbuf);`
`787`	`787`	`return CSTRING;`
`788`	`788`	`}`
`789`	`789`	`<xui>{dquote} {`
`@@ -795,7 +795,7 @@ cppline {space}#([^i][A-Za-z]\|{if}\|{ifdef}\|{ifndef}\|{import})((\/\[^/]\+`
`795`	`795`	`* The backend will truncate the identifier here. We do`
`796`	`796`	`* not as it does not change the result.`
`797`	`797`	`*/`
`798`		`- base_yylval.str = psprintf("U&\"%s\"", literalbuf);`
	`798`	`+ base_yylval.str = make3_str("U&\"", literalbuf, "\"");`
`799`	`799`	`return UIDENT;`
`800`	`800`	`}`
`801`	`801`	`<xd,xui>{xddouble} {`
`@@ -971,7 +971,7 @@ cppline {space}#([^i][A-Za-z]\|{if}\|{ifdef}\|{ifndef}\|{import})((\/\[^/]\+`
`971`	`971`	`}`
`972`	`972`	`}`
`973`	`973`
`974`		`- base_yylval.str = mm_strdup(yytext);`
	`974`	`+ base_yylval.str = loc_strdup(yytext);`
`975`	`975`	`return Op;`
`976`	`976`	`}`
`977`	`977`
`@@ -990,7 +990,7 @@ cppline {space}#([^i][A-Za-z]\|{if}\|{ifdef}\|{ifndef}\|{import})((\/\[^/]\+`
`990`	`990`	`}`
`991`	`991`
`992`	`992`	`{ip} {`
`993`		`- base_yylval.str = mm_strdup(yytext);`
	`993`	`+ base_yylval.str = loc_strdup(yytext);`
`994`	`994`	`return IP;`
`995`	`995`	`}`
`996`	`996`	`} /* <SQL> */`
`@@ -1003,7 +1003,7 @@ cppline {space}#([^i][A-Za-z]\|{if}\|{ifdef}\|{ifndef}\|{import})((\/\[^/]\+`
`1003`	`1003`	`return process_integer_literal(yytext, &base_yylval, 16);`
`1004`	`1004`	`}`
`1005`	`1005`	`{numeric} {`
`1006`		`- base_yylval.str = mm_strdup(yytext);`
	`1006`	`+ base_yylval.str = loc_strdup(yytext);`
`1007`	`1007`	`return FCONST;`
`1008`	`1008`	`}`
`1009`	`1009`	`{numericfail} {`
`@@ -1012,7 +1012,7 @@ cppline {space}#([^i][A-Za-z]\|{if}\|{ifdef}\|{ifndef}\|{import})((\/\[^/]\+`
`1012`	`1012`	`return process_integer_literal(yytext, &base_yylval, 10);`
`1013`	`1013`	`}`
`1014`	`1014`	`{real} {`
`1015`		`- base_yylval.str = mm_strdup(yytext);`
	`1015`	`+ base_yylval.str = loc_strdup(yytext);`
`1016`	`1016`	`return FCONST;`
`1017`	`1017`	`}`
`1018`	`1018`	`{realfail} {`
`@@ -1048,7 +1048,7 @@ cppline {space}#([^i][A-Za-z]\|{if}\|{ifdef}\|{ifndef}\|{import})((\/\[^/]\+`
`1048`	`1048`	`}`
`1049`	`1049`
`1050`	`1050`	`:{identifier}((("->"\|\.){identifier})\|(\[{array}\]))* {`
`1051`		`- base_yylval.str = mm_strdup(yytext + 1);`
	`1051`	`+ base_yylval.str = loc_strdup(yytext + 1);`
`1052`	`1052`	`return CVARIABLE;`
`1053`	`1053`	`}`
`1054`	`1054`
`@@ -1085,7 +1085,7 @@ cppline {space}#([^i][A-Za-z]\|{if}\|{ifdef}\|{ifndef}\|{import})((\/\[^/]\+`
`1085`	`1085`	`* to do so; that's just another way that ecpg could`
`1086`	`1086`	`* get out of step with the backend.`
`1087`	`1087`	`*/`
`1088`		`- base_yylval.str = mm_strdup(yytext);`
	`1088`	`+ base_yylval.str = loc_strdup(yytext);`
`1089`	`1089`	`return IDENT;`
`1090`	`1090`	`}`
`1091`	`1091`	`}`
`@@ -1124,7 +1124,7 @@ cppline {space}#([^i][A-Za-z]\|{if}\|{ifdef}\|{ifndef}\|{import})((\/\[^/]\+`
`1124`	`1124`	`}`
`1125`	`1125`	`else`
`1126`	`1126`	`{`
`1127`		`- base_yylval.str = mm_strdup(yytext);`
	`1127`	`+ base_yylval.str = loc_strdup(yytext);`
`1128`	`1128`	`return CPP_LINE;`
`1129`	`1129`	`}`
`1130`	`1130`	`}`
`@@ -1136,12 +1136,12 @@ cppline {space}#([^i][A-Za-z]\|{if}\|{ifdef}\|{ifndef}\|{import})((\/\[^/]\+`
`1136`	`1136`	`}`
`1137`	`1137`	`else`
`1138`	`1138`	`{`
`1139`		`- base_yylval.str = mm_strdup(yytext);`
	`1139`	`+ base_yylval.str = loc_strdup(yytext);`
`1140`	`1140`	`return CPP_LINE;`
`1141`	`1141`	`}`
`1142`	`1142`	`}`
`1143`	`1143`	`<C,SQL>{cppline} {`
`1144`		`- base_yylval.str = mm_strdup(yytext);`
	`1144`	`+ base_yylval.str = loc_strdup(yytext);`
`1145`	`1145`	`return CPP_LINE;`
`1146`	`1146`	`}`
`1147`	`1147`	`<C>{identifier} {`
`@@ -1167,7 +1167,7 @@ cppline {space}#([^i][A-Za-z]\|{if}\|{ifdef}\|{ifndef}\|{import})((\/\[^/]\+`
`1167`	`1167`	`return kwvalue;`
`1168`	`1168`	`else`
`1169`	`1169`	`{`
`1170`		`- base_yylval.str = mm_strdup(yytext);`
	`1170`	`+ base_yylval.str = loc_strdup(yytext);`
`1171`	`1171`	`return IDENT;`
`1172`	`1172`	`}`
`1173`	`1173`	`}`
`@@ -1685,7 +1685,7 @@ process_integer_literal(const char token, YYSTYPE lval, int base)`
`1685`	`1685`	`if (*endptr != '\0' \|\| errno == ERANGE)`
`1686`	`1686`	`{`
`1687`	`1687`	`/* integer too large (or contains decimal pt), treat it as a float */`
`1688`		`- lval->str = mm_strdup(token);`
	`1688`	`+ lval->str = loc_strdup(token);`
`1689`	`1689`	`return FCONST;`
`1690`	`1690`	`}`
`1691`	`1691`	`lval->ival = val;`