/* src/interfaces/ecpg/preproc/ecpg.addons */
ECPG: block stmt ClosePortalStmt
	{
		if (INFORMIX_MODE)
		{
			if (pg_strcasecmp(@1 + strlen("close "), "database") == 0)
			{
				if (connection)
					mmerror(PARSE_ERROR, ET_ERROR, "AT option not allowed in CLOSE DATABASE statement");

				fprintf(base_yyout, "{ ECPGdisconnect(__LINE__, \"CURRENT\");");
				whenever_action(2);
				break;
			}
		}

		output_statement(@1, 0, ECPGst_normal);
	}
ECPG: block stmt DeallocateStmt
	{
		output_deallocate_prepare_statement(@1);
	}
ECPG: block stmt DeclareCursorStmt
	{
		output_simple_statement(@1, (strncmp(@1, "ECPGset_var", strlen("ECPGset_var")) == 0) ? 4 : 0);
	}
ECPG: block stmt DiscardStmt
ECPG: block stmt FetchStmt
	{ output_statement(@1, 1, ECPGst_normal); }
ECPG: block stmt DeleteStmt
ECPG: block stmt InsertStmt
ECPG: block stmt SelectStmt
ECPG: block stmt UpdateStmt
	{ output_statement(@1, 1, ECPGst_prepnormal); }
ECPG: block stmt ExecuteStmt
	{
		check_declared_list($1.name);
		if ($1.type == NULL || strlen($1.type) == 0)
			output_statement($1.name, 1, ECPGst_execute);
		else
		{
			if ($1.name[0] != '"')
				/* case of char_variable */
				add_variable_to_tail(&argsinsert, find_variable($1.name), &no_indicator);
			else
			{
				/* case of ecpg_ident or CSTRING */
				char		length[32];
				char	   *str;

				/* Remove double quotes from name */
				str = loc_strdup($1.name + 1);
				str[strlen(str) - 1] = '\0';
				snprintf(length, sizeof(length), "%zu", strlen(str));
				add_variable_to_tail(&argsinsert, new_variable(str, ECPGmake_simple_type(ECPGt_const, length, 0), 0), &no_indicator);
			}
			output_statement(cat_str(3, "execute", "$0", $1.type), 0, ECPGst_exec_with_exprlist);
		}
	}
ECPG: block stmt PrepareStmt
	{
		check_declared_list($1.name);
		if ($1.type == NULL)
			output_prepare_statement($1.name, $1.stmt);
		else if (strlen($1.type) == 0)
		{
			char	   *stmt = cat_str(3, "\"", $1.stmt, "\"");

			output_prepare_statement($1.name, stmt);
		}
		else
		{
			if ($1.name[0] != '"')
				/* case of char_variable */
				add_variable_to_tail(&argsinsert, find_variable($1.name), &no_indicator);
			else
			{
				char		length[32];
				char	   *str;

				/* Remove double quotes from name */
				str = loc_strdup($1.name + 1);
				str[strlen(str) - 1] = '\0';
				snprintf(length, sizeof(length), "%zu", strlen(str));
				add_variable_to_tail(&argsinsert, new_variable(str, ECPGmake_simple_type(ECPGt_const, length, 0), 0), &no_indicator);
			}
			output_statement(cat_str(5, "prepare", "$0", $1.type, "as", $1.stmt), 0, ECPGst_prepare);
		}
	}
ECPG: block stmt TransactionStmt
	{
		fprintf(base_yyout, "{ ECPGtrans(__LINE__, %s, \"%s\");", connection ? connection : "NULL", @1);
		whenever_action(2);
	}
ECPG: block toplevel_stmt TransactionStmtLegacy
	{
		fprintf(base_yyout, "{ ECPGtrans(__LINE__, %s, \"%s\");", connection ? connection : "NULL", @1);
		whenever_action(2);
	}
ECPG: rule stmt ViewStmt
	| ECPGAllocateDescr
	{
		fprintf(base_yyout, "ECPGallocate_desc(__LINE__, %s);", @1);
		whenever_action(0);
	}
	| ECPGConnect
	{
		if (connection)
			mmerror(PARSE_ERROR, ET_ERROR, "AT option not allowed in CONNECT statement");

		fprintf(base_yyout, "{ ECPGconnect(__LINE__, %d, %s, %d); ", compat, @1, autocommit);
		reset_variables();
		whenever_action(2);
	}
	| ECPGDeclareStmt
	{
		output_simple_statement(@1, 0);
	}
	| ECPGCursorStmt
	{
		output_simple_statement(@1, (strncmp(@1, "ECPGset_var", strlen("ECPGset_var")) == 0) ? 4 : 0);
	}
	| ECPGDeallocateDescr
	{
		fprintf(base_yyout, "ECPGdeallocate_desc(__LINE__, %s);", @1);
		whenever_action(0);
	}
	| ECPGDeclare
	{
		output_simple_statement(@1, 0);
	}
	| ECPGDescribe
	{
		check_declared_list($1.stmt_name);

		fprintf(base_yyout, "{ ECPGdescribe(__LINE__, %d, %d, %s, %s,", compat, $1.input, connection ? connection : "NULL", $1.stmt_name);
		dump_variables(argsresult, 1);
		argsresult = NULL;
		fputs("ECPGt_EORT);", base_yyout);
		fprintf(base_yyout, "}");
		output_line_number();
	}
	| ECPGDisconnect
	{
		if (connection)
			mmerror(PARSE_ERROR, ET_ERROR, "AT option not allowed in DISCONNECT statement");

		fprintf(base_yyout, "{ ECPGdisconnect(__LINE__, %s);",
				@1 ? @1 : "\"CURRENT\"");
		whenever_action(2);
	}
	| ECPGExecuteImmediateStmt
	{
		output_statement(@1, 0, ECPGst_exec_immediate);
	}
	| ECPGFree
	{
		const char *con = connection ? connection : "NULL";

		if (strcmp(@1, "all") == 0)
			fprintf(base_yyout, "{ ECPGdeallocate_all(__LINE__, %d, %s);", compat, con);
		else if (@1[0] == ':')
			fprintf(base_yyout, "{ ECPGdeallocate(__LINE__, %d, %s, %s);", compat, con, @1 + 1);
		else
			fprintf(base_yyout, "{ ECPGdeallocate(__LINE__, %d, %s, \"%s\");", compat, con, @1);

		whenever_action(2);
	}
	| ECPGGetDescriptor
	{
		lookup_descriptor($1.name, connection);
		output_get_descr($1.name, $1.str);
	}
	| ECPGGetDescriptorHeader
	{
		lookup_descriptor(@1, connection);
		output_get_descr_header(@1);
	}
	| ECPGOpen
	{
		struct cursor *ptr;

		if ((ptr = add_additional_variables(@1, true)) != NULL)
		{
			free(connection);
			connection = ptr->connection ? mm_strdup(ptr->connection) : NULL;
			output_statement(ptr->command, 0, ECPGst_normal);
			ptr->opened = true;
		}
	}
	| ECPGSetAutocommit
	{
		fprintf(base_yyout, "{ ECPGsetcommit(__LINE__, \"%s\", %s);", @1, connection ? connection : "NULL");
		whenever_action(2);
	}
	| ECPGSetConnection
	{
		if (connection)
			mmerror(PARSE_ERROR, ET_ERROR, "AT option not allowed in SET CONNECTION statement");

		fprintf(base_yyout, "{ ECPGsetconn(__LINE__, %s);", @1);
		whenever_action(2);
	}
	| ECPGSetDescriptor
	{
		lookup_descriptor($1.name, connection);
		output_set_descr($1.name, $1.str);
	}
	| ECPGSetDescriptorHeader
	{
		lookup_descriptor(@1, connection);
		output_set_descr_header(@1);
	}
	| ECPGTypedef
	{
		if (connection)
			mmerror(PARSE_ERROR, ET_ERROR, "AT option not allowed in TYPE statement");

		fprintf(base_yyout, "%s", @1);
		output_line_number();
	}
	| ECPGVar
	{
		if (connection)
			mmerror(PARSE_ERROR, ET_ERROR, "AT option not allowed in VAR statement");

		output_simple_statement(@1, 0);
	}
	| ECPGWhenever
	{
		if (connection)
			mmerror(PARSE_ERROR, ET_ERROR, "AT option not allowed in WHENEVER statement");

		output_simple_statement(@1, 0);
	}
ECPG: block where_or_current_clause WHERE CURRENT_P OF cursor_name
	{
		const char *cursor_marker = @4[0] == ':' ? "$0" : @4;

		@$ = cat_str(2, "where current of", cursor_marker);
	}
ECPG: addon CopyStmt COPY opt_binary qualified_name opt_column_list copy_from opt_program copy_file_name copy_delimiter opt_with copy_options where_clause
		if (strcmp(@5, "from") == 0 &&
			(strcmp(@7, "stdin") == 0 || strcmp(@7, "stdout") == 0))
			mmerror(PARSE_ERROR, ET_WARNING, "COPY FROM STDIN is not implemented");
ECPG: addon var_value NumericOnly
		if (@1[0] == '$')
			@$ = "$0";
ECPG: addon fetch_args cursor_name
		struct cursor *ptr = add_additional_variables(@1, false);

		update_connection(ptr->connection);
		if (@1[0] == ':')
			@$ = "$0";
ECPG: addon fetch_args from_in cursor_name
		struct cursor *ptr = add_additional_variables(@2, false);

		update_connection(ptr->connection);
		if (@2[0] == ':')
			@$ = cat2_str(@1, "$0");
ECPG: addon fetch_args NEXT opt_from_in cursor_name
ECPG: addon fetch_args PRIOR opt_from_in cursor_name
ECPG: addon fetch_args FIRST_P opt_from_in cursor_name
ECPG: addon fetch_args LAST_P opt_from_in cursor_name
ECPG: addon fetch_args ALL opt_from_in cursor_name
		struct cursor *ptr = add_additional_variables(@3, false);

		update_connection(ptr->connection);
		if (@3[0] == ':')
			@$ = cat_str(3, @1, @2, "$0");
ECPG: addon fetch_args SignedIconst opt_from_in cursor_name
		struct cursor *ptr = add_additional_variables(@3, false);
		bool	replace = false;

		update_connection(ptr->connection);
		if (@3[0] == ':')
		{
			@3 = "$0";
			replace = true;
		}
		if (@1[0] == '$')
		{
			@1 = "$0";
			replace = true;
		}
		if (replace)
			@$ = cat_str(3, @1, @2, @3);
ECPG: addon fetch_args FORWARD ALL opt_from_in cursor_name
ECPG: addon fetch_args BACKWARD ALL opt_from_in cursor_name
		struct cursor *ptr = add_additional_variables(@4, false);

		update_connection(ptr->connection);
		if (@4[0] == ':')
			@$ = cat_str(4, @1, @2, @3, "$0");
ECPG: addon fetch_args ABSOLUTE_P SignedIconst opt_from_in cursor_name
ECPG: addon fetch_args RELATIVE_P SignedIconst opt_from_in cursor_name
ECPG: addon fetch_args FORWARD SignedIconst opt_from_in cursor_name
ECPG: addon fetch_args BACKWARD SignedIconst opt_from_in cursor_name
		struct cursor *ptr = add_additional_variables(@4, false);
		bool	replace = false;

		update_connection(ptr->connection);
		if (@4[0] == ':')
		{
			@4 = "$0";
			replace = true;
		}
		if (@2[0] == '$')
		{
			@2 = "$0";
			replace = true;
		}
		if (replace)
			@$ = cat_str(4, @1, @2, @3, @4);
ECPG: block cursor_name name
	| char_civar
	{
		char	   *curname = loc_alloc(strlen(@1) + 2);

		sprintf(curname, ":%s", @1);
		@$ = curname;
	}
ECPG: block ExplainableStmt ExecuteStmt
	{
		@$ = $1.name;
	}
ECPG: block PrepareStmt PREPARE prepared_name prep_type_clause AS PreparableStmt
	{
		$$.name = @2;
		$$.type = @3;
		$$.stmt = @5;
	}
	| PREPARE prepared_name FROM execstring
	{
		$$.name = @2;
		$$.type = NULL;
		$$.stmt = @4;
	}
ECPG: block ExecuteStmt EXECUTE prepared_name execute_param_clause execute_rest
	{
		$$.name = @2;
		$$.type = @3;
	}
ECPG: block ExecuteStmt CREATE OptTemp TABLE create_as_target AS EXECUTE prepared_name execute_param_clause opt_with_data execute_rest
	{
		$$.name = @$;
	}
ECPG: block ExecuteStmt CREATE OptTemp TABLE IF_P NOT EXISTS create_as_target AS EXECUTE prepared_name execute_param_clause opt_with_data execute_rest
	{
		$$.name = @$;
	}
ECPG: block DeclareCursorStmt DECLARE cursor_name cursor_options CURSOR opt_hold FOR SelectStmt
	{
		struct cursor *ptr,
				   *this;
		const char *cursor_marker = @2[0] == ':' ? "$0" : @2;
		char	   *comment,
				   *c1,
				   *c2;
		int			(*strcmp_fn) (const char *, const char *) = ((@2[0] == ':' || @2[0] == '"') ? strcmp : pg_strcasecmp);

		if (INFORMIX_MODE && pg_strcasecmp(@2, "database") == 0)
			mmfatal(PARSE_ERROR, "\"database\" cannot be used as cursor name in INFORMIX mode");

		for (ptr = cur; ptr != NULL; ptr = ptr->next)
		{
			if (strcmp_fn(@2, ptr->name) == 0)
			{
				if (@2[0] == ':')
					mmerror(PARSE_ERROR, ET_ERROR, "using variable \"%s\" in different declare statements is not supported", @2 + 1);
				else
					mmerror(PARSE_ERROR, ET_ERROR, "cursor \"%s\" is already defined", @2);
			}
		}

		this = (struct cursor *) mm_alloc(sizeof(struct cursor));

		this->next = cur;
		this->name = mm_strdup(@2);
		this->function = (current_function ? mm_strdup(current_function) : NULL);
		this->connection = connection ? mm_strdup(connection) : NULL;
		this->opened = false;
		this->command = mm_strdup(cat_str(7, "declare", cursor_marker, @3, "cursor", @5, "for", @7));
		this->argsinsert = argsinsert;
		this->argsinsert_oos = NULL;
		this->argsresult = argsresult;
		this->argsresult_oos = NULL;
		argsinsert = argsresult = NULL;
		cur = this;

		c1 = loc_strdup(this->command);
		while ((c2 = strstr(c1, "*/")) != NULL)
		{
			/* We put this text into a comment, so we better remove [*][/]. */
			c2[0] = '.';
			c2[1] = '.';
		}
		comment = cat_str(3, "/*", c1, "*/");

		@$ = cat2_str(adjust_outofscope_cursor_vars(this), comment);
	}
ECPG: block ClosePortalStmt CLOSE cursor_name
	{
		const char *cursor_marker = @2[0] == ':' ? "$0" : @2;
		struct cursor *ptr = NULL;

		for (ptr = cur; ptr != NULL; ptr = ptr->next)
		{
			if (strcmp(@2, ptr->name) == 0)
			{
				update_connection(ptr->connection);
				break;
			}
		}
		@$ = cat2_str("close", cursor_marker);
	}
ECPG: block opt_hold
	{
		if (compat == ECPG_COMPAT_INFORMIX_SE && autocommit)
			@$ = "with hold";
		else
			@$ = "";
	}
ECPG: block into_clause INTO OptTempTableName
	{
		FoundInto = 1;
		@$ = cat2_str("into", @2);
	}
	| ecpg_into
	{
		@$ = "";
	}
ECPG: block Typename SimpleTypename opt_array_bounds
	{
		@$ = cat2_str(@1, $2.str);
	}
ECPG: block Typename SETOF SimpleTypename opt_array_bounds
	{
		@$ = cat_str(3, "setof", @2, $3.str);
	}
ECPG: block opt_array_bounds opt_array_bounds '[' ']'
	{
		$$.index1 = $1.index1;
		$$.index2 = $1.index2;
		if (strcmp($$.index1, "-1") == 0)
			$$.index1 = "0";
		else if (strcmp($1.index2, "-1") == 0)
			$$.index2 = "0";
		$$.str = cat_str(2, $1.str, "[]");
	}
	| opt_array_bounds '[' Iresult ']'
	{
		$$.index1 = $1.index1;
		$$.index2 = $1.index2;
		if (strcmp($1.index1, "-1") == 0)
			$$.index1 = @3;
		else if (strcmp($1.index2, "-1") == 0)
			$$.index2 = @3;
		$$.str = cat_str(4, $1.str, "[", @3, "]");
	}
ECPG: block opt_array_bounds
	{
		$$.index1 = "-1";
		$$.index2 = "-1";
		$$.str = "";
	}
ECPG: rule AexprConst NULL_P
	| civar
	| civarind
ECPG: block VariableShowStmt SHOW ALL
	{
		mmerror(PARSE_ERROR, ET_ERROR, "SHOW ALL is not implemented");
	}
ECPG: rule FetchStmt MOVE fetch_args
	| FETCH fetch_args ecpg_fetch_into
	| FETCH FORWARD cursor_name opt_ecpg_fetch_into
	{
		const char *cursor_marker = @3[0] == ':' ? "$0" : @3;
		struct cursor *ptr = add_additional_variables(@3, false);

		update_connection(ptr->connection);

		@$ = cat_str(2, "fetch forward", cursor_marker);
	}
	| FETCH FORWARD from_in cursor_name opt_ecpg_fetch_into
	{
		const char *cursor_marker = @4[0] == ':' ? "$0" : @4;
		struct cursor *ptr = add_additional_variables(@4, false);

		update_connection(ptr->connection);

		@$ = cat_str(2, "fetch forward from", cursor_marker);
	}
	| FETCH BACKWARD cursor_name opt_ecpg_fetch_into
	{
		const char *cursor_marker = @3[0] == ':' ? "$0" : @3;
		struct cursor *ptr = add_additional_variables(@3, false);

		update_connection(ptr->connection);

		@$ = cat_str(2, "fetch backward", cursor_marker);
	}
	| FETCH BACKWARD from_in cursor_name opt_ecpg_fetch_into
	{
		const char *cursor_marker = @4[0] == ':' ? "$0" : @4;
		struct cursor *ptr = add_additional_variables(@4, false);

		update_connection(ptr->connection);

		@$ = cat_str(2, "fetch backward from", cursor_marker);
	}
	| MOVE FORWARD cursor_name
	{
		const char *cursor_marker = @3[0] == ':' ? "$0" : @3;
		struct cursor *ptr = add_additional_variables(@3, false);

		update_connection(ptr->connection);

		@$ = cat_str(2, "move forward", cursor_marker);
	}
	| MOVE FORWARD from_in cursor_name
	{
		const char *cursor_marker = @4[0] == ':' ? "$0" : @4;
		struct cursor *ptr = add_additional_variables(@4, false);

		update_connection(ptr->connection);

		@$ = cat_str(2, "move forward from", cursor_marker);
	}
	| MOVE BACKWARD cursor_name
	{
		const char *cursor_marker = @3[0] == ':' ? "$0" : @3;
		struct cursor *ptr = add_additional_variables(@3, false);

		update_connection(ptr->connection);

		@$ = cat_str(2, "move backward", cursor_marker);
	}
	| MOVE BACKWARD from_in cursor_name
	{
		const char *cursor_marker = @4[0] == ':' ? "$0" : @4;
		struct cursor *ptr = add_additional_variables(@4, false);

		update_connection(ptr->connection);

		@$ = cat_str(2, "move backward from", cursor_marker);
	}
ECPG: block limit_clause LIMIT select_limit_value ',' select_offset_value
	{
		mmerror(PARSE_ERROR, ET_WARNING, "no longer supported LIMIT #,# syntax passed to server");
	}
ECPG: rule SignedIconst Iconst
	| civar