Skip to content

P
Postgres FD Implementation
Commit 1066dbfb authored by Michael Meskes's avatar Michael Meskes
Browse files
Options

There is no need to have to identical functions in ecpg thus removing one of them.

parent fdf2dbda
Hide whitespace changes
Inline Side-by-side
Showing with 371 additions and 381 deletions
src/interfaces/ecpg/preproc/descriptor.c
View file @ 1066dbfb
......@@ -188,7 +188,7 @@ output_get_descr(char *desc_name, char *index)
break;
}
fprintf(yyout, "%s,", get_dtype(results->value));
ECPGdump_a_type(yyout, v->name, v->type, v->brace_level, NULL, NULL, -1, NULL, NULL, make_str("0"), NULL, NULL);
ECPGdump_a_type(yyout, v->name, v->type, v->brace_level, NULL, NULL, -1, NULL, NULL, mm_strdup("0"), NULL, NULL);
}
drop_assignments();
fputs("ECPGd_EODT);\n", yyout);
......@@ -293,7 +293,7 @@ output_set_descr(char *desc_name, char *index)
case ECPGd_length:
case ECPGd_type:
fprintf(yyout, "%s,", get_dtype(results->value));
ECPGdump_a_type(yyout, v->name, v->type, v->brace_level, NULL, NULL, -1, NULL, NULL, make_str("0"), NULL, NULL);
ECPGdump_a_type(yyout, v->name, v->type, v->brace_level, NULL, NULL, -1, NULL, NULL, mm_strdup("0"), NULL, NULL);
break;
default:
......
src/interfaces/ecpg/preproc/ecpg.addons
View file @ 1066dbfb
......@@ -41,7 +41,7 @@ ECPG: stmtPrepareStmt block
if ($1.type == NULL || strlen($1.type) == 0)
output_prepare_statement($1.name, $1.stmt);
else
output_statement(cat_str(5, make_str("prepare"), $1.name, $1.type, make_str("as"), $1.stmt), 0, ECPGst_normal);
output_statement(cat_str(5, mm_strdup("prepare"), $1.name, $1.type, mm_strdup("as"), $1.stmt), 0, ECPGst_normal);
}
ECPG: stmtTransactionStmt block
{
......@@ -212,21 +212,21 @@ ECPG: var_valueNumericOnly addon
if ($1[0] == '$')
{
free($1);
$1 = make_str("$0");
$1 = mm_strdup("$0");
}
ECPG: fetch_argscursor_name addon
add_additional_variables($1, false);
if ($1[0] == ':')
{
free($1);
$1 = make_str("$0");
$1 = mm_strdup("$0");
}
ECPG: fetch_argsfrom_incursor_name addon
add_additional_variables($2, false);
if ($2[0] == ':')
{
free($2);
$2 = make_str("$0");
$2 = mm_strdup("$0");
}
ECPG: fetch_argsNEXTopt_from_incursor_name addon
ECPG: fetch_argsPRIORopt_from_incursor_name addon
......@@ -237,19 +237,19 @@ ECPG: fetch_argsALLopt_from_incursor_name addon
if ($3[0] == ':')
{
free($3);
$3 = make_str("$0");
$3 = mm_strdup("$0");
}
ECPG: fetch_argsSignedIconstopt_from_incursor_name addon
add_additional_variables($3, false);
if ($3[0] == ':')
{
free($3);
$3 = make_str("$0");
$3 = mm_strdup("$0");
}
if ($1[0] == '$')
{
free($1);
$1 = make_str("$0");
$1 = mm_strdup("$0");
}
ECPG: fetch_argsFORWARDALLopt_from_incursor_name addon
ECPG: fetch_argsBACKWARDALLopt_from_incursor_name addon
......@@ -257,7 +257,7 @@ ECPG: fetch_argsBACKWARDALLopt_from_incursor_name addon
if ($4[0] == ':')
{
free($4);
$4 = make_str("$0");
$4 = mm_strdup("$0");
}
ECPG: fetch_argsABSOLUTE_PSignedIconstopt_from_incursor_name addon
ECPG: fetch_argsRELATIVE_PSignedIconstopt_from_incursor_name addon
......@@ -267,12 +267,12 @@ ECPG: fetch_argsBACKWARDSignedIconstopt_from_incursor_name addon
if ($4[0] == ':')
{
free($4);
$4 = make_str("$0");
$4 = mm_strdup("$0");
}
if ($2[0] == '$')
{
free($2);
$2 = make_str("$0");
$2 = mm_strdup("$0");
}
ECPG: cursor_namename rule
| char_civar
......@@ -287,7 +287,7 @@ ECPG: PrepareStmtPREPAREprepared_nameprep_type_clauseASPreparableStmt block
{
$$.name = $2;
$$.type = $3;
$$.stmt = cat_str(3, make_str("\""), $5, make_str("\""));
$$.stmt = cat_str(3, mm_strdup("\""), $5, mm_strdup("\""));
}
| PREPARE prepared_name FROM execstring
{
......@@ -300,7 +300,7 @@ ECPG: ExecuteStmtEXECUTEprepared_nameexecute_param_clauseexecute_rest block
ECPG: DeclareCursorStmtDECLAREcursor_namecursor_optionsCURSORopt_holdFORSelectStmt block
{
struct cursor *ptr, *this;
char *cursor_marker = $2[0] == ':' ? make_str("$0") : mm_strdup($2);
char *cursor_marker = $2[0] == ':' ? mm_strdup("$0") : mm_strdup($2);
char *comment, *c1, *c2;
int (* strcmp_fn)(const char *, const char *) = ($2[0] == ':' ? strcmp : pg_strcasecmp);
......@@ -322,7 +322,7 @@ ECPG: DeclareCursorStmtDECLAREcursor_namecursor_optionsCURSORopt_holdFORSelectSt
this->function = (current_function ? mm_strdup(current_function) : NULL);
this->connection = connection;
this->opened = false;
this->command = cat_str(7, make_str("declare"), cursor_marker, $3, make_str("cursor"), $5, make_str("for"), $7);
this->command = cat_str(7, mm_strdup("declare"), cursor_marker, $3, mm_strdup("cursor"), $5, mm_strdup("for"), $7);
this->argsinsert = argsinsert;
this->argsinsert_oos = NULL;
this->argsresult = argsresult;
......@@ -337,31 +337,31 @@ ECPG: DeclareCursorStmtDECLAREcursor_namecursor_optionsCURSORopt_holdFORSelectSt
c2[0] = '.';
c2[1] = '.';
}
comment = cat_str(3, make_str("/*"), c1, make_str("*/"));
comment = cat_str(3, mm_strdup("/*"), c1, mm_strdup("*/"));
if ((braces_open > 0) && INFORMIX_MODE) /* we're in a function */
$$ = cat_str(3, adjust_outofscope_cursor_vars(this),
make_str("ECPG_informix_reset_sqlca();"),
mm_strdup("ECPG_informix_reset_sqlca();"),
comment);
else
$$ = cat2_str(adjust_outofscope_cursor_vars(this), comment);
}
ECPG: ClosePortalStmtCLOSEcursor_name block
{
char *cursor_marker = $2[0] == ':' ? make_str("$0") : $2;
$$ = cat2_str(make_str("close"), cursor_marker);
char *cursor_marker = $2[0] == ':' ? mm_strdup("$0") : $2;
$$ = cat2_str(mm_strdup("close"), cursor_marker);
}
ECPG: opt_hold block
{
if (compat == ECPG_COMPAT_INFORMIX_SE && autocommit)
$$ = make_str("with hold");
$$ = mm_strdup("with hold");
else
$$ = EMPTY;
}
ECPG: into_clauseINTOOptTempTableName block
{
FoundInto = 1;
$$= cat2_str(make_str("into"), $2);
$$= cat2_str(mm_strdup("into"), $2);
}
| ecpg_into { $$ = EMPTY; }
ECPG: table_refselect_with_parens addon
......@@ -369,16 +369,16 @@ ECPG: table_refselect_with_parens addon
ECPG: TypenameSimpleTypenameopt_array_bounds block
{ $$ = cat2_str($1, $2.str); }
ECPG: TypenameSETOFSimpleTypenameopt_array_bounds block
{ $$ = cat_str(3, make_str("setof"), $2, $3.str); }
{ $$ = cat_str(3, mm_strdup("setof"), $2, $3.str); }
ECPG: opt_array_boundsopt_array_bounds'['']' block
{
$$.index1 = $1.index1;
$$.index2 = $1.index2;
if (strcmp($$.index1, "-1") == 0)
$$.index1 = make_str("0");
$$.index1 = mm_strdup("0");
else if (strcmp($1.index2, "-1") == 0)
$$.index2 = make_str("0");
$$.str = cat_str(2, $1.str, make_str("[]"));
$$.index2 = mm_strdup("0");
$$.str = cat_str(2, $1.str, mm_strdup("[]"));
}
| opt_array_bounds '[' Iresult ']'
{
......@@ -388,12 +388,12 @@ ECPG: opt_array_boundsopt_array_bounds'['']' block
$$.index1 = strdup($3);
else if (strcmp($1.index2, "-1") == 0)
$$.index2 = strdup($3);
$$.str = cat_str(4, $1.str, make_str("["), $3, make_str("]"));
$$.str = cat_str(4, $1.str, mm_strdup("["), $3, mm_strdup("]"));
}
ECPG: opt_array_bounds
{
$$.index1 = make_str("-1");
$$.index2 = make_str("-1");
$$.index1 = mm_strdup("-1");
$$.index2 = mm_strdup("-1");
$$.str= EMPTY;
}
ECPG: IconstICONST block
......@@ -404,8 +404,8 @@ ECPG: AexprConstNULL_P rule
ECPG: ColIdcol_name_keyword rule
| ECPGKeywords { $$ = $1; }
| ECPGCKeywords { $$ = $1; }
| CHAR_P { $$ = make_str("char"); }
| VALUES { $$ = make_str("values"); }
| CHAR_P { $$ = mm_strdup("char"); }
| VALUES { $$ = mm_strdup("values"); }
ECPG: type_function_nametype_func_name_keyword rule
| ECPGKeywords { $$ = $1; }
| ECPGTypeName { $$ = $1; }
......@@ -418,60 +418,60 @@ ECPG: VariableShowStmtSHOWALL block
ECPG: FetchStmtMOVEfetch_args rule
| FETCH fetch_args ecpg_fetch_into
{
$$ = cat2_str(make_str("fetch"), $2);
$$ = cat2_str(mm_strdup("fetch"), $2);
}
| FETCH FORWARD cursor_name opt_ecpg_fetch_into
{
char *cursor_marker = $3[0] == ':' ? make_str("$0") : $3;
char *cursor_marker = $3[0] == ':' ? mm_strdup("$0") : $3;
add_additional_variables($3, false);
$$ = cat_str(2, make_str("fetch forward"), cursor_marker);
$$ = cat_str(2, mm_strdup("fetch forward"), cursor_marker);
}
| FETCH FORWARD from_in cursor_name opt_ecpg_fetch_into
{
char *cursor_marker = $4[0] == ':' ? make_str("$0") : $4;
char *cursor_marker = $4[0] == ':' ? mm_strdup("$0") : $4;
add_additional_variables($4, false);
$$ = cat_str(2, make_str("fetch forward from"), cursor_marker);
$$ = cat_str(2, mm_strdup("fetch forward from"), cursor_marker);
}
| FETCH BACKWARD cursor_name opt_ecpg_fetch_into
{
char *cursor_marker = $3[0] == ':' ? make_str("$0") : $3;
char *cursor_marker = $3[0] == ':' ? mm_strdup("$0") : $3;
add_additional_variables($3, false);
$$ = cat_str(2, make_str("fetch backward"), cursor_marker);
$$ = cat_str(2, mm_strdup("fetch backward"), cursor_marker);
}
| FETCH BACKWARD from_in cursor_name opt_ecpg_fetch_into
{
char *cursor_marker = $4[0] == ':' ? make_str("$0") : $4;
char *cursor_marker = $4[0] == ':' ? mm_strdup("$0") : $4;
add_additional_variables($4, false);
$$ = cat_str(2, make_str("fetch backward from"), cursor_marker);
$$ = cat_str(2, mm_strdup("fetch backward from"), cursor_marker);
}
| MOVE FORWARD cursor_name
{
char *cursor_marker = $3[0] == ':' ? make_str("$0") : $3;
char *cursor_marker = $3[0] == ':' ? mm_strdup("$0") : $3;
add_additional_variables($3, false);
$$ = cat_str(2, make_str("move forward"), cursor_marker);
$$ = cat_str(2, mm_strdup("move forward"), cursor_marker);
}
| MOVE FORWARD from_in cursor_name
{
char *cursor_marker = $4[0] == ':' ? make_str("$0") : $4;
char *cursor_marker = $4[0] == ':' ? mm_strdup("$0") : $4;
add_additional_variables($4, false);
$$ = cat_str(2, make_str("move forward from"), cursor_marker);
$$ = cat_str(2, mm_strdup("move forward from"), cursor_marker);
}
| MOVE BACKWARD cursor_name
{
char *cursor_marker = $3[0] == ':' ? make_str("$0") : $3;
char *cursor_marker = $3[0] == ':' ? mm_strdup("$0") : $3;
add_additional_variables($3, false);
$$ = cat_str(2, make_str("move backward"), cursor_marker);
$$ = cat_str(2, mm_strdup("move backward"), cursor_marker);
}
| MOVE BACKWARD from_in cursor_name
{
char *cursor_marker = $4[0] == ':' ? make_str("$0") : $4;
char *cursor_marker = $4[0] == ':' ? mm_strdup("$0") : $4;
add_additional_variables($4, false);
$$ = cat_str(2, make_str("move backward from"), cursor_marker);
$$ = cat_str(2, mm_strdup("move backward from"), cursor_marker);
}
ECPG: limit_clauseLIMITselect_limit_value','select_offset_value block
{
mmerror(PARSE_ERROR, ET_WARNING, "no longer supported LIMIT #,# syntax passed to server");
$$ = cat_str(4, make_str("limit"), $2, make_str(","), $4);
$$ = cat_str(4, mm_strdup("limit"), $2, mm_strdup(","), $4);
}
ECPG: SignedIconstIconst rule
| civar { $$ = $1; }
src/interfaces/ecpg/preproc/ecpg.header
View file @ 1066dbfb
......@@ -148,15 +148,6 @@ cat_str(int count, ...)
return(res_str);
}
char *
make_str(const char *str)
{
char * res_str = (char *)mm_alloc(strlen(str) + 1);
strcpy(res_str, str);
return res_str;
}
static char *
make2_str(char *str1, char *str2)
{
......@@ -219,7 +210,7 @@ create_questionmarks(char *name, bool array)
for (; count > 0; count --)
{
sprintf(pacounter_buffer, "$%d", pacounter++);
result = cat_str(3, result, mm_strdup(pacounter_buffer), make_str(" , "));
result = cat_str(3, result, mm_strdup(pacounter_buffer), mm_strdup(" , "));
}
/* removed the trailing " ," */
......@@ -242,7 +233,7 @@ adjust_outofscope_cursor_vars(struct cursor *cur)
* instead of the variable. Do it only for local variables, not for globals.
*/
char *result = make_str("");
char *result = mm_strdup("");
int insert;
for (insert = 1; insert >= 0; insert--)
......@@ -277,12 +268,12 @@ adjust_outofscope_cursor_vars(struct cursor *cur)
}
else if ((ptr->variable->type->type != ECPGt_varchar && ptr->variable->type->type != ECPGt_char && ptr->variable->type->type != ECPGt_unsigned_char && ptr->variable->type->type != ECPGt_string) && atoi(ptr->variable->type->size) > 1)
{
newvar = new_variable(cat_str(4, make_str("("), mm_strdup(ecpg_type_name(ptr->variable->type->u.element->type)), make_str(" *)(ECPGget_var("), mm_strdup(temp)), ECPGmake_array_type(ECPGmake_simple_type(ptr->variable->type->u.element->type, make_str("1"), ptr->variable->type->u.element->counter), ptr->variable->type->size), 0);
newvar = new_variable(cat_str(4, mm_strdup("("), mm_strdup(ecpg_type_name(ptr->variable->type->u.element->type)), mm_strdup(" *)(ECPGget_var("), mm_strdup(temp)), ECPGmake_array_type(ECPGmake_simple_type(ptr->variable->type->u.element->type, mm_strdup("1"), ptr->variable->type->u.element->counter), ptr->variable->type->size), 0);
sprintf(temp, "%d, (", ecpg_internal_var++);
}
else if ((ptr->variable->type->type == ECPGt_varchar || ptr->variable->type->type == ECPGt_char || ptr->variable->type->type == ECPGt_unsigned_char || ptr->variable->type->type == ECPGt_string) && atoi(ptr->variable->type->size) > 1)
{
newvar = new_variable(cat_str(4, make_str("("), mm_strdup(ecpg_type_name(ptr->variable->type->type)), make_str(" *)(ECPGget_var("), mm_strdup(temp)), ECPGmake_simple_type(ptr->variable->type->type, ptr->variable->type->size, ptr->variable->type->counter), 0);
newvar = new_variable(cat_str(4, mm_strdup("("), mm_strdup(ecpg_type_name(ptr->variable->type->type)), mm_strdup(" *)(ECPGget_var("), mm_strdup(temp)), ECPGmake_simple_type(ptr->variable->type->type, ptr->variable->type->size, ptr->variable->type->counter), 0);
if (ptr->variable->type->type == ECPGt_varchar)
sprintf(temp, "%d, &(", ecpg_internal_var++);
else
......@@ -291,7 +282,7 @@ adjust_outofscope_cursor_vars(struct cursor *cur)
else if (ptr->variable->type->type == ECPGt_struct || ptr->variable->type->type == ECPGt_union)
{
sprintf(temp, "%d)))", ecpg_internal_var);
newvar = new_variable(cat_str(4, make_str("(*("), mm_strdup(ptr->variable->type->type_name), make_str(" *)(ECPGget_var("), mm_strdup(temp)), ECPGmake_struct_type(ptr->variable->type->u.members, ptr->variable->type->type, ptr->variable->type->type_name, ptr->variable->type->struct_sizeof), 0);
newvar = new_variable(cat_str(4, mm_strdup("(*("), mm_strdup(ptr->variable->type->type_name), mm_strdup(" *)(ECPGget_var("), mm_strdup(temp)), ECPGmake_struct_type(ptr->variable->type->u.members, ptr->variable->type->type, ptr->variable->type->type_name, ptr->variable->type->struct_sizeof), 0);
sprintf(temp, "%d, &(", ecpg_internal_var++);
}
else if (ptr->variable->type->type == ECPGt_array)
......@@ -299,24 +290,24 @@ adjust_outofscope_cursor_vars(struct cursor *cur)
if (ptr->variable->type->u.element->type == ECPGt_struct || ptr->variable->type->u.element->type == ECPGt_union)
{
sprintf(temp, "%d)))", ecpg_internal_var);
newvar = new_variable(cat_str(4, make_str("(*("), mm_strdup(ptr->variable->type->u.element->type_name), make_str(" *)(ECPGget_var("), mm_strdup(temp)), ECPGmake_struct_type(ptr->variable->type->u.element->u.members, ptr->variable->type->u.element->type, ptr->variable->type->u.element->type_name, ptr->variable->type->u.element->struct_sizeof), 0);
newvar = new_variable(cat_str(4, mm_strdup("(*("), mm_strdup(ptr->variable->type->u.element->type_name), mm_strdup(" *)(ECPGget_var("), mm_strdup(temp)), ECPGmake_struct_type(ptr->variable->type->u.element->u.members, ptr->variable->type->u.element->type, ptr->variable->type->u.element->type_name, ptr->variable->type->u.element->struct_sizeof), 0);
sprintf(temp, "%d, (", ecpg_internal_var++);
}
else
{
newvar = new_variable(cat_str(4, make_str("("), mm_strdup(ecpg_type_name(ptr->variable->type->type)), make_str(" *)(ECPGget_var("), mm_strdup(temp)), ECPGmake_array_type(ECPGmake_simple_type(ptr->variable->type->u.element->type, ptr->variable->type->u.element->size, ptr->variable->type->u.element->counter), ptr->variable->type->size), 0);
newvar = new_variable(cat_str(4, mm_strdup("("), mm_strdup(ecpg_type_name(ptr->variable->type->type)), mm_strdup(" *)(ECPGget_var("), mm_strdup(temp)), ECPGmake_array_type(ECPGmake_simple_type(ptr->variable->type->u.element->type, ptr->variable->type->u.element->size, ptr->variable->type->u.element->counter), ptr->variable->type->size), 0);
sprintf(temp, "%d, &(", ecpg_internal_var++);
}
}
else
{
newvar = new_variable(cat_str(4, make_str("*("), mm_strdup(ecpg_type_name(ptr->variable->type->type)), make_str(" *)(ECPGget_var("), mm_strdup(temp)), ECPGmake_simple_type(ptr->variable->type->type, ptr->variable->type->size, ptr->variable->type->counter), 0);
newvar = new_variable(cat_str(4, mm_strdup("*("), mm_strdup(ecpg_type_name(ptr->variable->type->type)), mm_strdup(" *)(ECPGget_var("), mm_strdup(temp)), ECPGmake_simple_type(ptr->variable->type->type, ptr->variable->type->size, ptr->variable->type->counter), 0);
sprintf(temp, "%d, &(", ecpg_internal_var++);
}
/* create call to "ECPGset_var(<counter>, <pointer>. <line number>)" */
if (!skip_set_var)
result = cat_str(5, result, make_str("ECPGset_var("), mm_strdup(temp), mm_strdup(original_var), make_str("), __LINE__);\n"));
result = cat_str(5, result, mm_strdup("ECPGset_var("), mm_strdup(temp), mm_strdup(original_var), mm_strdup("), __LINE__);\n"));
/* now the indicator if there is one and it's not a global variable */
if ((ptr->indicator->type->type == ECPGt_NO_INDICATOR) || (ptr->indicator->brace_level == 0))
......@@ -332,7 +323,7 @@ adjust_outofscope_cursor_vars(struct cursor *cur)
if (ptr->indicator->type->type == ECPGt_struct || ptr->indicator->type->type == ECPGt_union)
{
sprintf(temp, "%d)))", ecpg_internal_var);
newind = new_variable(cat_str(4, make_str("(*("), mm_strdup(ptr->indicator->type->type_name), make_str(" *)(ECPGget_var("), mm_strdup(temp)), ECPGmake_struct_type(ptr->indicator->type->u.members, ptr->indicator->type->type, ptr->indicator->type->type_name, ptr->indicator->type->struct_sizeof), 0);
newind = new_variable(cat_str(4, mm_strdup("(*("), mm_strdup(ptr->indicator->type->type_name), mm_strdup(" *)(ECPGget_var("), mm_strdup(temp)), ECPGmake_struct_type(ptr->indicator->type->u.members, ptr->indicator->type->type, ptr->indicator->type->type_name, ptr->indicator->type->struct_sizeof), 0);
sprintf(temp, "%d, &(", ecpg_internal_var++);
}
else if (ptr->indicator->type->type == ECPGt_array)
......@@ -340,28 +331,28 @@ adjust_outofscope_cursor_vars(struct cursor *cur)
if (ptr->indicator->type->u.element->type == ECPGt_struct || ptr->indicator->type->u.element->type == ECPGt_union)
{
sprintf(temp, "%d)))", ecpg_internal_var);
newind = new_variable(cat_str(4, make_str("(*("), mm_strdup(ptr->indicator->type->u.element->type_name), make_str(" *)(ECPGget_var("), mm_strdup(temp)), ECPGmake_struct_type(ptr->indicator->type->u.element->u.members, ptr->indicator->type->u.element->type, ptr->indicator->type->u.element->type_name, ptr->indicator->type->u.element->struct_sizeof), 0);
newind = new_variable(cat_str(4, mm_strdup("(*("), mm_strdup(ptr->indicator->type->u.element->type_name), mm_strdup(" *)(ECPGget_var("), mm_strdup(temp)), ECPGmake_struct_type(ptr->indicator->type->u.element->u.members, ptr->indicator->type->u.element->type, ptr->indicator->type->u.element->type_name, ptr->indicator->type->u.element->struct_sizeof), 0);
sprintf(temp, "%d, (", ecpg_internal_var++);
}
else
{
newind = new_variable(cat_str(4, make_str("("), mm_strdup(ecpg_type_name(ptr->indicator->type->u.element->type)), make_str(" *)(ECPGget_var("), mm_strdup(temp)), ECPGmake_array_type(ECPGmake_simple_type(ptr->indicator->type->u.element->type, ptr->indicator->type->u.element->size, ptr->indicator->type->u.element->counter), ptr->indicator->type->size), 0);
newind = new_variable(cat_str(4, mm_strdup("("), mm_strdup(ecpg_type_name(ptr->indicator->type->u.element->type)), mm_strdup(" *)(ECPGget_var("), mm_strdup(temp)), ECPGmake_array_type(ECPGmake_simple_type(ptr->indicator->type->u.element->type, ptr->indicator->type->u.element->size, ptr->indicator->type->u.element->counter), ptr->indicator->type->size), 0);
sprintf(temp, "%d, &(", ecpg_internal_var++);
}
}
else if (atoi(ptr->indicator->type->size) > 1)
{
newind = new_variable(cat_str(4, make_str("("), mm_strdup(ecpg_type_name(ptr->indicator->type->type)), make_str(" *)(ECPGget_var("), mm_strdup(temp)), ECPGmake_simple_type(ptr->indicator->type->type, ptr->indicator->type->size, ptr->variable->type->counter), 0);
newind = new_variable(cat_str(4, mm_strdup("("), mm_strdup(ecpg_type_name(ptr->indicator->type->type)), mm_strdup(" *)(ECPGget_var("), mm_strdup(temp)), ECPGmake_simple_type(ptr->indicator->type->type, ptr->indicator->type->size, ptr->variable->type->counter), 0);
sprintf(temp, "%d, (", ecpg_internal_var++);
}
else
{
newind = new_variable(cat_str(4, make_str("*("), mm_strdup(ecpg_type_name(ptr->indicator->type->type)), make_str(" *)(ECPGget_var("), mm_strdup(temp)), ECPGmake_simple_type(ptr->indicator->type->type, ptr->indicator->type->size, ptr->variable->type->counter), 0);
newind = new_variable(cat_str(4, mm_strdup("*("), mm_strdup(ecpg_type_name(ptr->indicator->type->type)), mm_strdup(" *)(ECPGget_var("), mm_strdup(temp)), ECPGmake_simple_type(ptr->indicator->type->type, ptr->indicator->type->size, ptr->variable->type->counter), 0);
sprintf(temp, "%d, &(", ecpg_internal_var++);
}
/* create call to "ECPGset_var(<counter>, <pointer>. <line number>)" */
result = cat_str(5, result, make_str("ECPGset_var("), mm_strdup(temp), mm_strdup(original_var), make_str("), __LINE__);\n"));
result = cat_str(5, result, mm_strdup("ECPGset_var("), mm_strdup(temp), mm_strdup(original_var), mm_strdup("), __LINE__);\n"));
}
add_variable_to_tail(&newlist, newvar, newind);
......
src/interfaces/ecpg/preproc/ecpg.trailer
View file @ 1066dbfb
......@@ -34,7 +34,7 @@ CreateAsStmt: CREATE OptTemp TABLE create_as_target AS {FoundInto = 0;} SelectSt
if (FoundInto == 1)
mmerror(PARSE_ERROR, ET_ERROR, "CREATE TABLE AS cannot specify INTO");
$$ = cat_str(6, make_str("create"), $2, make_str("table"), $4, make_str("as"), $7);
$$ = cat_str(6, mm_strdup("create"), $2, mm_strdup("table"), $4, mm_strdup("as"), $7);
}
;
......@@ -55,14 +55,14 @@ at: AT connection_object
* the exec sql connect statement: connect to the given database
*/
ECPGConnect: SQL_CONNECT TO connection_target opt_connection_name opt_user
{ $$ = cat_str(5, $3, make_str(","), $5, make_str(","), $4); }
{ $$ = cat_str(5, $3, mm_strdup(","), $5, mm_strdup(","), $4); }
| SQL_CONNECT TO DEFAULT
{ $$ = make_str("NULL, NULL, NULL, \"DEFAULT\""); }
{ $$ = mm_strdup("NULL, NULL, NULL, \"DEFAULT\""); }
/* also allow ORACLE syntax */
| SQL_CONNECT ora_user
{ $$ = cat_str(3, make_str("NULL,"), $2, make_str(", NULL")); }
{ $$ = cat_str(3, mm_strdup("NULL,"), $2, mm_strdup(", NULL")); }
| DATABASE connection_target
{ $$ = cat2_str($2, make_str(", NULL, NULL, NULL")); }
{ $$ = cat2_str($2, mm_strdup(", NULL, NULL, NULL")); }
;
connection_target: opt_database_name opt_server opt_port
......@@ -75,7 +75,7 @@ connection_target: opt_database_name opt_server opt_port
if ($1[0] == '\"')
$$ = $1;
else
$$ = make3_str(make_str("\""), make3_str($1, $2, $3), make_str("\""));
$$ = make3_str(mm_strdup("\""), make3_str($1, $2, $3), mm_strdup("\""));
}
| db_prefix ':' server opt_port '/' opt_database_name opt_options
{
......@@ -91,7 +91,7 @@ connection_target: opt_database_name opt_server opt_port
strncmp($3 + strlen("//"), "127.0.0.1", strlen("127.0.0.1")) != 0)
mmerror(PARSE_ERROR, ET_ERROR, "Unix-domain sockets only work on \"localhost\" but not on \"%s\"", $3 + strlen("//"));
$$ = make3_str(make3_str(make_str("\""), $1, make_str(":")), $3, make3_str(make3_str($4, make_str("/"), $6), $7, make_str("\"")));
$$ = make3_str(make3_str(mm_strdup("\""), $1, mm_strdup(":")), $3, make3_str(make3_str($4, mm_strdup("/"), $6), $7, mm_strdup("\"")));
}
| char_variable
{
......@@ -120,7 +120,7 @@ db_prefix: ecpg_ident cvariable
if (strcmp($1, "tcp") != 0 && strcmp($1, "unix") != 0)
mmerror(PARSE_ERROR, ET_ERROR, "invalid connection type: %s", $1);
$$ = make3_str($1, make_str(":"), $2);
$$ = make3_str($1, mm_strdup(":"), $2);
}
;
......@@ -138,30 +138,30 @@ opt_server: server { $$ = $1; }
;
server_name: ColId { $$ = $1; }
| ColId '.' server_name { $$ = make3_str($1, make_str("."), $3); }
| ColId '.' server_name { $$ = make3_str($1, mm_strdup("."), $3); }
| IP { $$ = make_name(); }
;
opt_port: ':' Iconst { $$ = make2_str(make_str(":"), $2); }
opt_port: ':' Iconst { $$ = make2_str(mm_strdup(":"), $2); }
| /*EMPTY*/ { $$ = EMPTY; }
;
opt_connection_name: AS connection_object { $$ = $2; }
| /*EMPTY*/ { $$ = make_str("NULL"); }
| /*EMPTY*/ { $$ = mm_strdup("NULL"); }
;
opt_user: USER ora_user { $$ = $2; }
| /*EMPTY*/ { $$ = make_str("NULL, NULL"); }
| /*EMPTY*/ { $$ = mm_strdup("NULL, NULL"); }
;
ora_user: user_name
{ $$ = cat2_str($1, make_str(", NULL")); }
{ $$ = cat2_str($1, mm_strdup(", NULL")); }
| user_name '/' user_name
{ $$ = cat_str(3, $1, make_str(","), $3); }
{ $$ = cat_str(3, $1, mm_strdup(","), $3); }
| user_name SQL_IDENTIFIED BY user_name
{ $$ = cat_str(3, $1, make_str(","), $4); }
{ $$ = cat_str(3, $1, mm_strdup(","), $4); }
| user_name USING user_name
{ $$ = cat_str(3, $1, make_str(","), $3); }
{ $$ = cat_str(3, $1, mm_strdup(","), $3); }
;
user_name: RoleId
......@@ -169,14 +169,14 @@ user_name: RoleId
if ($1[0] == '\"')
$$ = $1;
else
$$ = make3_str(make_str("\""), $1, make_str("\""));
$$ = make3_str(mm_strdup("\""), $1, mm_strdup("\""));
}
| ecpg_sconst
{
if ($1[0] == '\"')
$$ = $1;
else
$$ = make3_str(make_str("\""), $1, make_str("\""));
$$ = make3_str(mm_strdup("\""), $1, mm_strdup("\""));
}
| civar
{
......@@ -188,7 +188,7 @@ user_name: RoleId
/* handle varchars */
if (type == ECPGt_varchar)
$$ = make2_str(mm_strdup(argsinsert->variable->name), make_str(".arr"));
$$ = make2_str(mm_strdup(argsinsert->variable->name), mm_strdup(".arr"));
else
$$ = mm_strdup(argsinsert->variable->name);
}
......@@ -217,7 +217,7 @@ char_variable: cvariable
$$ = $1;
break;
case ECPGt_varchar:
$$ = make2_str($1, make_str(".arr"));
$$ = make2_str($1, mm_strdup(".arr"));
break;
default:
mmerror(PARSE_ERROR, ET_ERROR, "invalid data type");
......@@ -236,7 +236,7 @@ opt_options: Op connect_options
if (strcmp($1, "?") != 0)
mmerror(PARSE_ERROR, ET_ERROR, "unrecognized token \"%s\"", $1);
$$ = make2_str(make_str("?"), $2);
$$ = make2_str(mm_strdup("?"), $2);
}
| /*EMPTY*/ { $$ = EMPTY; }
;
......@@ -258,11 +258,11 @@ connect_options: ColId opt_opt_value
opt_opt_value: /*EMPTY*/
{ $$ = EMPTY; }
| '=' Iconst
{ $$ = make2_str(make_str("="), $2); }
{ $$ = make2_str(mm_strdup("="), $2); }
| '=' ecpg_ident
{ $$ = make2_str(make_str("="), $2); }
{ $$ = make2_str(mm_strdup("="), $2); }
| '=' civar
{ $$ = make2_str(make_str("="), $2); }
{ $$ = make2_str(mm_strdup("="), $2); }
;
prepared_name: name {
......@@ -275,7 +275,7 @@ prepared_name: name {
for (i = 0; i< strlen($1); i++)
$1[i] = tolower((unsigned char) $1[i]);
$$ = make3_str(make_str("\""), $1, make_str("\""));
$$ = make3_str(mm_strdup("\""), $1, mm_strdup("\""));
}
}
| char_variable { $$ = $1; }
......@@ -288,7 +288,7 @@ prepared_name: name {
ECPGCursorStmt: DECLARE cursor_name cursor_options CURSOR opt_hold FOR prepared_name
{
struct cursor *ptr, *this;
char *cursor_marker = $2[0] == ':' ? make_str("$0") : mm_strdup($2);
char *cursor_marker = $2[0] == ':' ? mm_strdup("$0") : mm_strdup($2);
int (* strcmp_fn)(const char *, const char *) = ($2[0] == ':' ? strcmp : pg_strcasecmp);
struct variable *thisquery = (struct variable *)mm_alloc(sizeof(struct variable));
const char *con = connection ? connection : "NULL";
......@@ -313,7 +313,7 @@ ECPGCursorStmt: DECLARE cursor_name cursor_options CURSOR opt_hold FOR prepared
this->name = $2;
this->function = (current_function ? mm_strdup(current_function) : NULL);
this->connection = connection;
this->command = cat_str(6, make_str("declare"), cursor_marker, $3, make_str("cursor"), $5, make_str("for $1"));
this->command = cat_str(6, mm_strdup("declare"), cursor_marker, $3, mm_strdup("cursor"), $5, mm_strdup("for $1"));
this->argsresult = NULL;
this->argsresult_oos = NULL;
......@@ -335,11 +335,11 @@ ECPGCursorStmt: DECLARE cursor_name cursor_options CURSOR opt_hold FOR prepared
cur = this;
comment = cat_str(3, make_str("/*"), mm_strdup(this->command), make_str("*/"));
comment = cat_str(3, mm_strdup("/*"), mm_strdup(this->command), mm_strdup("*/"));
if ((braces_open > 0) && INFORMIX_MODE) /* we're in a function */
$$ = cat_str(3, adjust_outofscope_cursor_vars(this),
make_str("ECPG_informix_reset_sqlca();"),
mm_strdup("ECPG_informix_reset_sqlca();"),
comment);
else
$$ = cat2_str(adjust_outofscope_cursor_vars(this), comment);
......@@ -368,10 +368,10 @@ opt_scale: ',' NumericOnly { $$ = $2; }
;
ecpg_interval: opt_interval { $$ = $1; }
| YEAR_P TO MINUTE_P { $$ = make_str("year to minute"); }
| YEAR_P TO SECOND_P { $$ = make_str("year to second"); }
| DAY_P TO DAY_P { $$ = make_str("day to day"); }
| MONTH_P TO MONTH_P { $$ = make_str("month to month"); }
| YEAR_P TO MINUTE_P { $$ = mm_strdup("year to minute"); }
| YEAR_P TO SECOND_P { $$ = mm_strdup("year to second"); }
| DAY_P TO DAY_P { $$ = mm_strdup("day to day"); }
| MONTH_P TO MONTH_P { $$ = mm_strdup("month to month"); }
;
/*
......@@ -417,7 +417,7 @@ type_declaration: S_TYPEDEF
fprintf(yyout, "typedef %s %s %s %s;\n", $3.type_str, *$4 ? "*" : "", $5, $6.str);
output_line_number();
$$ = make_str("");
$$ = mm_strdup("");
};
var_declaration: storage_declaration
......@@ -433,7 +433,7 @@ var_declaration: storage_declaration
}
variable_list ';'
{
$$ = cat_str(5, actual_startline[struct_level], $1, $2.type_str, $4, make_str(";\n"));
$$ = cat_str(5, actual_startline[struct_level], $1, $2.type_str, $4, mm_strdup(";\n"));
}
| var_type
{
......@@ -447,15 +447,15 @@ var_declaration: storage_declaration
}
variable_list ';'
{
$$ = cat_str(4, actual_startline[struct_level], $1.type_str, $3, make_str(";\n"));
$$ = cat_str(4, actual_startline[struct_level], $1.type_str, $3, mm_strdup(";\n"));
}
| struct_union_type_with_symbol ';'
{
$$ = cat2_str($1, make_str(";"));
$$ = cat2_str($1, mm_strdup(";"));
}
;
opt_bit_field: ':' Iconst { $$ =cat2_str(make_str(":"), $2); }
opt_bit_field: ':' Iconst { $$ =cat2_str(mm_strdup(":"), $2); }
| /* EMPTY */ { $$ = EMPTY; }
;
......@@ -465,29 +465,29 @@ storage_declaration: storage_clause storage_modifier
| storage_modifier {$$ = $1; }
;
storage_clause : S_EXTERN { $$ = make_str("extern"); }
| S_STATIC { $$ = make_str("static"); }
| S_REGISTER { $$ = make_str("register"); }
| S_AUTO { $$ = make_str("auto"); }
storage_clause : S_EXTERN { $$ = mm_strdup("extern"); }
| S_STATIC { $$ = mm_strdup("static"); }
| S_REGISTER { $$ = mm_strdup("register"); }
| S_AUTO { $$ = mm_strdup("auto"); }
;
storage_modifier : S_CONST { $$ = make_str("const"); }
| S_VOLATILE { $$ = make_str("volatile"); }
storage_modifier : S_CONST { $$ = mm_strdup("const"); }
| S_VOLATILE { $$ = mm_strdup("volatile"); }
;
var_type: simple_type
{
$$.type_enum = $1;
$$.type_str = mm_strdup(ecpg_type_name($1));
$$.type_dimension = make_str("-1");
$$.type_index = make_str("-1");
$$.type_dimension = mm_strdup("-1");
$$.type_index = mm_strdup("-1");
$$.type_sizeof = NULL;
}
| struct_union_type
{
$$.type_str = $1;
$$.type_dimension = make_str("-1");
$$.type_index = make_str("-1");
$$.type_dimension = mm_strdup("-1");
$$.type_index = mm_strdup("-1");
if (strncmp($1, "struct", sizeof("struct")-1) == 0)
{
......@@ -504,8 +504,8 @@ var_type: simple_type
{
$$.type_str = $1;
$$.type_enum = ECPGt_int;
$$.type_dimension = make_str("-1");
$$.type_index = make_str("-1");
$$.type_dimension = mm_strdup("-1");
$$.type_index = mm_strdup("-1");
$$.type_sizeof = NULL;
}
| ECPGColLabelCommon '(' precision opt_scale ')'
......@@ -513,22 +513,22 @@ var_type: simple_type
if (strcmp($1, "numeric") == 0)
{
$$.type_enum = ECPGt_numeric;
$$.type_str = make_str("numeric");
$$.type_str = mm_strdup("numeric");
}
else if (strcmp($1, "decimal") == 0)
{
$$.type_enum = ECPGt_decimal;
$$.type_str = make_str("decimal");
$$.type_str = mm_strdup("decimal");
}
else
{
mmerror(PARSE_ERROR, ET_ERROR, "only data types numeric and decimal have precision/scale argument");
$$.type_enum = ECPGt_numeric;
$$.type_str = make_str("numeric");
$$.type_str = mm_strdup("numeric");
}
$$.type_dimension = make_str("-1");
$$.type_index = make_str("-1");
$$.type_dimension = mm_strdup("-1");
$$.type_index = mm_strdup("-1");
$$.type_sizeof = NULL;
}
| ECPGColLabelCommon ecpg_interval
......@@ -543,81 +543,81 @@ var_type: simple_type
if (strcmp($1, "varchar") == 0)
{
$$.type_enum = ECPGt_varchar;
$$.type_str = EMPTY; /*make_str("varchar");*/
$$.type_dimension = make_str("-1");
$$.type_index = make_str("-1");
$$.type_str = EMPTY; /*mm_strdup("varchar");*/
$$.type_dimension = mm_strdup("-1");
$$.type_index = mm_strdup("-1");
$$.type_sizeof = NULL;
}
else if (strcmp($1, "float") == 0)
{
$$.type_enum = ECPGt_float;
$$.type_str = make_str("float");
$$.type_dimension = make_str("-1");
$$.type_index = make_str("-1");
$$.type_str = mm_strdup("float");
$$.type_dimension = mm_strdup("-1");
$$.type_index = mm_strdup("-1");
$$.type_sizeof = NULL;
}
else if (strcmp($1, "double") == 0)
{
$$.type_enum = ECPGt_double;
$$.type_str = make_str("double");
$$.type_dimension = make_str("-1");
$$.type_index = make_str("-1");
$$.type_str = mm_strdup("double");
$$.type_dimension = mm_strdup("-1");
$$.type_index = mm_strdup("-1");
$$.type_sizeof = NULL;
}
else if (strcmp($1, "numeric") == 0)
{
$$.type_enum = ECPGt_numeric;
$$.type_str = make_str("numeric");
$$.type_dimension = make_str("-1");
$$.type_index = make_str("-1");
$$.type_str = mm_strdup("numeric");
$$.type_dimension = mm_strdup("-1");
$$.type_index = mm_strdup("-1");
$$.type_sizeof = NULL;
}
else if (strcmp($1, "decimal") == 0)
{
$$.type_enum = ECPGt_decimal;
$$.type_str = make_str("decimal");
$$.type_dimension = make_str("-1");
$$.type_index = make_str("-1");
$$.type_str = mm_strdup("decimal");
$$.type_dimension = mm_strdup("-1");
$$.type_index = mm_strdup("-1");
$$.type_sizeof = NULL;
}
else if (strcmp($1, "date") == 0)
{
$$.type_enum = ECPGt_date;
$$.type_str = make_str("date");
$$.type_dimension = make_str("-1");
$$.type_index = make_str("-1");
$$.type_str = mm_strdup("date");
$$.type_dimension = mm_strdup("-1");
$$.type_index = mm_strdup("-1");
$$.type_sizeof = NULL;
}
else if (strcmp($1, "timestamp") == 0)
{
$$.type_enum = ECPGt_timestamp;
$$.type_str = make_str("timestamp");
$$.type_dimension = make_str("-1");
$$.type_index = make_str("-1");
$$.type_str = mm_strdup("timestamp");
$$.type_dimension = mm_strdup("-1");
$$.type_index = mm_strdup("-1");
$$.type_sizeof = NULL;
}
else if (strcmp($1, "interval") == 0)
{
$$.type_enum = ECPGt_interval;
$$.type_str = make_str("interval");
$$.type_dimension = make_str("-1");
$$.type_index = make_str("-1");
$$.type_str = mm_strdup("interval");
$$.type_dimension = mm_strdup("-1");
$$.type_index = mm_strdup("-1");
$$.type_sizeof = NULL;
}
else if (strcmp($1, "datetime") == 0)
{
$$.type_enum = ECPGt_timestamp;
$$.type_str = make_str("timestamp");
$$.type_dimension = make_str("-1");
$$.type_index = make_str("-1");
$$.type_str = mm_strdup("timestamp");
$$.type_dimension = mm_strdup("-1");
$$.type_index = mm_strdup("-1");
$$.type_sizeof = NULL;
}
else if ((strcmp($1, "string") == 0) && INFORMIX_MODE)
{
$$.type_enum = ECPGt_string;
$$.type_str = make_str("char");
$$.type_dimension = make_str("-1");
$$.type_index = make_str("-1");
$$.type_str = mm_strdup("char");
$$.type_dimension = mm_strdup("-1");
$$.type_index = mm_strdup("-1");
$$.type_sizeof = NULL;
}
else
......@@ -632,7 +632,7 @@ var_type: simple_type
if (this->type->type_sizeof && strlen(this->type->type_sizeof) != 0)
$$.type_sizeof = this->type->type_sizeof;
else
$$.type_sizeof = cat_str(3, make_str("sizeof("), mm_strdup(this->name), make_str(")"));
$$.type_sizeof = cat_str(3, mm_strdup("sizeof("), mm_strdup(this->name), mm_strdup(")"));
struct_member_list[struct_level] = ECPGstruct_member_dup(this->struct_member_list);
}
......@@ -663,24 +663,24 @@ var_type: simple_type
{
$$.type_str = name;
$$.type_enum = ECPGt_long;
$$.type_dimension = make_str("-1");
$$.type_index = make_str("-1");
$$.type_sizeof = make_str("");
$$.type_dimension = mm_strdup("-1");
$$.type_index = mm_strdup("-1");
$$.type_sizeof = mm_strdup("");
struct_member_list[struct_level] = NULL;
}
}
;
enum_type: ENUM_P symbol enum_definition
{ $$ = cat_str(3, make_str("enum"), $2, $3); }
{ $$ = cat_str(3, mm_strdup("enum"), $2, $3); }
| ENUM_P enum_definition
{ $$ = cat2_str(make_str("enum"), $2); }
{ $$ = cat2_str(mm_strdup("enum"), $2); }
| ENUM_P symbol
{ $$ = cat2_str(make_str("enum"), $2); }
{ $$ = cat2_str(mm_strdup("enum"), $2); }
;
enum_definition: '{' c_list '}'
{ $$ = cat_str(3, make_str("{"), $2, make_str("}")); };
{ $$ = cat_str(3, mm_strdup("{"), $2, mm_strdup("}")); };
struct_union_type_with_symbol: s_struct_union_symbol
{
......@@ -723,13 +723,13 @@ struct_union_type_with_symbol: s_struct_union_symbol
this->type = (struct this_type *) mm_alloc(sizeof(struct this_type));
this->type->type_enum = su_type.type_enum;
this->type->type_str = mm_strdup(su_type.type_str);
this->type->type_dimension = make_str("-1"); /* dimension of array */
this->type->type_index = make_str("-1"); /* length of string */
this->type->type_dimension = mm_strdup("-1"); /* dimension of array */
this->type->type_index = mm_strdup("-1"); /* length of string */
this->type->type_sizeof = ECPGstruct_sizeof;
this->struct_member_list = struct_member_list[struct_level];
types = this;
$$ = cat_str(4, su_type.type_str, make_str("{"), $4, make_str("}"));
$$ = cat_str(4, su_type.type_str, mm_strdup("{"), $4, mm_strdup("}"));
}
;
......@@ -745,29 +745,29 @@ struct_union_type: struct_union_type_with_symbol { $$ = $1; }
ECPGfree_struct_member(struct_member_list[struct_level]);
struct_member_list[struct_level] = NULL;
struct_level--;
$$ = cat_str(4, $1, make_str("{"), $4, make_str("}"));
$$ = cat_str(4, $1, mm_strdup("{"), $4, mm_strdup("}"));
}
;
s_struct_union_symbol: SQL_STRUCT symbol
{
$$.su = make_str("struct");
$$.su = mm_strdup("struct");
$$.symbol = $2;
ECPGstruct_sizeof = cat_str(3, make_str("sizeof("), cat2_str(mm_strdup($$.su), mm_strdup($$.symbol)), make_str(")"));
ECPGstruct_sizeof = cat_str(3, mm_strdup("sizeof("), cat2_str(mm_strdup($$.su), mm_strdup($$.symbol)), mm_strdup(")"));
}
| UNION symbol
{
$$.su = make_str("union");
$$.su = mm_strdup("union");
$$.symbol = $2;
}
;
s_struct_union: SQL_STRUCT
{
ECPGstruct_sizeof = make_str(""); /* This must not be NULL to distinguish from simple types. */
$$ = make_str("struct");
ECPGstruct_sizeof = mm_strdup(""); /* This must not be NULL to distinguish from simple types. */
$$ = mm_strdup("struct");
}
| UNION { $$ = make_str("union"); }
| UNION { $$ = mm_strdup("union"); }
;
simple_type: unsigned_type { $$=$1; }
......@@ -832,7 +832,7 @@ opt_signed: SQL_SIGNED
variable_list: variable
{ $$ = $1; }
| variable_list ',' variable
{ $$ = cat_str(3, $1, make_str(","), $3); }
{ $$ = cat_str(3, $1, mm_strdup(","), $3); }
;
variable: opt_pointer ECPGColLabel opt_array_bounds opt_bit_field opt_initializer
......@@ -864,9 +864,9 @@ variable: opt_pointer ECPGColLabel opt_array_bounds opt_bit_field opt_initialize
type = ECPGmake_array_type(ECPGmake_simple_type(actual_type[struct_level].type_enum, length, varchar_counter), dimension);
if (strcmp(dimension, "0") == 0 || abs(atoi(dimension)) == 1)
dim_str=make_str("");
dim_str=mm_strdup("");
else
dim_str=cat_str(3, make_str("["), mm_strdup(dimension), make_str("]"));
dim_str=cat_str(3, mm_strdup("["), mm_strdup(dimension), mm_strdup("]"));
/* cannot check for atoi <= 0 because a defined constant will yield 0 here as well */
if (atoi(length) < 0 || strcmp(length, "0") == 0)
mmerror(PARSE_ERROR, ET_ERROR, "pointers to varchar are not implemented");
......@@ -875,9 +875,9 @@ variable: opt_pointer ECPGColLabel opt_array_bounds opt_bit_field opt_initialize
vcn = (char *) mm_alloc(strlen($2) + sizeof(int) * CHAR_BIT * 10 / 3);
sprintf(vcn, "%s_%d", $2, varchar_counter);
if (strcmp(dimension, "0") == 0)
$$ = cat_str(7, make2_str(make_str(" struct varchar_"), vcn), make_str(" { int len; char arr["), mm_strdup(length), make_str("]; } *"), mm_strdup($2), $4, $5);
$$ = cat_str(7, make2_str(mm_strdup(" struct varchar_"), vcn), mm_strdup(" { int len; char arr["), mm_strdup(length), mm_strdup("]; } *"), mm_strdup($2), $4, $5);
else
$$ = cat_str(8, make2_str(make_str(" struct varchar_"), vcn), make_str(" { int len; char arr["), mm_strdup(length), make_str("]; } "), mm_strdup($2), dim_str, $4, $5);
$$ = cat_str(8, make2_str(mm_strdup(" struct varchar_"), vcn), mm_strdup(" { int len; char arr["), mm_strdup(length), mm_strdup("]; } "), mm_strdup($2), dim_str, $4, $5);
varchar_counter++;
break;
......@@ -905,9 +905,9 @@ variable: opt_pointer ECPGColLabel opt_array_bounds opt_bit_field opt_initialize
default:
if (atoi(dimension) < 0)
type = ECPGmake_simple_type(actual_type[struct_level].type_enum, make_str("1"), 0);
type = ECPGmake_simple_type(actual_type[struct_level].type_enum, mm_strdup("1"), 0);
else
type = ECPGmake_array_type(ECPGmake_simple_type(actual_type[struct_level].type_enum, make_str("1"), 0), dimension);
type = ECPGmake_array_type(ECPGmake_simple_type(actual_type[struct_level].type_enum, mm_strdup("1"), 0), dimension);
$$ = cat_str(5, $1, mm_strdup($2), $3.str, $4, $5);
break;
......@@ -927,13 +927,13 @@ opt_initializer: /*EMPTY*/
| '=' c_term
{
initializer = 1;
$$ = cat2_str(make_str("="), $2);
$$ = cat2_str(mm_strdup("="), $2);
}
;
opt_pointer: /*EMPTY*/ { $$ = EMPTY; }
| '*' { $$ = make_str("*"); }
| '*' '*' { $$ = make_str("**"); }
| '*' { $$ = mm_strdup("*"); }
| '*' '*' { $$ = mm_strdup("**"); }
;
/*
......@@ -942,7 +942,7 @@ opt_pointer: /*EMPTY*/ { $$ = EMPTY; }
ECPGDeclare: DECLARE STATEMENT ecpg_ident
{
/* this is only supported for compatibility */
$$ = cat_str(3, make_str("/* declare statement"), $3, make_str("*/"));
$$ = cat_str(3, mm_strdup("/* declare statement"), $3, mm_strdup("*/"));
}
;
/*
......@@ -952,20 +952,20 @@ ECPGDisconnect: SQL_DISCONNECT dis_name { $$ = $2; }
;
dis_name: connection_object { $$ = $1; }
| CURRENT_P { $$ = make_str("\"CURRENT\""); }
| ALL { $$ = make_str("\"ALL\""); }
| /* EMPTY */ { $$ = make_str("\"CURRENT\""); }
| CURRENT_P { $$ = mm_strdup("\"CURRENT\""); }
| ALL { $$ = mm_strdup("\"ALL\""); }
| /* EMPTY */ { $$ = mm_strdup("\"CURRENT\""); }
;
connection_object: database_name { $$ = make3_str(make_str("\""), $1, make_str("\"")); }
| DEFAULT { $$ = make_str("\"DEFAULT\""); }
connection_object: database_name { $$ = make3_str(mm_strdup("\""), $1, mm_strdup("\"")); }
| DEFAULT { $$ = mm_strdup("\"DEFAULT\""); }
| char_variable { $$ = $1; }
;
execstring: char_variable
{ $$ = $1; }
| CSTRING
{ $$ = make3_str(make_str("\""), $1, make_str("\"")); }
{ $$ = make3_str(mm_strdup("\""), $1, mm_strdup("\"")); }
;
/*
......@@ -973,7 +973,7 @@ execstring: char_variable
* prepared statement
*/
ECPGFree: SQL_FREE cursor_name { $$ = $2; }
| SQL_FREE ALL { $$ = make_str("all"); }
| SQL_FREE ALL { $$ = mm_strdup("all"); }
;
/*
......@@ -1040,11 +1040,11 @@ UsingValue: UsingConst
;
UsingConst: Iconst { $$ = $1; }
| '+' Iconst { $$ = cat_str(2, make_str("+"), $2); }
| '-' Iconst { $$ = cat_str(2, make_str("-"), $2); }
| '+' Iconst { $$ = cat_str(2, mm_strdup("+"), $2); }
| '-' Iconst { $$ = cat_str(2, mm_strdup("-"), $2); }
| ecpg_fconst { $$ = $1; }
| '+' ecpg_fconst { $$ = cat_str(2, make_str("+"), $2); }
| '-' ecpg_fconst { $$ = cat_str(2, make_str("-"), $2); }
| '+' ecpg_fconst { $$ = cat_str(2, mm_strdup("+"), $2); }
| '-' ecpg_fconst { $$ = cat_str(2, mm_strdup("-"), $2); }
| ecpg_sconst { $$ = $1; }
| ecpg_bconst { $$ = $1; }
| ecpg_xconst { $$ = $1; }
......@@ -1093,7 +1093,7 @@ ECPGDescribe: SQL_DESCRIBE INPUT_P prepared_name using_descriptor
}
;
opt_output: SQL_OUTPUT { $$ = make_str("output"); }
opt_output: SQL_OUTPUT { $$ = mm_strdup("output"); }
| /* EMPTY */ { $$ = EMPTY; }
;
......@@ -1210,7 +1210,7 @@ AllConstVar: ecpg_fconst
| '-' ecpg_fconst
{
char *length = mm_alloc(sizeof(int) * CHAR_BIT * 10 / 3);
char *var = cat2_str(make_str("-"), $2);
char *var = cat2_str(mm_strdup("-"), $2);
sprintf(length, "%d", (int) strlen(var));
new_variable(var, ECPGmake_simple_type(ECPGt_const, length, 0), 0);
......@@ -1219,7 +1219,7 @@ AllConstVar: ecpg_fconst
| '-' Iconst
{
char *length = mm_alloc(sizeof(int) * CHAR_BIT * 10 / 3);
char *var = cat2_str(make_str("-"), $2);
char *var = cat2_str(mm_strdup("-"), $2);
sprintf(length, "%d", (int) strlen(var));
new_variable(var, ECPGmake_simple_type(ECPGt_const, length, 0), 0);
......@@ -1262,8 +1262,8 @@ ECPGSetAutocommit: SET SQL_AUTOCOMMIT '=' on_off { $$ = $4; }
| SET SQL_AUTOCOMMIT TO on_off { $$ = $4; }
;
on_off: ON { $$ = make_str("on"); }
| OFF { $$ = make_str("off"); }
on_off: ON { $$ = mm_strdup("on"); }
| OFF { $$ = mm_strdup("off"); }
;
/*
......@@ -1289,13 +1289,13 @@ ECPGTypedef: TYPE_P
add_typedef($3, $6.index1, $6.index2, $5.type_enum, $5.type_dimension, $5.type_index, initializer, *$7 ? 1 : 0);
if (auto_create_c == false)
$$ = cat_str(7, make_str("/* exec sql type"), mm_strdup($3), make_str("is"), mm_strdup($5.type_str), mm_strdup($6.str), $7, make_str("*/"));
$$ = cat_str(7, mm_strdup("/* exec sql type"), mm_strdup($3), mm_strdup("is"), mm_strdup($5.type_str), mm_strdup($6.str), $7, mm_strdup("*/"));
else
$$ = cat_str(6, make_str("typedef "), mm_strdup($5.type_str), *$7?make_str("*"):make_str(""), mm_strdup($6.str), mm_strdup($3), make_str(";"));
$$ = cat_str(6, mm_strdup("typedef "), mm_strdup($5.type_str), *$7?mm_strdup("*"):mm_strdup(""), mm_strdup($6.str), mm_strdup($3), mm_strdup(";"));
}
;
opt_reference: SQL_REFERENCE { $$ = make_str("reference"); }
opt_reference: SQL_REFERENCE { $$ = mm_strdup("reference"); }
| /*EMPTY*/ { $$ = EMPTY; }
;
......@@ -1354,9 +1354,9 @@ ECPGVar: SQL_VAR
mmerror(PARSE_ERROR, ET_ERROR, "multidimensional arrays for simple data types are not supported");
if (atoi(dimension) < 0)
type = ECPGmake_simple_type($5.type_enum, make_str("1"), 0);
type = ECPGmake_simple_type($5.type_enum, mm_strdup("1"), 0);
else
type = ECPGmake_array_type(ECPGmake_simple_type($5.type_enum, make_str("1"), 0), dimension);
type = ECPGmake_array_type(ECPGmake_simple_type($5.type_enum, mm_strdup("1"), 0), dimension);
break;
}
......@@ -1364,7 +1364,7 @@ ECPGVar: SQL_VAR
p->type = type;
}
$$ = cat_str(7, make_str("/* exec sql var"), mm_strdup($3), make_str("is"), mm_strdup($5.type_str), mm_strdup($6.str), $7, make_str("*/"));
$$ = cat_str(7, mm_strdup("/* exec sql var"), mm_strdup($3), mm_strdup("is"), mm_strdup($5.type_str), mm_strdup($6.str), $7, mm_strdup("*/"));
}
;
......@@ -1376,19 +1376,19 @@ ECPGWhenever: SQL_WHENEVER SQL_SQLERROR action
{
when_error.code = $<action>3.code;
when_error.command = $<action>3.command;
$$ = cat_str(3, make_str("/* exec sql whenever sqlerror "), $3.str, make_str("; */"));
$$ = cat_str(3, mm_strdup("/* exec sql whenever sqlerror "), $3.str, mm_strdup("; */"));
}
| SQL_WHENEVER NOT SQL_FOUND action
{
when_nf.code = $<action>4.code;
when_nf.command = $<action>4.command;
$$ = cat_str(3, make_str("/* exec sql whenever not found "), $4.str, make_str("; */"));
$$ = cat_str(3, mm_strdup("/* exec sql whenever not found "), $4.str, mm_strdup("; */"));
}
| SQL_WHENEVER SQL_SQLWARNING action
{
when_warn.code = $<action>3.code;
when_warn.command = $<action>3.command;
$$ = cat_str(3, make_str("/* exec sql whenever sql_warning "), $3.str, make_str("; */"));
$$ = cat_str(3, mm_strdup("/* exec sql whenever sql_warning "), $3.str, mm_strdup("; */"));
}
;
......@@ -1396,55 +1396,55 @@ action : CONTINUE_P
{
$<action>$.code = W_NOTHING;
$<action>$.command = NULL;
$<action>$.str = make_str("continue");
$<action>$.str = mm_strdup("continue");
}
| SQL_SQLPRINT
{
$<action>$.code = W_SQLPRINT;
$<action>$.command = NULL;
$<action>$.str = make_str("sqlprint");
$<action>$.str = mm_strdup("sqlprint");
}
| SQL_STOP
{
$<action>$.code = W_STOP;
$<action>$.command = NULL;
$<action>$.str = make_str("stop");
$<action>$.str = mm_strdup("stop");
}
| SQL_GOTO name
{
$<action>$.code = W_GOTO;
$<action>$.command = strdup($2);
$<action>$.str = cat2_str(make_str("goto "), $2);
$<action>$.str = cat2_str(mm_strdup("goto "), $2);
}
| SQL_GO TO name
{
$<action>$.code = W_GOTO;
$<action>$.command = strdup($3);
$<action>$.str = cat2_str(make_str("goto "), $3);
$<action>$.str = cat2_str(mm_strdup("goto "), $3);
}
| DO name '(' c_args ')'
{
$<action>$.code = W_DO;
$<action>$.command = cat_str(4, $2, make_str("("), $4, make_str(")"));
$<action>$.str = cat2_str(make_str("do"), mm_strdup($<action>$.command));
$<action>$.command = cat_str(4, $2, mm_strdup("("), $4, mm_strdup(")"));
$<action>$.str = cat2_str(mm_strdup("do"), mm_strdup($<action>$.command));
}
| DO SQL_BREAK
{
$<action>$.code = W_BREAK;
$<action>$.command = NULL;
$<action>$.str = make_str("break");
$<action>$.str = mm_strdup("break");
}
| SQL_CALL name '(' c_args ')'
{
$<action>$.code = W_DO;
$<action>$.command = cat_str(4, $2, make_str("("), $4, make_str(")"));
$<action>$.str = cat2_str(make_str("call"), mm_strdup($<action>$.command));
$<action>$.command = cat_str(4, $2, mm_strdup("("), $4, mm_strdup(")"));
$<action>$.str = cat2_str(mm_strdup("call"), mm_strdup($<action>$.command));
}
| SQL_CALL name
{
$<action>$.code = W_DO;
$<action>$.command = cat2_str($2, make_str("()"));
$<action>$.str = cat2_str(make_str("call"), mm_strdup($<action>$.command));
$<action>$.command = cat2_str($2, mm_strdup("()"));
$<action>$.str = cat2_str(mm_strdup("call"), mm_strdup($<action>$.command));
}
;
......@@ -1455,48 +1455,48 @@ ECPGKeywords: ECPGKeywords_vanames { $$ = $1; }
| ECPGKeywords_rest { $$ = $1; }
;
ECPGKeywords_vanames: SQL_BREAK { $$ = make_str("break"); }
| SQL_CALL { $$ = make_str("call"); }
| SQL_CARDINALITY { $$ = make_str("cardinality"); }
| SQL_COUNT { $$ = make_str("count"); }
| SQL_DATETIME_INTERVAL_CODE { $$ = make_str("datetime_interval_code"); }
| SQL_DATETIME_INTERVAL_PRECISION { $$ = make_str("datetime_interval_precision"); }
| SQL_FOUND { $$ = make_str("found"); }
| SQL_GO { $$ = make_str("go"); }
| SQL_GOTO { $$ = make_str("goto"); }
| SQL_IDENTIFIED { $$ = make_str("identified"); }
| SQL_INDICATOR { $$ = make_str("indicator"); }
| SQL_KEY_MEMBER { $$ = make_str("key_member"); }
| SQL_LENGTH { $$ = make_str("length"); }
| SQL_NULLABLE { $$ = make_str("nullable"); }
| SQL_OCTET_LENGTH { $$ = make_str("octet_length"); }
| SQL_RETURNED_LENGTH { $$ = make_str("returned_length"); }
| SQL_RETURNED_OCTET_LENGTH { $$ = make_str("returned_octet_length"); }
| SQL_SCALE { $$ = make_str("scale"); }
| SQL_SECTION { $$ = make_str("section"); }
| SQL_SQL { $$ = make_str("sql"); }
| SQL_SQLERROR { $$ = make_str("sqlerror"); }
| SQL_SQLPRINT { $$ = make_str("sqlprint"); }
| SQL_SQLWARNING { $$ = make_str("sqlwarning"); }
| SQL_STOP { $$ = make_str("stop"); }
;
ECPGKeywords_rest: SQL_CONNECT { $$ = make_str("connect"); }
| SQL_DESCRIBE { $$ = make_str("describe"); }
| SQL_DISCONNECT { $$ = make_str("disconnect"); }
| SQL_OPEN { $$ = make_str("open"); }
| SQL_VAR { $$ = make_str("var"); }
| SQL_WHENEVER { $$ = make_str("whenever"); }
ECPGKeywords_vanames: SQL_BREAK { $$ = mm_strdup("break"); }
| SQL_CALL { $$ = mm_strdup("call"); }
| SQL_CARDINALITY { $$ = mm_strdup("cardinality"); }
| SQL_COUNT { $$ = mm_strdup("count"); }
| SQL_DATETIME_INTERVAL_CODE { $$ = mm_strdup("datetime_interval_code"); }
| SQL_DATETIME_INTERVAL_PRECISION { $$ = mm_strdup("datetime_interval_precision"); }
| SQL_FOUND { $$ = mm_strdup("found"); }
| SQL_GO { $$ = mm_strdup("go"); }
| SQL_GOTO { $$ = mm_strdup("goto"); }
| SQL_IDENTIFIED { $$ = mm_strdup("identified"); }
| SQL_INDICATOR { $$ = mm_strdup("indicator"); }
| SQL_KEY_MEMBER { $$ = mm_strdup("key_member"); }
| SQL_LENGTH { $$ = mm_strdup("length"); }
| SQL_NULLABLE { $$ = mm_strdup("nullable"); }
| SQL_OCTET_LENGTH { $$ = mm_strdup("octet_length"); }
| SQL_RETURNED_LENGTH { $$ = mm_strdup("returned_length"); }
| SQL_RETURNED_OCTET_LENGTH { $$ = mm_strdup("returned_octet_length"); }
| SQL_SCALE { $$ = mm_strdup("scale"); }
| SQL_SECTION { $$ = mm_strdup("section"); }
| SQL_SQL { $$ = mm_strdup("sql"); }
| SQL_SQLERROR { $$ = mm_strdup("sqlerror"); }
| SQL_SQLPRINT { $$ = mm_strdup("sqlprint"); }
| SQL_SQLWARNING { $$ = mm_strdup("sqlwarning"); }
| SQL_STOP { $$ = mm_strdup("stop"); }
;
ECPGKeywords_rest: SQL_CONNECT { $$ = mm_strdup("connect"); }
| SQL_DESCRIBE { $$ = mm_strdup("describe"); }
| SQL_DISCONNECT { $$ = mm_strdup("disconnect"); }
| SQL_OPEN { $$ = mm_strdup("open"); }
| SQL_VAR { $$ = mm_strdup("var"); }
| SQL_WHENEVER { $$ = mm_strdup("whenever"); }
;
/* additional keywords that can be SQL type names (but not ECPGColLabels) */
ECPGTypeName: SQL_BOOL { $$ = make_str("bool"); }
| SQL_LONG { $$ = make_str("long"); }
| SQL_OUTPUT { $$ = make_str("output"); }
| SQL_SHORT { $$ = make_str("short"); }
| SQL_STRUCT { $$ = make_str("struct"); }
| SQL_SIGNED { $$ = make_str("signed"); }
| SQL_UNSIGNED { $$ = make_str("unsigned"); }
ECPGTypeName: SQL_BOOL { $$ = mm_strdup("bool"); }
| SQL_LONG { $$ = mm_strdup("long"); }
| SQL_OUTPUT { $$ = mm_strdup("output"); }
| SQL_SHORT { $$ = mm_strdup("short"); }
| SQL_STRUCT { $$ = mm_strdup("struct"); }
| SQL_SIGNED { $$ = mm_strdup("signed"); }
| SQL_UNSIGNED { $$ = mm_strdup("unsigned"); }
;
symbol: ColLabel { $$ = $1; }
......@@ -1508,8 +1508,8 @@ ECPGColId: ecpg_ident { $$ = $1; }
| ECPGunreserved_interval { $$ = $1; }
| ECPGKeywords { $$ = $1; }
| ECPGCKeywords { $$ = $1; }
| CHAR_P { $$ = make_str("char"); }
| VALUES { $$ = make_str("values"); }
| CHAR_P { $$ = mm_strdup("char"); }
| VALUES { $$ = mm_strdup("values"); }
;
/*
......@@ -1527,8 +1527,8 @@ ColId: ecpg_ident { $$ = $1; }
| col_name_keyword { $$ = $1; }
| ECPGKeywords { $$ = $1; }
| ECPGCKeywords { $$ = $1; }
| CHAR_P { $$ = make_str("char"); }
| VALUES { $$ = make_str("values"); }
| CHAR_P { $$ = mm_strdup("char"); }
| VALUES { $$ = mm_strdup("values"); }
;
/* Type/function identifier --- names that can be type or function names.
......@@ -1546,13 +1546,13 @@ type_function_name: ecpg_ident { $$ = $1; }
*/
ColLabel: ECPGColLabel { $$ = $1; }
| ECPGTypeName { $$ = $1; }
| CHAR_P { $$ = make_str("char"); }
| CURRENT_P { $$ = make_str("current"); }
| INPUT_P { $$ = make_str("input"); }
| INT_P { $$ = make_str("int"); }
| TO { $$ = make_str("to"); }
| UNION { $$ = make_str("union"); }
| VALUES { $$ = make_str("values"); }
| CHAR_P { $$ = mm_strdup("char"); }
| CURRENT_P { $$ = mm_strdup("current"); }
| INPUT_P { $$ = mm_strdup("input"); }
| INT_P { $$ = mm_strdup("int"); }
| TO { $$ = mm_strdup("to"); }
| UNION { $$ = mm_strdup("union"); }
| VALUES { $$ = mm_strdup("values"); }
| ECPGCKeywords { $$ = $1; }
| ECPGunreserved_interval { $$ = $1; }
;
......@@ -1561,7 +1561,7 @@ ECPGColLabel: ECPGColLabelCommon { $$ = $1; }
| unreserved_keyword { $$ = $1; }
| reserved_keyword { $$ = $1; }
| ECPGKeywords_rest { $$ = $1; }
| CONNECTION { $$ = make_str("connection"); }
| CONNECTION { $$ = mm_strdup("connection"); }
;
ECPGColLabelCommon: ecpg_ident { $$ = $1; }
......@@ -1570,13 +1570,13 @@ ECPGColLabelCommon: ecpg_ident { $$ = $1; }
| ECPGKeywords_vanames { $$ = $1; }
;
ECPGCKeywords: S_AUTO { $$ = make_str("auto"); }
| S_CONST { $$ = make_str("const"); }
| S_EXTERN { $$ = make_str("extern"); }
| S_REGISTER { $$ = make_str("register"); }
| S_STATIC { $$ = make_str("static"); }
| S_TYPEDEF { $$ = make_str("typedef"); }
| S_VOLATILE { $$ = make_str("volatile"); }
ECPGCKeywords: S_AUTO { $$ = mm_strdup("auto"); }
| S_CONST { $$ = mm_strdup("const"); }
| S_EXTERN { $$ = mm_strdup("extern"); }
| S_REGISTER { $$ = mm_strdup("register"); }
| S_STATIC { $$ = mm_strdup("static"); }
| S_TYPEDEF { $$ = mm_strdup("typedef"); }
| S_VOLATILE { $$ = mm_strdup("volatile"); }
;
/* "Unreserved" keywords --- available for use as any kind of name.
......@@ -1595,15 +1595,15 @@ ECPGCKeywords: S_AUTO { $$ = make_str("auto"); }
*/
all_unreserved_keyword: unreserved_keyword { $$ = $1; }
| ECPGunreserved_interval { $$ = $1; }
| CONNECTION { $$ = make_str("connection"); }
| CONNECTION { $$ = mm_strdup("connection"); }
;
ECPGunreserved_interval: DAY_P { $$ = make_str("day"); }
| HOUR_P { $$ = make_str("hour"); }
| MINUTE_P { $$ = make_str("minute"); }
| MONTH_P { $$ = make_str("month"); }
| SECOND_P { $$ = make_str("second"); }
| YEAR_P { $$ = make_str("year"); }
ECPGunreserved_interval: DAY_P { $$ = mm_strdup("day"); }
| HOUR_P { $$ = mm_strdup("hour"); }
| MINUTE_P { $$ = mm_strdup("minute"); }
| MONTH_P { $$ = mm_strdup("month"); }
| SECOND_P { $$ = mm_strdup("second"); }
| YEAR_P { $$ = mm_strdup("year"); }
;
......@@ -1737,14 +1737,14 @@ ecpg_sconst:
ecpg_xconst: XCONST { $$ = make_name(); } ;
ecpg_ident: IDENT { $$ = make_name(); }
| CSTRING { $$ = make3_str(make_str("\""), $1, make_str("\"")); }
| CSTRING { $$ = make3_str(mm_strdup("\""), $1, mm_strdup("\"")); }
| UIDENT { $$ = $1; }
;
quoted_ident_stringvar: name
{ $$ = make3_str(make_str("\""), $1, make_str("\"")); }
{ $$ = make3_str(mm_strdup("\""), $1, mm_strdup("\"")); }
| char_variable
{ $$ = make3_str(make_str("("), $1, make_str(")")); }
{ $$ = make3_str(mm_strdup("("), $1, mm_strdup(")")); }
;
/*
......@@ -1752,9 +1752,9 @@ quoted_ident_stringvar: name
*/
c_stuff_item: c_anything { $$ = $1; }
| '(' ')' { $$ = make_str("()"); }
| '(' ')' { $$ = mm_strdup("()"); }
| '(' c_stuff ')'
{ $$ = cat_str(3, make_str("("), $2, make_str(")")); }
{ $$ = cat_str(3, mm_strdup("("), $2, mm_strdup(")")); }
;
c_stuff: c_stuff_item { $$ = $1; }
......@@ -1763,91 +1763,91 @@ c_stuff: c_stuff_item { $$ = $1; }
;
c_list: c_term { $$ = $1; }
| c_list ',' c_term { $$ = cat_str(3, $1, make_str(","), $3); }
| c_list ',' c_term { $$ = cat_str(3, $1, mm_strdup(","), $3); }
;
c_term: c_stuff { $$ = $1; }
| '{' c_list '}' { $$ = cat_str(3, make_str("{"), $2, make_str("}")); }
| '{' c_list '}' { $$ = cat_str(3, mm_strdup("{"), $2, mm_strdup("}")); }
;
c_thing: c_anything { $$ = $1; }
| '(' { $$ = make_str("("); }
| ')' { $$ = make_str(")"); }
| ',' { $$ = make_str(","); }
| ';' { $$ = make_str(";"); }
| '(' { $$ = mm_strdup("("); }
| ')' { $$ = mm_strdup(")"); }
| ',' { $$ = mm_strdup(","); }
| ';' { $$ = mm_strdup(";"); }
;
c_anything: ecpg_ident { $$ = $1; }
| Iconst { $$ = $1; }
| ecpg_fconst { $$ = $1; }
| ecpg_sconst { $$ = $1; }
| '*' { $$ = make_str("*"); }
| '+' { $$ = make_str("+"); }
| '-' { $$ = make_str("-"); }
| '/' { $$ = make_str("/"); }
| '%' { $$ = make_str("%"); }
| NULL_P { $$ = make_str("NULL"); }
| S_ADD { $$ = make_str("+="); }
| S_AND { $$ = make_str("&&"); }
| '*' { $$ = mm_strdup("*"); }
| '+' { $$ = mm_strdup("+"); }
| '-' { $$ = mm_strdup("-"); }
| '/' { $$ = mm_strdup("/"); }
| '%' { $$ = mm_strdup("%"); }
| NULL_P { $$ = mm_strdup("NULL"); }
| S_ADD { $$ = mm_strdup("+="); }
| S_AND { $$ = mm_strdup("&&"); }
| S_ANYTHING { $$ = make_name(); }
| S_AUTO { $$ = make_str("auto"); }
| S_CONST { $$ = make_str("const"); }
| S_DEC { $$ = make_str("--"); }
| S_DIV { $$ = make_str("/="); }
| S_DOTPOINT { $$ = make_str(".*"); }
| S_EQUAL { $$ = make_str("=="); }
| S_EXTERN { $$ = make_str("extern"); }
| S_INC { $$ = make_str("++"); }
| S_LSHIFT { $$ = make_str("<<"); }
| S_MEMBER { $$ = make_str("->"); }
| S_MEMPOINT { $$ = make_str("->*"); }
| S_MOD { $$ = make_str("%="); }
| S_MUL { $$ = make_str("*="); }
| S_NEQUAL { $$ = make_str("!="); }
| S_OR { $$ = make_str("||"); }
| S_REGISTER { $$ = make_str("register"); }
| S_RSHIFT { $$ = make_str(">>"); }
| S_STATIC { $$ = make_str("static"); }
| S_SUB { $$ = make_str("-="); }
| S_TYPEDEF { $$ = make_str("typedef"); }
| S_VOLATILE { $$ = make_str("volatile"); }
| SQL_BOOL { $$ = make_str("bool"); }
| ENUM_P { $$ = make_str("enum"); }
| HOUR_P { $$ = make_str("hour"); }
| INT_P { $$ = make_str("int"); }
| SQL_LONG { $$ = make_str("long"); }
| MINUTE_P { $$ = make_str("minute"); }
| MONTH_P { $$ = make_str("month"); }
| SECOND_P { $$ = make_str("second"); }
| SQL_SHORT { $$ = make_str("short"); }
| SQL_SIGNED { $$ = make_str("signed"); }
| SQL_STRUCT { $$ = make_str("struct"); }
| SQL_UNSIGNED { $$ = make_str("unsigned"); }
| YEAR_P { $$ = make_str("year"); }
| CHAR_P { $$ = make_str("char"); }
| FLOAT_P { $$ = make_str("float"); }
| TO { $$ = make_str("to"); }
| UNION { $$ = make_str("union"); }
| VARCHAR { $$ = make_str("varchar"); }
| '[' { $$ = make_str("["); }
| ']' { $$ = make_str("]"); }
| '=' { $$ = make_str("="); }
| ':' { $$ = make_str(":"); }
| S_AUTO { $$ = mm_strdup("auto"); }
| S_CONST { $$ = mm_strdup("const"); }
| S_DEC { $$ = mm_strdup("--"); }
| S_DIV { $$ = mm_strdup("/="); }
| S_DOTPOINT { $$ = mm_strdup(".*"); }
| S_EQUAL { $$ = mm_strdup("=="); }
| S_EXTERN { $$ = mm_strdup("extern"); }
| S_INC { $$ = mm_strdup("++"); }
| S_LSHIFT { $$ = mm_strdup("<<"); }
| S_MEMBER { $$ = mm_strdup("->"); }
| S_MEMPOINT { $$ = mm_strdup("->*"); }
| S_MOD { $$ = mm_strdup("%="); }
| S_MUL { $$ = mm_strdup("*="); }
| S_NEQUAL { $$ = mm_strdup("!="); }
| S_OR { $$ = mm_strdup("||"); }
| S_REGISTER { $$ = mm_strdup("register"); }
| S_RSHIFT { $$ = mm_strdup(">>"); }
| S_STATIC { $$ = mm_strdup("static"); }
| S_SUB { $$ = mm_strdup("-="); }
| S_TYPEDEF { $$ = mm_strdup("typedef"); }
| S_VOLATILE { $$ = mm_strdup("volatile"); }
| SQL_BOOL { $$ = mm_strdup("bool"); }
| ENUM_P { $$ = mm_strdup("enum"); }
| HOUR_P { $$ = mm_strdup("hour"); }
| INT_P { $$ = mm_strdup("int"); }
| SQL_LONG { $$ = mm_strdup("long"); }
| MINUTE_P { $$ = mm_strdup("minute"); }
| MONTH_P { $$ = mm_strdup("month"); }
| SECOND_P { $$ = mm_strdup("second"); }
| SQL_SHORT { $$ = mm_strdup("short"); }
| SQL_SIGNED { $$ = mm_strdup("signed"); }
| SQL_STRUCT { $$ = mm_strdup("struct"); }
| SQL_UNSIGNED { $$ = mm_strdup("unsigned"); }
| YEAR_P { $$ = mm_strdup("year"); }
| CHAR_P { $$ = mm_strdup("char"); }
| FLOAT_P { $$ = mm_strdup("float"); }
| TO { $$ = mm_strdup("to"); }
| UNION { $$ = mm_strdup("union"); }
| VARCHAR { $$ = mm_strdup("varchar"); }
| '[' { $$ = mm_strdup("["); }
| ']' { $$ = mm_strdup("]"); }
| '=' { $$ = mm_strdup("="); }
| ':' { $$ = mm_strdup(":"); }
;
DeallocateStmt: DEALLOCATE prepared_name { $$ = $2; }
| DEALLOCATE PREPARE prepared_name { $$ = $3; }
| DEALLOCATE ALL { $$ = make_str("all"); }
| DEALLOCATE PREPARE ALL { $$ = make_str("all"); }
| DEALLOCATE ALL { $$ = mm_strdup("all"); }
| DEALLOCATE PREPARE ALL { $$ = mm_strdup("all"); }
;
Iresult: Iconst { $$ = $1; }
| '(' Iresult ')' { $$ = cat_str(3, make_str("("), $2, make_str(")")); }
| Iresult '+' Iresult { $$ = cat_str(3, $1, make_str("+"), $3); }
| Iresult '-' Iresult { $$ = cat_str(3, $1, make_str("-"), $3); }
| Iresult '*' Iresult { $$ = cat_str(3, $1, make_str("*"), $3); }
| Iresult '/' Iresult { $$ = cat_str(3, $1, make_str("/"), $3); }
| Iresult '%' Iresult { $$ = cat_str(3, $1, make_str("%"), $3); }
| '(' Iresult ')' { $$ = cat_str(3, mm_strdup("("), $2, mm_strdup(")")); }
| Iresult '+' Iresult { $$ = cat_str(3, $1, mm_strdup("+"), $3); }
| Iresult '-' Iresult { $$ = cat_str(3, $1, mm_strdup("-"), $3); }
| Iresult '*' Iresult { $$ = cat_str(3, $1, mm_strdup("*"), $3); }
| Iresult '/' Iresult { $$ = cat_str(3, $1, mm_strdup("/"), $3); }
| Iresult '%' Iresult { $$ = cat_str(3, $1, mm_strdup("%"), $3); }
| ecpg_sconst { $$ = $1; }
| ColId { $$ = $1; }
;
......
src/interfaces/ecpg/preproc/extern.h
View file @ 1066dbfb
......@@ -14,7 +14,7 @@
/* defines */
#define STRUCT_DEPTH 128
#define EMPTY make_str("")
#define EMPTY mm_strdup("")
/* variables */
......@@ -62,7 +62,6 @@ extern struct ECPGstruct_member *struct_member_list[STRUCT_DEPTH];
extern const char *get_dtype(enum ECPGdtype);
extern void lex_init(void);
extern char *make_str(const char *);
extern void output_line_number(void);
extern void output_statement(char *, int, enum ECPG_statement_type);
extern void output_prepare_statement(char *, char *);
......
src/interfaces/ecpg/preproc/parse.pl
View file @ 1066dbfb
......@@ -397,7 +397,7 @@ sub dump_fields {
&add_to_buffer('rules', " \$\$=EMPTY; }");
}
else {
# Go through each field and try to 'aggregate' the tokens into a single 'make_str' where possible
# Go through each field and try to 'aggregate' the tokens into a single 'mm_strdup' where possible
$cnt = 0;
for ($z = 0; $z < $len; $z++) {
if (substr($flds{$z}, 1, 1) eq "\$") {
......@@ -410,7 +410,7 @@ sub dump_fields {
while (1) {
if ($z >= $len - 1 || substr($flds{$z + 1}, 1, 1) eq "\$") {
# We're at the end...
$flds_new{$cnt++} = "make_str(\"" . $str . "\")";
$flds_new{$cnt++} = "mm_strdup(\"" . $str . "\")";
last;
}
$z++;
......
src/interfaces/ecpg/preproc/type.c
View file @ 1066dbfb
......@@ -120,7 +120,7 @@ ECPGmake_array_type(struct ECPGtype * type, char *size)
struct ECPGtype *
ECPGmake_struct_type(struct ECPGstruct_member * rm, enum ECPGttype type, char *type_name, char *struct_sizeof)
{
struct ECPGtype *ne = ECPGmake_simple_type(type, make_str("1"), 0);
struct ECPGtype *ne = ECPGmake_simple_type(type, mm_strdup("1"), 0);
ne->type_name = mm_strdup(type_name);
ne->u.members = ECPGstruct_member_dup(rm);
......@@ -308,7 +308,7 @@ ECPGdump_a_type(FILE *o, const char *name, struct ECPGtype * type, const int bra
if (ind_type != NULL)
{
if (ind_type->type == ECPGt_NO_INDICATOR)
ECPGdump_a_simple(o, ind_name, ind_type->type, ind_type->size, make_str("-1"), NULL, ind_prefix, 0);
ECPGdump_a_simple(o, ind_name, ind_type->type, ind_type->size, mm_strdup("-1"), NULL, ind_prefix, 0);
else
{
ECPGdump_a_simple(o, ind_name, ind_type->u.element->type,
......@@ -321,7 +321,7 @@ ECPGdump_a_type(FILE *o, const char *name, struct ECPGtype * type, const int bra
if (indicator_set && ind_type->type != ECPGt_struct)
mmerror(INDICATOR_NOT_STRUCT, ET_FATAL, "indicator for struct has to be a struct");
ECPGdump_a_struct(o, name, ind_name, make_str("1"), type, ind_type, prefix, ind_prefix);
ECPGdump_a_struct(o, name, ind_name, mm_strdup("1"), type, ind_type, prefix, ind_prefix);
break;
case ECPGt_union: /* cannot dump a complete union */
base_yyerror("type of union has to be specified");
......@@ -330,25 +330,25 @@ ECPGdump_a_type(FILE *o, const char *name, struct ECPGtype * type, const int bra
if (indicator_set && (ind_type->type == ECPGt_struct || ind_type->type == ECPGt_array))
mmerror(INDICATOR_NOT_SIMPLE, ET_FATAL, "indicator for simple data type has to be simple");
ECPGdump_a_simple(o, name, type->type, make_str("1"), (arr_str_siz && strcmp(arr_str_siz, "0") != 0) ? arr_str_siz : make_str("1"), struct_sizeof, prefix, 0);
ECPGdump_a_simple(o, name, type->type, mm_strdup("1"), (arr_str_siz && strcmp(arr_str_siz, "0") != 0) ? arr_str_siz : mm_strdup("1"), struct_sizeof, prefix, 0);
if (ind_type != NULL)
ECPGdump_a_simple(o, ind_name, ind_type->type, ind_type->size, (arr_str_siz && strcmp(arr_str_siz, "0") != 0) ? arr_str_siz : make_str("-1"), ind_struct_sizeof, ind_prefix, 0);
ECPGdump_a_simple(o, ind_name, ind_type->type, ind_type->size, (arr_str_siz && strcmp(arr_str_siz, "0") != 0) ? arr_str_siz : mm_strdup("-1"), ind_struct_sizeof, ind_prefix, 0);
break;
case ECPGt_descriptor:
if (indicator_set && (ind_type->type == ECPGt_struct || ind_type->type == ECPGt_array))
mmerror(INDICATOR_NOT_SIMPLE, ET_FATAL, "indicator for simple data type has to be simple");
ECPGdump_a_simple(o, name, type->type, NULL, make_str("-1"), NULL, prefix, 0);
ECPGdump_a_simple(o, name, type->type, NULL, mm_strdup("-1"), NULL, prefix, 0);
if (ind_type != NULL)
ECPGdump_a_simple(o, ind_name, ind_type->type, ind_type->size, make_str("-1"), NULL, ind_prefix, 0);
ECPGdump_a_simple(o, ind_name, ind_type->type, ind_type->size, mm_strdup("-1"), NULL, ind_prefix, 0);
break;
default:
if (indicator_set && (ind_type->type == ECPGt_struct || ind_type->type == ECPGt_array))
mmerror(INDICATOR_NOT_SIMPLE, ET_FATAL, "indicator for simple data type has to be simple");
ECPGdump_a_simple(o, name, type->type, type->size, (arr_str_siz && strcmp(arr_str_siz, "0") != 0) ? arr_str_siz : make_str("-1"), struct_sizeof, prefix, type->counter);
ECPGdump_a_simple(o, name, type->type, type->size, (arr_str_siz && strcmp(arr_str_siz, "0") != 0) ? arr_str_siz : mm_strdup("-1"), struct_sizeof, prefix, type->counter);
if (ind_type != NULL)
ECPGdump_a_simple(o, ind_name, ind_type->type, ind_type->size, (arr_str_siz && strcmp(arr_str_siz, "0") != 0) ? arr_str_siz : make_str("-1"), ind_struct_sizeof, ind_prefix, 0);
ECPGdump_a_simple(o, ind_name, ind_type->type, ind_type->size, (arr_str_siz && strcmp(arr_str_siz, "0") != 0) ? arr_str_siz : mm_strdup("-1"), ind_struct_sizeof, ind_prefix, 0);
break;
}
}
......
src/interfaces/ecpg/preproc/variable.c
View file @ 1066dbfb
......@@ -446,7 +446,7 @@ dump_variables(struct arguments * list, int mode)
/* Then the current element and its indicator */
ECPGdump_a_type(yyout, list->variable->name, list->variable->type, list->variable->brace_level,
list->indicator->name, list->indicator->type, list->indicator->brace_level,
NULL, NULL, make_str("0"), NULL, NULL);
NULL, NULL, mm_strdup("0"), NULL, NULL);
/* Then release the list element. */
if (mode != 0)
......@@ -542,7 +542,7 @@ adjust_array(enum ECPGttype type_enum, char **dimension, char **length, char *ty
if (pointer_len)
{
*length = *dimension;
*dimension = make_str("0");
*dimension = mm_strdup("0");
}
if (atoi(*length) >= 0)
......@@ -552,13 +552,13 @@ adjust_array(enum ECPGttype type_enum, char **dimension, char **length, char *ty
case ECPGt_varchar:
/* pointer has to get dimension 0 */
if (pointer_len)
*dimension = make_str("0");
*dimension = mm_strdup("0");
/* one index is the string length */
if (atoi(*length) < 0)
{
*length = *dimension;
*dimension = make_str("-1");
*dimension = mm_strdup("-1");
}
break;
......@@ -568,13 +568,13 @@ adjust_array(enum ECPGttype type_enum, char **dimension, char **length, char *ty
/* char ** */
if (pointer_len == 2)
{
*length = *dimension = make_str("0");
*length = *dimension = mm_strdup("0");
break;
}
/* pointer has to get length 0 */
if (pointer_len == 1)
*length = make_str("0");
*length = mm_strdup("0");
/* one index is the string length */
if (atoi(*length) < 0)
......@@ -589,13 +589,13 @@ adjust_array(enum ECPGttype type_enum, char **dimension, char **length, char *ty
* do not change this for typedefs since it will be
* changed later on when the variable is defined
*/
*length = make_str("1");
*length = mm_strdup("1");
else if (strcmp(*dimension, "0") == 0)
*length = make_str("-1");
*length = mm_strdup("-1");
else
*length = *dimension;
*dimension = make_str("-1");
*dimension = mm_strdup("-1");
}
break;
default:
......@@ -603,7 +603,7 @@ adjust_array(enum ECPGttype type_enum, char **dimension, char **length, char *ty
if (pointer_len)
{
*length = *dimension;
*dimension = make_str("0");
*dimension = mm_strdup("0");
}
if (atoi(*length) >= 0)
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment