/* src/interfaces/ecpg/preproc/ecpg.trailer */

statements: /* EMPTY */
	| statements statement
	{
		/* Reclaim local storage used while processing statement */
		reclaim_local_storage();
		/* Clean up now-dangling location pointer */
		@$ = "";
	}
	;

statement: ecpgstart at toplevel_stmt ';'
	{
		if (connection)
			free(connection);
		connection = NULL;
	}
	| ecpgstart toplevel_stmt ';'
	{
		if (connection)
			free(connection);
		connection = NULL;
	}
	| ecpgstart ECPGVarDeclaration
	{
		fprintf(base_yyout, "%s", @$);
		output_line_number();
	}
	| ECPGDeclaration
	| c_thing
	{
		fprintf(base_yyout, "%s", @$);
	}
	| CPP_LINE
	{
		fprintf(base_yyout, "%s", @$);
	}
	| '{'
	{
		braces_open++;
		fputs("{", base_yyout);
	}
	| '}'
	{
		if (braces_open > 0)
		{
			remove_typedefs(braces_open);
			remove_variables(braces_open);
			if (--braces_open == 0)
			{
				free(current_function);
				current_function = NULL;
			}
		}
		fputs("}", base_yyout);
	}
	;

CreateAsStmt: CREATE OptTemp TABLE create_as_target AS
	{
		FoundInto = 0;
	} SelectStmt opt_with_data
	{
		if (FoundInto == 1)
			mmerror(PARSE_ERROR, ET_ERROR, "CREATE TABLE AS cannot specify INTO");
	}
	| CREATE OptTemp TABLE IF_P NOT EXISTS create_as_target AS
	{
		FoundInto = 0;
	} SelectStmt opt_with_data
	{
		if (FoundInto == 1)
			mmerror(PARSE_ERROR, ET_ERROR, "CREATE TABLE AS cannot specify INTO");
	}
	;

at: AT connection_object
	{
		if (connection)
			free(connection);
		connection = mm_strdup(@2);

		/*
		 * Do we have a variable as connection target?  Remove the variable
		 * from the variable list or else it will be used twice.
		 */
		if (argsinsert != NULL)
			argsinsert = NULL;
	}
	;

/*
 * 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, ",", @5, ",", @4);
	}
	| SQL_CONNECT TO DEFAULT
	{
		@$ = "NULL, NULL, NULL, \"DEFAULT\"";
	}
	/* also allow ORACLE syntax */
	| SQL_CONNECT ora_user
	{
		@$ = cat_str(3, "NULL,", @2, ", NULL");
	}
	| DATABASE connection_target
	{
		@$ = cat2_str(@2, ", NULL, NULL, NULL");
	}
	;

connection_target: opt_database_name opt_server opt_port
	{
		/* old style: dbname[@server][:port] */
		if (strlen(@2) > 0 && *(@2) != '@')
			mmerror(PARSE_ERROR, ET_ERROR, "expected \"@\", found \"%s\"", @2);

		/* C strings need to be handled differently */
		if (@1[0] == '\"')
			@$ = @1;
		else
			@$ = make3_str("\"", make3_str(@1, @2, @3), "\"");
	}
	| db_prefix ':' server opt_port '/' opt_database_name opt_options
	{
		/* new style: <tcp|unix>:postgresql://server[:port][/dbname] */
		if (strncmp(@1, "unix:postgresql", strlen("unix:postgresql")) != 0 && strncmp(@1, "tcp:postgresql", strlen("tcp:postgresql")) != 0)
			mmerror(PARSE_ERROR, ET_ERROR, "only protocols \"tcp\" and \"unix\" and database type \"postgresql\" are supported");

		if (strncmp(@3, "//", strlen("//")) != 0)
			mmerror(PARSE_ERROR, ET_ERROR, "expected \"://\", found \"%s\"", @3);

		if (strncmp(@1, "unix", strlen("unix")) == 0 &&
			strncmp(@3 + strlen("//"), "localhost", strlen("localhost")) != 0 &&
			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("\"", @1, ":"), @3, make3_str(make3_str(@4, "/", @6), @7, "\""));
	}
	| char_variable
	| ecpg_sconst
	{
		/*
		 * We can only process double quoted strings not single quoted ones,
		 * so we change the quotes. Note that the rule for ecpg_sconst adds
		 * these single quotes.
		 */
		char   *str = loc_strdup(@1);

		str[0] = '\"';
		str[strlen(str) - 1] = '\"';
		@$ = str;
	}
	;

opt_database_name: name
	| /* EMPTY */
	;

db_prefix: ecpg_ident cvariable
	{
		if (strcmp(@2, "postgresql") != 0 && strcmp(@2, "postgres") != 0)
			mmerror(PARSE_ERROR, ET_ERROR, "expected \"postgresql\", found \"%s\"", @2);

		if (strcmp(@1, "tcp") != 0 && strcmp(@1, "unix") != 0)
			mmerror(PARSE_ERROR, ET_ERROR, "invalid connection type: %s", @1);

		@$ = make3_str(@1, ":", @2);
	}
	;

server: Op server_name
	{
		if (strcmp(@1, "@") != 0 && strcmp(@1, "//") != 0)
			mmerror(PARSE_ERROR, ET_ERROR, "expected \"@\" or \"://\", found \"%s\"", @1);

		@$ = make2_str(@1, @2);
	}
	;

opt_server: server
	| /* EMPTY */
	;

server_name: ColId
	| ColId '.' server_name
	| IP
	;

opt_port: ':' Iconst
	{
		@$ = make2_str(":", @2);
	}
	| /* EMPTY */
	;

opt_connection_name: AS connection_object
	{
		@$ = @2;
	}
	| /* EMPTY */
	{
		@$ = "NULL";
	}
	;

opt_user: USER ora_user
	{
		@$ = @2;
	}
	| /* EMPTY */
	{
		@$ = "NULL, NULL";
	}
	;

ora_user: user_name
	{
		@$ = cat2_str(@1, ", NULL");
	}
	| user_name '/' user_name
	{
		@$ = cat_str(3, @1, ",", @3);
	}
	| user_name SQL_IDENTIFIED BY user_name
	{
		@$ = cat_str(3, @1, ",", @4);
	}
	| user_name USING user_name
	{
		@$ = cat_str(3, @1, ",", @3);
	}
	;

user_name: RoleId
	{
		if (@1[0] == '\"')
			@$ = @1;
		else
			@$ = make3_str("\"", @1, "\"");
	}
	| ecpg_sconst
	{
		if (@1[0] == '\"')
			@$ = @1;
		else
			@$ = make3_str("\"", @1, "\"");
	}
	| civar
	{
		enum ECPGttype type = argsinsert->variable->type->type;

		/* if array see what's inside */
		if (type == ECPGt_array)
			type = argsinsert->variable->type->u.element->type;

		/* handle varchars */
		if (type == ECPGt_varchar)
			@$ = make2_str(argsinsert->variable->name, ".arr");
		else
			@$ = argsinsert->variable->name;
	}
	;

char_variable: cvariable
	{
		/* check if we have a string variable */
		struct variable *p = find_variable(@1);
		enum ECPGttype type = p->type->type;

		/* If we have just one character this is not a string */
		if (atol(p->type->size) == 1)
			mmerror(PARSE_ERROR, ET_ERROR, "invalid data type");
		else
		{
			/* if array see what's inside */
			if (type == ECPGt_array)
				type = p->type->u.element->type;

			switch (type)
			{
				case ECPGt_char:
				case ECPGt_unsigned_char:
				case ECPGt_string:
					@$ = @1;
					break;
				case ECPGt_varchar:
					@$ = make2_str(@1, ".arr");
					break;
				default:
					mmerror(PARSE_ERROR, ET_ERROR, "invalid data type");
					@$ = @1;
					break;
			}
		}
	}
	;

opt_options: Op connect_options
	{
		if (strlen(@1) == 0)
			mmerror(PARSE_ERROR, ET_ERROR, "incomplete statement");

		if (strcmp(@1, "?") != 0)
			mmerror(PARSE_ERROR, ET_ERROR, "unrecognized token \"%s\"", @1);

		@$ = make2_str("?", @2);
	}
	| /* EMPTY */
	;

connect_options: ColId opt_opt_value
	{
		@$ = make2_str(@1, @2);
	}
	| ColId opt_opt_value Op connect_options
	{
		if (strlen(@3) == 0)
			mmerror(PARSE_ERROR, ET_ERROR, "incomplete statement");

		if (strcmp(@3, "&") != 0)
			mmerror(PARSE_ERROR, ET_ERROR, "unrecognized token \"%s\"", @3);

		@$ = make3_str(make2_str(@1, @2), @3, @4);
	}
	;

opt_opt_value: /* EMPTY */
	| '=' Iconst
	{
		@$ = make2_str("=", @2);
	}
	| '=' ecpg_ident
	{
		@$ = make2_str("=", @2);
	}
	| '=' civar
	{
		@$ = make2_str("=", @2);
	}
	;

prepared_name: name
	{
		size_t		slen = strlen(@1);

		if (@1[0] == '\"' && @1[slen - 1] == '\"')	/* already quoted? */
			@$ = @1;
		else					/* not quoted => convert to lowercase */
		{
			char	   *str = loc_alloc(slen + 3);

			str[0] = '\"';
			for (size_t i = 0; i < slen; i++)
				str[i + 1] = tolower((unsigned char) @1[i]);
			str[slen + 1] = '\"';
			str[slen + 2] = '\0';
			@$ = str;
		}
	}
	| char_variable
	;

/*
 * Declare Statement
 */
ECPGDeclareStmt: DECLARE prepared_name STATEMENT
	{
		struct declared_list *ptr;

		/* Check whether the declared name has been defined or not */
		for (ptr = g_declared_list; ptr != NULL; ptr = ptr->next)
		{
			if (strcmp(@2, ptr->name) == 0)
			{
				/* re-definition is not allowed */
				mmerror(PARSE_ERROR, ET_ERROR, "name \"%s\" is already declared", ptr->name);
			}
		}

		/* Add a new declared name into the g_declared_list */
		ptr = (struct declared_list *) mm_alloc(sizeof(struct declared_list));
		if (ptr)
		{
			/* initial definition */
			ptr->name = mm_strdup(@2);
			if (connection)
				ptr->connection = mm_strdup(connection);
			else
				ptr->connection = NULL;

			ptr->next = g_declared_list;
			g_declared_list = ptr;
		}

		@$ = cat_str(3, "/* declare ", @2, " as an SQL identifier */");
	}
	;

/*
 * Declare a prepared cursor. The syntax is different from the standard
 * declare statement, so we create a new rule.
 */
ECPGCursorStmt: DECLARE cursor_name cursor_options CURSOR opt_hold FOR prepared_name
	{
		struct cursor *ptr,
				   *this;
		const char *cursor_marker = @2[0] == ':' ? "$0" : @2;
		int			(*strcmp_fn) (const char *, const char *) = ((@2[0] == ':' || @2[0] == '"') ? strcmp : pg_strcasecmp);
		struct variable *thisquery = (struct variable *) mm_alloc(sizeof(struct variable));
		char	   *comment;
		char	   *con;

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

		check_declared_list(@7);
		con = connection ? connection : "NULL";
		for (ptr = cur; ptr != NULL; ptr = ptr->next)
		{
			if (strcmp_fn(@2, ptr->name) == 0)
			{
				/* re-definition is a bug */
				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));

		/* initial definition */
		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(6, "declare", cursor_marker, @3, "cursor", @5, "for $1"));
		this->argsresult = NULL;
		this->argsresult_oos = NULL;

		thisquery->type = &ecpg_query;
		thisquery->brace_level = 0;
		thisquery->next = NULL;
		thisquery->name = (char *) mm_alloc(sizeof("ECPGprepared_statement(, , __LINE__)") + strlen(con) + strlen(@7));
		sprintf(thisquery->name, "ECPGprepared_statement(%s, %s, __LINE__)", con, @7);

		this->argsinsert = NULL;
		this->argsinsert_oos = NULL;
		if (@2[0] == ':')
		{
			struct variable *var = find_variable(@2 + 1);

			remove_variable_from_list(&argsinsert, var);
			add_variable_to_head(&(this->argsinsert), var, &no_indicator);
		}
		add_variable_to_head(&(this->argsinsert), thisquery, &no_indicator);

		cur = this;

		comment = cat_str(3, "/*", this->command, "*/");

		@$ = cat_str(2, adjust_outofscope_cursor_vars(this),
					 comment);
	}
	;

ECPGExecuteImmediateStmt: EXECUTE IMMEDIATE execstring
	{
		/*
		 * execute immediate means prepare the statement and immediately
		 * execute it
		 */
		@$ = @3;
	}
	;

/*
 * variable declaration outside exec sql declare block
 */
ECPGVarDeclaration: single_vt_declaration;

single_vt_declaration: type_declaration
	| var_declaration
	;

precision: NumericOnly
	;

opt_scale: ',' NumericOnly
	{
		@$ = @2;
	}
	| /* EMPTY */
	;

ecpg_interval: opt_interval
	| YEAR_P TO MINUTE_P
	| YEAR_P TO SECOND_P
	| DAY_P TO DAY_P
	| MONTH_P TO MONTH_P
	;

/*
 * variable declaration inside exec sql declare block
 */
ECPGDeclaration: sql_startdeclare
	{
		fputs("/* exec sql begin declare section */", base_yyout);
	}
	var_type_declarations sql_enddeclare
	{
		fprintf(base_yyout, "%s/* exec sql end declare section */", @3);
		output_line_number();
	}
	;

sql_startdeclare: ecpgstart BEGIN_P DECLARE SQL_SECTION ';'
	{
	}
	;

sql_enddeclare: ecpgstart END_P DECLARE SQL_SECTION ';'
	{
	}
	;

var_type_declarations: /* EMPTY */
	| vt_declarations
	;

vt_declarations: single_vt_declaration
	| CPP_LINE
	| vt_declarations single_vt_declaration
	| vt_declarations CPP_LINE
	;

variable_declarations: var_declaration
	| variable_declarations var_declaration
	;

type_declaration: S_TYPEDEF
	{
		/* reset this variable so we see if there was */
		/* an initializer specified */
		initializer = 0;
	}
	var_type	opt_pointer ECPGColLabel opt_array_bounds ';'
	{
		add_typedef(@5, $6.index1, $6.index2, $3.type_enum, $3.type_dimension, $3.type_index, initializer, *@4 ? 1 : 0);

		fprintf(base_yyout, "typedef %s %s %s %s;\n", $3.type_str, *@4 ? "*" : "", @5, $6.str);
		output_line_number();
		@$ = "";
	}
	;

var_declaration:
	storage_declaration var_type
	{
		actual_type[struct_level].type_storage = loc_strdup(@1);
		actual_type[struct_level].type_enum = $2.type_enum;
		actual_type[struct_level].type_str = $2.type_str;
		actual_type[struct_level].type_dimension = $2.type_dimension;
		actual_type[struct_level].type_index = $2.type_index;
		actual_type[struct_level].type_sizeof = $2.type_sizeof;

		actual_startline[struct_level] = hashline_number();
	}
	variable_list ';'
	{
		@$ = cat_str(5, actual_startline[struct_level], @1, $2.type_str, @4, ";\n");
	}
	| var_type
	{
		actual_type[struct_level].type_storage = loc_strdup("");
		actual_type[struct_level].type_enum = $1.type_enum;
		actual_type[struct_level].type_str = $1.type_str;
		actual_type[struct_level].type_dimension = $1.type_dimension;
		actual_type[struct_level].type_index = $1.type_index;
		actual_type[struct_level].type_sizeof = $1.type_sizeof;

		actual_startline[struct_level] = hashline_number();
	}
	variable_list ';'
	{
		@$ = cat_str(4, actual_startline[struct_level], $1.type_str, @3, ";\n");
	}
	| struct_union_type_with_symbol ';'
	;

opt_bit_field: ':' Iconst
	| /* EMPTY */
	;

storage_declaration: storage_clause storage_modifier
	| storage_clause
	| storage_modifier
	;

storage_clause: S_EXTERN
	| S_STATIC
	| S_REGISTER
	| S_AUTO
	;

storage_modifier: S_CONST
	| S_VOLATILE
	;

var_type: simple_type
	{
		$$.type_enum = $1;
		$$.type_str = loc_strdup(ecpg_type_name($1));
		$$.type_dimension = "-1";
		$$.type_index = "-1";
		$$.type_sizeof = NULL;
	}
	| struct_union_type
	{
		$$.type_str = loc_strdup(@1);
		$$.type_dimension = "-1";
		$$.type_index = "-1";

		if (strncmp(@1, "struct", sizeof("struct") - 1) == 0)
		{
			$$.type_enum = ECPGt_struct;
			$$.type_sizeof = ECPGstruct_sizeof;
		}
		else
		{
			$$.type_enum = ECPGt_union;
			$$.type_sizeof = NULL;
		}
	}
	| enum_type
	{
		$$.type_str = loc_strdup(@1);
		$$.type_enum = ECPGt_int;
		$$.type_dimension = "-1";
		$$.type_index = "-1";
		$$.type_sizeof = NULL;
	}
	| NUMERIC '(' precision opt_scale ')'
	{
		$$.type_enum = ECPGt_numeric;
		$$.type_str = "numeric";
		$$.type_dimension = "-1";
		$$.type_index = "-1";
		$$.type_sizeof = NULL;
	}
	| DECIMAL_P '(' precision opt_scale ')'
	{
		$$.type_enum = ECPGt_decimal;
		$$.type_str = "decimal";
		$$.type_dimension = "-1";
		$$.type_index = "-1";
		$$.type_sizeof = NULL;
	}
	| IDENT '(' precision opt_scale ')'
	{
		/*
		 * In C parsing mode, NUMERIC and DECIMAL are not keywords, so they
		 * will show up here as a plain identifier, and we need this duplicate
		 * code to recognize them.
		 */
		if (strcmp(@1, "numeric") == 0)
		{
			$$.type_enum = ECPGt_numeric;
			$$.type_str = "numeric";
		}
		else if (strcmp(@1, "decimal") == 0)
		{
			$$.type_enum = ECPGt_decimal;
			$$.type_str = "decimal";
		}
		else
		{
			mmerror(PARSE_ERROR, ET_ERROR, "only data types numeric and decimal have precision/scale argument");
			$$.type_enum = ECPGt_numeric;
			$$.type_str = "numeric";
		}

		$$.type_dimension = "-1";
		$$.type_index = "-1";
		$$.type_sizeof = NULL;
	}
	| VARCHAR
	{
		$$.type_enum = ECPGt_varchar;
		$$.type_str = "";	/* "varchar"; */
		$$.type_dimension = "-1";
		$$.type_index = "-1";
		$$.type_sizeof = NULL;
	}
	| FLOAT_P
	{
		/* Note: DOUBLE is handled in simple_type */
		$$.type_enum = ECPGt_float;
		$$.type_str = "float";
		$$.type_dimension = "-1";
		$$.type_index = "-1";
		$$.type_sizeof = NULL;
	}
	| NUMERIC
	{
		$$.type_enum = ECPGt_numeric;
		$$.type_str = "numeric";
		$$.type_dimension = "-1";
		$$.type_index = "-1";
		$$.type_sizeof = NULL;
	}
	| DECIMAL_P
	{
		$$.type_enum = ECPGt_decimal;
		$$.type_str = "decimal";
		$$.type_dimension = "-1";
		$$.type_index = "-1";
		$$.type_sizeof = NULL;
	}
	| TIMESTAMP
	{
		$$.type_enum = ECPGt_timestamp;
		$$.type_str = "timestamp";
		$$.type_dimension = "-1";
		$$.type_index = "-1";
		$$.type_sizeof = NULL;
	}
	| STRING_P
	{
		if (INFORMIX_MODE)
		{
			/* In Informix mode, "string" is automatically a typedef */
			$$.type_enum = ECPGt_string;
			$$.type_str = "char";
			$$.type_dimension = "-1";
			$$.type_index = "-1";
			$$.type_sizeof = NULL;
		}
		else
		{
			/* Otherwise, legal only if user typedef'ed it */
			struct typedefs *this = get_typedef("string", false);

			$$.type_str = (this->type->type_enum == ECPGt_varchar || this->type->type_enum == ECPGt_bytea) ? mm_strdup("") : mm_strdup(this->name);
			$$.type_enum = this->type->type_enum;
			$$.type_dimension = this->type->type_dimension;
			$$.type_index = this->type->type_index;
			if (this->type->type_sizeof && strlen(this->type->type_sizeof) != 0)
				$$.type_sizeof = this->type->type_sizeof;
			else
				$$.type_sizeof = cat_str(3, "sizeof(", this->name, ")");

			ECPGfree_struct_member(struct_member_list[struct_level]);
			struct_member_list[struct_level] = ECPGstruct_member_dup(this->struct_member_list);
		}
	}
	| INTERVAL ecpg_interval
	{
		$$.type_enum = ECPGt_interval;
		$$.type_str = "interval";
		$$.type_dimension = "-1";
		$$.type_index = "-1";
		$$.type_sizeof = NULL;
	}
	| IDENT ecpg_interval
	{
		/*
		 * In C parsing mode, the above SQL type names are not keywords, so
		 * they will show up here as a plain identifier, and we need this
		 * duplicate code to recognize them.
		 *
		 * Note that we also handle the type names bytea, date, and datetime
		 * here, but not above because those are not currently SQL keywords.
		 * If they ever become so, they must gain duplicate productions above.
		 */
		if (strlen(@2) != 0 && strcmp(@1, "datetime") != 0 && strcmp(@1, "interval") != 0)
			mmerror(PARSE_ERROR, ET_ERROR, "interval specification not allowed here");

		if (strcmp(@1, "varchar") == 0)
		{
			$$.type_enum = ECPGt_varchar;
			$$.type_str = "";	/* "varchar"; */
			$$.type_dimension = "-1";
			$$.type_index = "-1";
			$$.type_sizeof = NULL;
		}
		else if (strcmp(@1, "bytea") == 0)
		{
			$$.type_enum = ECPGt_bytea;
			$$.type_str = "";
			$$.type_dimension = "-1";
			$$.type_index = "-1";
			$$.type_sizeof = NULL;
		}
		else if (strcmp(@1, "float") == 0)
		{
			$$.type_enum = ECPGt_float;
			$$.type_str = "float";
			$$.type_dimension = "-1";
			$$.type_index = "-1";
			$$.type_sizeof = NULL;
		}
		else if (strcmp(@1, "double") == 0)
		{
			$$.type_enum = ECPGt_double;
			$$.type_str = "double";
			$$.type_dimension = "-1";
			$$.type_index = "-1";
			$$.type_sizeof = NULL;
		}
		else if (strcmp(@1, "numeric") == 0)
		{
			$$.type_enum = ECPGt_numeric;
			$$.type_str = "numeric";
			$$.type_dimension = "-1";
			$$.type_index = "-1";
			$$.type_sizeof = NULL;
		}
		else if (strcmp(@1, "decimal") == 0)
		{
			$$.type_enum = ECPGt_decimal;
			$$.type_str = "decimal";
			$$.type_dimension = "-1";
			$$.type_index = "-1";
			$$.type_sizeof = NULL;
		}
		else if (strcmp(@1, "date") == 0)
		{
			$$.type_enum = ECPGt_date;
			$$.type_str = "date";
			$$.type_dimension = "-1";
			$$.type_index = "-1";
			$$.type_sizeof = NULL;
		}
		else if (strcmp(@1, "timestamp") == 0)
		{
			$$.type_enum = ECPGt_timestamp;
			$$.type_str = "timestamp";
			$$.type_dimension = "-1";
			$$.type_index = "-1";
			$$.type_sizeof = NULL;
		}
		else if (strcmp(@1, "interval") == 0)
		{
			$$.type_enum = ECPGt_interval;
			$$.type_str = "interval";
			$$.type_dimension = "-1";
			$$.type_index = "-1";
			$$.type_sizeof = NULL;
		}
		else if (strcmp(@1, "datetime") == 0)
		{
			$$.type_enum = ECPGt_timestamp;
			$$.type_str = "timestamp";
			$$.type_dimension = "-1";
			$$.type_index = "-1";
			$$.type_sizeof = NULL;
		}
		else if ((strcmp(@1, "string") == 0) && INFORMIX_MODE)
		{
			$$.type_enum = ECPGt_string;
			$$.type_str = "char";
			$$.type_dimension = "-1";
			$$.type_index = "-1";
			$$.type_sizeof = NULL;
		}
		else
		{
			/* Otherwise, it must be a user-defined typedef name */
			struct typedefs *this = get_typedef(@1, false);

			$$.type_str = (this->type->type_enum == ECPGt_varchar || this->type->type_enum == ECPGt_bytea) ? "" : this->name;
			$$.type_enum = this->type->type_enum;
			$$.type_dimension = this->type->type_dimension;
			$$.type_index = this->type->type_index;
			if (this->type->type_sizeof && strlen(this->type->type_sizeof) != 0)
				$$.type_sizeof = this->type->type_sizeof;
			else
				$$.type_sizeof = cat_str(3, "sizeof(", this->name, ")");

			ECPGfree_struct_member(struct_member_list[struct_level]);
			struct_member_list[struct_level] = ECPGstruct_member_dup(this->struct_member_list);
		}
	}
	| s_struct_union_symbol
	{
		/* this is for named structs/unions */
		char	   *name;
		struct typedefs *this;
		bool		forward = (forward_name != NULL && strcmp($1.symbol, forward_name) == 0 && strcmp($1.su, "struct") == 0);

		name = cat2_str($1.su, $1.symbol);
		/* Do we have a forward definition? */
		if (!forward)
		{
			/* No */

			this = get_typedef(name, false);
			$$.type_str = this->name;
			$$.type_enum = this->type->type_enum;
			$$.type_dimension = this->type->type_dimension;
			$$.type_index = this->type->type_index;
			$$.type_sizeof = this->type->type_sizeof;
			ECPGfree_struct_member(struct_member_list[struct_level]);
			struct_member_list[struct_level] = ECPGstruct_member_dup(this->struct_member_list);
		}
		else
		{
			$$.type_str = name;
			$$.type_enum = ECPGt_long;
			$$.type_dimension = "-1";
			$$.type_index = "-1";
			$$.type_sizeof = "";
			ECPGfree_struct_member(struct_member_list[struct_level]);
			struct_member_list[struct_level] = NULL;
		}
	}
	;

enum_type: ENUM_P symbol enum_definition
	| ENUM_P enum_definition
	| ENUM_P symbol
	;

enum_definition: '{' c_list '}'
	;

struct_union_type_with_symbol: s_struct_union_symbol
	{
		ECPGfree_struct_member(struct_member_list[struct_level]);
		struct_member_list[struct_level++] = NULL;
		if (struct_level >= STRUCT_DEPTH)
			mmerror(PARSE_ERROR, ET_ERROR, "too many levels in nested structure/union definition");
		forward_name = mm_strdup($1.symbol);
	}
	'{' variable_declarations '}'
	{
		struct typedefs *ptr,
				   *this;
		struct this_type su_type;

		ECPGfree_struct_member(struct_member_list[struct_level]);
		struct_member_list[struct_level] = NULL;
		struct_level--;
		if (strcmp($1.su, "struct") == 0)
			su_type.type_enum = ECPGt_struct;
		else
			su_type.type_enum = ECPGt_union;
		su_type.type_str = cat2_str($1.su, $1.symbol);
		free(forward_name);
		forward_name = NULL;

		/*
		 * This is essentially a typedef but needs the keyword struct/union as
		 * well. So we create the typedef for each struct definition with
		 * symbol
		 */
		for (ptr = types; ptr != NULL; ptr = ptr->next)
		{
			if (strcmp(su_type.type_str, ptr->name) == 0)
				/* re-definition is a bug */
				mmerror(PARSE_ERROR, ET_ERROR, "type \"%s\" is already defined", su_type.type_str);
		}

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

		/* initial definition */
		this->next = types;
		this->name = mm_strdup(su_type.type_str);
		this->brace_level = braces_open;
		this->type = (struct this_type *) mm_alloc(sizeof(struct this_type));
		this->type->type_storage = NULL;
		this->type->type_enum = su_type.type_enum;
		this->type->type_str = mm_strdup(su_type.type_str);
		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 ? mm_strdup(ECPGstruct_sizeof) : NULL;
		this->struct_member_list = ECPGstruct_member_dup(struct_member_list[struct_level]);

		types = this;
		@$ = cat_str(4, su_type.type_str, "{", @4, "}");
	}
	;

struct_union_type: struct_union_type_with_symbol
	| s_struct_union
	{
		ECPGfree_struct_member(struct_member_list[struct_level]);
		struct_member_list[struct_level++] = NULL;
		if (struct_level >= STRUCT_DEPTH)
			mmerror(PARSE_ERROR, ET_ERROR, "too many levels in nested structure/union definition");
	}
	'{' variable_declarations '}'
	{
		ECPGfree_struct_member(struct_member_list[struct_level]);
		struct_member_list[struct_level] = NULL;
		struct_level--;
		@$ = cat_str(4, @1, "{", @4, "}");
	}
	;

s_struct_union_symbol: SQL_STRUCT symbol
	{
		$$.su = "struct";
		$$.symbol = @2;
		free(ECPGstruct_sizeof);
		ECPGstruct_sizeof = mm_strdup(cat_str(3, "sizeof(",
											  cat2_str($$.su, $$.symbol),
											  ")"));
	}
	| UNION symbol
	{
		$$.su = "union";
		$$.symbol = @2;
	}
	;

s_struct_union: SQL_STRUCT
	{
		free(ECPGstruct_sizeof);
		ECPGstruct_sizeof = mm_strdup("");	/* This must not be NULL to
											 * distinguish from simple types. */
		@$ = "struct";
	}
	| UNION
	{
		@$ = "union";
	}
	;

simple_type: unsigned_type
	| opt_signed signed_type			{ $$ = $2; }
	;

unsigned_type: SQL_UNSIGNED SQL_SHORT	{ $$ = ECPGt_unsigned_short; }
	| SQL_UNSIGNED SQL_SHORT INT_P		{ $$ = ECPGt_unsigned_short; }
	| SQL_UNSIGNED						{ $$ = ECPGt_unsigned_int; }
	| SQL_UNSIGNED INT_P				{ $$ = ECPGt_unsigned_int; }
	| SQL_UNSIGNED SQL_LONG				{ $$ = ECPGt_unsigned_long; }
	| SQL_UNSIGNED SQL_LONG INT_P		{ $$ = ECPGt_unsigned_long; }
	| SQL_UNSIGNED SQL_LONG SQL_LONG	{ $$ = ECPGt_unsigned_long_long; }
	| SQL_UNSIGNED SQL_LONG SQL_LONG INT_P	{ $$ = ECPGt_unsigned_long_long; }
	| SQL_UNSIGNED CHAR_P				{ $$ = ECPGt_unsigned_char; }
	;

signed_type: SQL_SHORT					{ $$ = ECPGt_short; }
	| SQL_SHORT INT_P					{ $$ = ECPGt_short; }
	| INT_P								{ $$ = ECPGt_int; }
	| SQL_LONG							{ $$ = ECPGt_long; }
	| SQL_LONG INT_P					{ $$ = ECPGt_long; }
	| SQL_LONG SQL_LONG					{ $$ = ECPGt_long_long; }
	| SQL_LONG SQL_LONG INT_P			{ $$ = ECPGt_long_long; }
	| SQL_BOOL							{ $$ = ECPGt_bool; }
	| CHAR_P							{ $$ = ECPGt_char; }
	| DOUBLE_P							{ $$ = ECPGt_double; }
	;

opt_signed: SQL_SIGNED
	| /* EMPTY */
	;

variable_list: variable
	| variable_list ',' variable
	{
		if (actual_type[struct_level].type_enum == ECPGt_varchar || actual_type[struct_level].type_enum == ECPGt_bytea)
			@$ = cat_str(4, @1, ";", actual_type[struct_level].type_storage, @3);
		else
			@$ = cat_str(3, @1, ",", @3);
	}
	;

variable: opt_pointer ECPGColLabel opt_array_bounds opt_bit_field opt_initializer
	{
		struct ECPGtype *type;
		const char *dimension = $3.index1;	/* dimension of array */
		const char *length = $3.index2; /* length of string */
		char	   *dim_str;
		char		vcn[32];
		int		   *varlen_type_counter;
		char	   *struct_name;

		adjust_array(actual_type[struct_level].type_enum,
					 &dimension, &length,
					 actual_type[struct_level].type_dimension,
					 actual_type[struct_level].type_index,
					 strlen(@1), false);
		switch (actual_type[struct_level].type_enum)
		{
			case ECPGt_struct:
			case ECPGt_union:
				if (atoi(dimension) < 0)
					type = ECPGmake_struct_type(struct_member_list[struct_level], actual_type[struct_level].type_enum, actual_type[struct_level].type_str, actual_type[struct_level].type_sizeof);
				else
					type = ECPGmake_array_type(ECPGmake_struct_type(struct_member_list[struct_level], actual_type[struct_level].type_enum, actual_type[struct_level].type_str, actual_type[struct_level].type_sizeof), dimension);

				@$ = cat_str(5, @1, @2, $3.str, @4, @5);
				break;

			case ECPGt_varchar:
			case ECPGt_bytea:
				if (actual_type[struct_level].type_enum == ECPGt_varchar)
				{
					varlen_type_counter = &varchar_counter;
					struct_name = " struct varchar_";
				}
				else
				{
					varlen_type_counter = &bytea_counter;
					struct_name = " struct bytea_";
				}
				if (atoi(dimension) < 0)
					type = ECPGmake_simple_type(actual_type[struct_level].type_enum, length, *varlen_type_counter);
				else
					type = ECPGmake_array_type(ECPGmake_simple_type(actual_type[struct_level].type_enum, length, *varlen_type_counter), dimension);

				if (strcmp(dimension, "0") == 0 || abs(atoi(dimension)) == 1)
					dim_str = "";
				else
					dim_str = cat_str(3, "[", dimension, "]");

				/*
				 * 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");

				/*
				 * make sure varchar struct name is unique by adding a unique
				 * counter to its definition
				 */
				snprintf(vcn, sizeof(vcn), "%d", *varlen_type_counter);
				if (strcmp(dimension, "0") == 0)
					@$ = cat_str(7, make2_str(struct_name, vcn), " { int len; char arr[", length, "]; } *", @2, @4, @5);
				else
					@$ = cat_str(8, make2_str(struct_name, vcn), " { int len; char arr[", length, "]; } ", @2, dim_str, @4, @5);
				(*varlen_type_counter)++;
				break;

			case ECPGt_char:
			case ECPGt_unsigned_char:
			case ECPGt_string:
				if (atoi(dimension) == -1)
				{
					int			i = strlen(@5);

					if (atoi(length) == -1 && i > 0)	/* char <var>[] =
														 * "string" */
					{
						/*
						 * if we have an initializer but no string size set,
						 * let's use the initializer's length
						 */
						char   *buf = loc_alloc(32);

						snprintf(buf, 32, "sizeof(%s)", @5 + 2);
						length = buf;
					}
					type = ECPGmake_simple_type(actual_type[struct_level].type_enum, length, 0);
				}
				else
					type = ECPGmake_array_type(ECPGmake_simple_type(actual_type[struct_level].type_enum, length, 0), dimension);

				@$ = cat_str(5, @1, @2, $3.str, @4, @5);
				break;

			default:
				if (atoi(dimension) < 0)
					type = ECPGmake_simple_type(actual_type[struct_level].type_enum, "1", 0);
				else
					type = ECPGmake_array_type(ECPGmake_simple_type(actual_type[struct_level].type_enum, "1", 0), dimension);

				@$ = cat_str(5, @1, @2, $3.str, @4, @5);
				break;
		}

		if (struct_level == 0)
			new_variable(@2, type, braces_open);
		else
			ECPGmake_struct_member(@2, type, &(struct_member_list[struct_level - 1]));
	}
	;

opt_initializer: /* EMPTY */
	| '=' c_term
	{
		initializer = 1;
	}
	;

opt_pointer: /* EMPTY */
	| '*'
	| '*' '*'
	{
		@$ = "**";
	}
	;

/*
 * We try to simulate the correct DECLARE syntax here so we get dynamic SQL
 */
ECPGDeclare: DECLARE STATEMENT ecpg_ident
	{
		/* this is only supported for compatibility */
		@$ = cat_str(3, "/* declare statement", @3, "*/");
	}
	;
/*
 * the exec sql disconnect statement: disconnect from the given database
 */
ECPGDisconnect: SQL_DISCONNECT dis_name
	{
		@$ = @2;
	}
	;

dis_name: connection_object
	| CURRENT_P
	{
		@$ = "\"CURRENT\"";
	}
	| ALL
	{
		@$ = "\"ALL\"";
	}
	| /* EMPTY */
	{
		@$ = "\"CURRENT\"";
	}
	;

connection_object: name
	{
		@$ = make3_str("\"", @1, "\"");
	}
	| DEFAULT
	{
		@$ = "\"DEFAULT\"";
	}
	| char_variable
	;

execstring: char_variable
	| CSTRING
	{
		@$ = make3_str("\"", @1, "\"");
	}
	;

/*
 * the exec sql free command to deallocate a previously
 * prepared statement
 */
ECPGFree: SQL_FREE cursor_name
	{
		@$ = @2;
	}
	| SQL_FREE ALL
	{
		@$ = "all";
	}
	;

/*
 * open is an open cursor, at the moment this has to be removed
 */
ECPGOpen: SQL_OPEN cursor_name opt_ecpg_using
	{
		if (@2[0] == ':')
			remove_variable_from_list(&argsinsert, find_variable(@2 + 1));
		@$ = @2;
	}
	;

opt_ecpg_using: /* EMPTY */
	| ecpg_using
	;

ecpg_using: USING using_list
	{
		@$ = "";
	}
	| using_descriptor
	;

using_descriptor: USING SQL_P SQL_DESCRIPTOR quoted_ident_stringvar
	{
		add_variable_to_head(&argsinsert, descriptor_variable(@4, 0), &no_indicator);
		@$ = "";
	}
	| USING SQL_DESCRIPTOR name
	{
		add_variable_to_head(&argsinsert, sqlda_variable(@3), &no_indicator);
		@$ = "";
	}
	;

into_descriptor: INTO SQL_P SQL_DESCRIPTOR quoted_ident_stringvar
	{
		add_variable_to_head(&argsresult, descriptor_variable(@4, 1), &no_indicator);
		@$ = "";
	}
	| INTO SQL_DESCRIPTOR name
	{
		add_variable_to_head(&argsresult, sqlda_variable(@3), &no_indicator);
		@$ = "";
	}
	;

into_sqlda: INTO name
	{
		add_variable_to_head(&argsresult, sqlda_variable(@2), &no_indicator);
		@$ = "";
	}
	;

using_list: UsingValue | UsingValue ',' using_list
	;

UsingValue: UsingConst
	{
		char		length[32];

		snprintf(length, sizeof(length), "%zu", strlen(@1));
		add_variable_to_head(&argsinsert, new_variable(@1, ECPGmake_simple_type(ECPGt_const, length, 0), 0), &no_indicator);
	}
	| civar
	{
		@$ = "";
	}
	| civarind
	{
		@$ = "";
	}
	;

UsingConst: Iconst
	| '+' Iconst
	| '-' Iconst
	| ecpg_fconst
	| '+' ecpg_fconst
	| '-' ecpg_fconst
	| ecpg_sconst
	| ecpg_bconst
	| ecpg_xconst
	;

/*
 * We accept DESCRIBE [OUTPUT] but do nothing with DESCRIBE INPUT so far.
 */
ECPGDescribe: SQL_DESCRIBE INPUT_P prepared_name using_descriptor
	{
		$$.input = 1;
		$$.stmt_name = @3;
	}
	| SQL_DESCRIBE opt_output prepared_name using_descriptor
	{
		struct variable *var;

		var = argsinsert->variable;
		remove_variable_from_list(&argsinsert, var);
		add_variable_to_head(&argsresult, var, &no_indicator);

		$$.input = 0;
		$$.stmt_name = @3;
	}
	| SQL_DESCRIBE opt_output prepared_name into_descriptor
	{
		$$.input = 0;
		$$.stmt_name = @3;
	}
	| SQL_DESCRIBE INPUT_P prepared_name into_sqlda
	{
		$$.input = 1;
		$$.stmt_name = @3;
	}
	| SQL_DESCRIBE opt_output prepared_name into_sqlda
	{
		$$.input = 0;
		$$.stmt_name = @3;
	}
	;

opt_output: SQL_OUTPUT
	| /* EMPTY */
	;

/*
 * dynamic SQL: descriptor based access
 *	originally written by Christof Petig <christof.petig@wtal.de>
 *			and Peter Eisentraut <peter.eisentraut@credativ.de>
 */

/*
 * allocate a descriptor
 */
ECPGAllocateDescr: SQL_ALLOCATE SQL_DESCRIPTOR quoted_ident_stringvar
	{
		add_descriptor(@3, connection);
		@$ = @3;
	}
	;


/*
 * deallocate a descriptor
 */
ECPGDeallocateDescr: DEALLOCATE SQL_DESCRIPTOR quoted_ident_stringvar
	{
		drop_descriptor(@3, connection);
		@$ = @3;
	}
	;

/*
 * manipulate a descriptor header
 */

ECPGGetDescriptorHeader: SQL_GET SQL_DESCRIPTOR quoted_ident_stringvar ECPGGetDescHeaderItems
	{
		@$ = @3;
	}
	;

ECPGGetDescHeaderItems: ECPGGetDescHeaderItem
	| ECPGGetDescHeaderItems ',' ECPGGetDescHeaderItem
	;

ECPGGetDescHeaderItem: cvariable '=' desc_header_item
	{
		push_assignment(@1, $3);
	}
	;

ECPGSetDescriptorHeader: SET SQL_DESCRIPTOR quoted_ident_stringvar ECPGSetDescHeaderItems
	{
		@$ = @3;
	}
	;

ECPGSetDescHeaderItems: ECPGSetDescHeaderItem
	| ECPGSetDescHeaderItems ',' ECPGSetDescHeaderItem
	;

ECPGSetDescHeaderItem: desc_header_item '=' IntConstVar
	{
		push_assignment(@3, $1);
	}
	;

IntConstVar: Iconst
	{
		char		length[32];

		snprintf(length, sizeof(length), "%zu", strlen(@1));
		new_variable(@1, ECPGmake_simple_type(ECPGt_const, length, 0), 0);
	}
	| cvariable
	;

desc_header_item: SQL_COUNT
	{
		$$ = ECPGd_count;
	}
	;

/*
 * manipulate a descriptor
 */

ECPGGetDescriptor: SQL_GET SQL_DESCRIPTOR quoted_ident_stringvar VALUE_P IntConstVar ECPGGetDescItems
	{
		$$.str = @5;
		$$.name = @3;
	}
	;

ECPGGetDescItems: ECPGGetDescItem
	| ECPGGetDescItems ',' ECPGGetDescItem
	;

ECPGGetDescItem: cvariable '=' descriptor_item
	{
		push_assignment(@1, $3);
	}
	;

ECPGSetDescriptor: SET SQL_DESCRIPTOR quoted_ident_stringvar VALUE_P IntConstVar ECPGSetDescItems
	{
		$$.str = @5;
		$$.name = @3;
	}
	;

ECPGSetDescItems: ECPGSetDescItem
	| ECPGSetDescItems ',' ECPGSetDescItem
	;

ECPGSetDescItem: descriptor_item '=' AllConstVar
	{
		push_assignment(@3, $1);
	}
	;

AllConstVar: ecpg_fconst
	{
		char		length[32];

		snprintf(length, sizeof(length), "%zu", strlen(@1));
		new_variable(@1, ECPGmake_simple_type(ECPGt_const, length, 0), 0);
	}
	| IntConstVar
	| '-' ecpg_fconst
	{
		char		length[32];
		char	   *var = cat2_str("-", @2);

		snprintf(length, sizeof(length), "%zu", strlen(var));
		new_variable(var, ECPGmake_simple_type(ECPGt_const, length, 0), 0);
		@$ = var;
	}
	| '-' Iconst
	{
		char		length[32];
		char	   *var = cat2_str("-", @2);

		snprintf(length, sizeof(length), "%zu", strlen(var));
		new_variable(var, ECPGmake_simple_type(ECPGt_const, length, 0), 0);
		@$ = var;
	}
	| ecpg_sconst
	{
		char		length[32];
		char	   *var;

		/* Strip single quotes from ecpg_sconst */
		var = loc_strdup(@1 + 1);
		var[strlen(var) - 1] = '\0';
		snprintf(length, sizeof(length), "%zu", strlen(var));
		new_variable(var, ECPGmake_simple_type(ECPGt_const, length, 0), 0);
		@$ = var;
	}
	;

descriptor_item: SQL_CARDINALITY		{ $$ = ECPGd_cardinality; }
	| DATA_P							{ $$ = ECPGd_data; }
	| SQL_DATETIME_INTERVAL_CODE		{ $$ = ECPGd_di_code; }
	| SQL_DATETIME_INTERVAL_PRECISION	{ $$ = ECPGd_di_precision; }
	| SQL_INDICATOR						{ $$ = ECPGd_indicator; }
	| SQL_KEY_MEMBER					{ $$ = ECPGd_key_member; }
	| SQL_LENGTH						{ $$ = ECPGd_length; }
	| NAME_P							{ $$ = ECPGd_name; }
	| SQL_NULLABLE						{ $$ = ECPGd_nullable; }
	| SQL_OCTET_LENGTH					{ $$ = ECPGd_octet; }
	| PRECISION							{ $$ = ECPGd_precision; }
	| SQL_RETURNED_LENGTH				{ $$ = ECPGd_length; }
	| SQL_RETURNED_OCTET_LENGTH			{ $$ = ECPGd_ret_octet; }
	| SQL_SCALE							{ $$ = ECPGd_scale; }
	| TYPE_P							{ $$ = ECPGd_type; }
	;

/*
 * set/reset the automatic transaction mode, this needs a different handling
 * as the other set commands
 */
ECPGSetAutocommit: SET SQL_AUTOCOMMIT '=' on_off
	{
		@$ = @4;
	}
	| SET SQL_AUTOCOMMIT TO on_off
	{
		@$ = @4;
	}
	;

on_off: ON
	| OFF
	;

/*
 * set the actual connection, this needs a different handling as the other
 * set commands
 */
ECPGSetConnection: SET CONNECTION TO connection_object
	{
		@$ = @4;
	}
	| SET CONNECTION '=' connection_object
	{
		@$ = @4;
	}
	| SET CONNECTION connection_object
	{
		@$ = @3;
	}
	;

/*
 * define a new type for embedded SQL
 */
ECPGTypedef: TYPE_P
	{
		/* reset this variable so we see if there was */
		/* an initializer specified */
		initializer = 0;
	}
	ECPGColLabel IS var_type opt_array_bounds opt_reference
	{
		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, "/* exec sql type", @3, "is", $5.type_str, $6.str, @7, "*/");
		else
			@$ = cat_str(6, "typedef ", $5.type_str, *@7 ? "*" : "", @3, $6.str, ";");
	}
	;

opt_reference: SQL_REFERENCE
	| /* EMPTY */
	;

/*
 * define the type of one variable for embedded SQL
 */
ECPGVar: SQL_VAR
	{
		/* reset this variable so we see if there was */
		/* an initializer specified */
		initializer = 0;
	}
	ColLabel	IS var_type opt_array_bounds opt_reference
	{
		struct variable *p = find_variable(@3);
		const char *dimension = $6.index1;
		const char *length = $6.index2;
		struct ECPGtype *type;

		if			(($5.type_enum == ECPGt_struct ||
					  $5.type_enum == ECPGt_union) &&
					 initializer == 1)
			mmerror(PARSE_ERROR, ET_ERROR, "initializer not allowed in EXEC SQL VAR command");
		else
		{
			adjust_array($5.type_enum, &dimension, &length,
						 $5.type_dimension, $5.type_index, *@7 ? 1 : 0, false);

			switch ($5.type_enum)
			{
					case ECPGt_struct:
					case ECPGt_union:
					if (atoi(dimension) < 0)
						type = ECPGmake_struct_type(struct_member_list[struct_level], $5.type_enum, $5.type_str, $5.type_sizeof);
					else
						type = ECPGmake_array_type(ECPGmake_struct_type(struct_member_list[struct_level], $5.type_enum, $5.type_str, $5.type_sizeof), dimension);
					break;

					case ECPGt_varchar:
					case ECPGt_bytea:
					if (atoi(dimension) == -1)
						type = ECPGmake_simple_type($5.type_enum, length, 0);
					else
						type = ECPGmake_array_type(ECPGmake_simple_type($5.type_enum, length, 0), dimension);
					break;

					case ECPGt_char:
					case ECPGt_unsigned_char:
					case ECPGt_string:
					if (atoi(dimension) == -1)
						type = ECPGmake_simple_type($5.type_enum, length, 0);
					else
						type = ECPGmake_array_type(ECPGmake_simple_type($5.type_enum, length, 0), dimension);
					break;

					default:
					if (atoi(length) >= 0)
						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, "1", 0);
					else
						type = ECPGmake_array_type(ECPGmake_simple_type($5.type_enum, "1", 0), dimension);
					break;
			}

			ECPGfree_type(p->type);
			p->type = type;
		}

					@$ = cat_str(7, "/* exec sql var", @3, "is", $5.type_str, $6.str, @7, "*/");
	}
	;

/*
 * whenever statement: decide what to do in case of error/no data found
 * according to SQL standards we lack: SQLSTATE, CONSTRAINT and SQLEXCEPTION
 */
ECPGWhenever: SQL_WHENEVER SQL_SQLERROR action
	{
		when_error.code = $3.code;
		free(when_error.command);
		when_error.command = $3.command ? mm_strdup($3.command) : NULL;
		@$ = cat_str(3, "/* exec sql whenever sqlerror ", $3.str, "; */");
	}
	| SQL_WHENEVER NOT SQL_FOUND action
	{
		when_nf.code = $4.code;
		free(when_nf.command);
		when_nf.command = $4.command ? mm_strdup($4.command) : NULL;
		@$ = cat_str(3, "/* exec sql whenever not found ", $4.str, "; */");
	}
	| SQL_WHENEVER SQL_SQLWARNING action
	{
		when_warn.code = $3.code;
		free(when_warn.command);
		when_warn.command = $3.command ? mm_strdup($3.command) : NULL;
		@$ = cat_str(3, "/* exec sql whenever sql_warning ", $3.str, "; */");
	}
	;

action: CONTINUE_P
	{
		$$.code = W_NOTHING;
		$$.command = NULL;
		$$.str = "continue";
	}
	| SQL_SQLPRINT
	{
		$$.code = W_SQLPRINT;
		$$.command = NULL;
		$$.str = "sqlprint";
	}
	| SQL_STOP
	{
		$$.code = W_STOP;
		$$.command = NULL;
		$$.str = "stop";
	}
	| SQL_GOTO name
	{
		$$.code = W_GOTO;
		$$.command = loc_strdup(@2);
		$$.str = cat2_str("goto ", @2);
	}
	| SQL_GO TO name
	{
		$$.code = W_GOTO;
		$$.command = loc_strdup(@3);
		$$.str = cat2_str("goto ", @3);
	}
	| DO name '(' c_args ')'
	{
		$$.code = W_DO;
		$$.command = cat_str(4, @2, "(", @4, ")");
		$$.str = cat2_str("do", $$.command);
	}
	| DO SQL_BREAK
	{
		$$.code = W_BREAK;
		$$.command = NULL;
		$$.str = "break";
	}
	| DO CONTINUE_P
	{
		$$.code = W_CONTINUE;
		$$.command = NULL;
		$$.str = "continue";
	}
	| CALL name '(' c_args ')'
	{
		$$.code = W_DO;
		$$.command = cat_str(4, @2, "(", @4, ")");
		$$.str = cat2_str("call", $$.command);
	}
	| CALL name
	{
		$$.code = W_DO;
		$$.command = cat2_str(@2, "()");
		$$.str = cat2_str("call", $$.command);
	}
	;

/* some other stuff for ecpg */

/* additional unreserved keywords */
ECPGKeywords: ECPGKeywords_vanames
	| ECPGKeywords_rest
	;

ECPGKeywords_vanames: SQL_BREAK
	| SQL_CARDINALITY
	| SQL_COUNT
	| SQL_DATETIME_INTERVAL_CODE
	| SQL_DATETIME_INTERVAL_PRECISION
	| SQL_FOUND
	| SQL_GO
	| SQL_GOTO
	| SQL_IDENTIFIED
	| SQL_INDICATOR
	| SQL_KEY_MEMBER
	| SQL_LENGTH
	| SQL_NULLABLE
	| SQL_OCTET_LENGTH
	| SQL_RETURNED_LENGTH
	| SQL_RETURNED_OCTET_LENGTH
	| SQL_SCALE
	| SQL_SECTION
	| SQL_SQLERROR
	| SQL_SQLPRINT
	| SQL_SQLWARNING
	| SQL_STOP
	;

ECPGKeywords_rest: SQL_CONNECT
	| SQL_DESCRIBE
	| SQL_DISCONNECT
	| SQL_OPEN
	| SQL_VAR
	| SQL_WHENEVER
	;

/* additional keywords that can be SQL type names (but not ECPGColLabels) */
ECPGTypeName: SQL_BOOL
	| SQL_LONG
	| SQL_OUTPUT
	| SQL_SHORT
	| SQL_STRUCT
	| SQL_SIGNED
	| SQL_UNSIGNED
	;

symbol: ColLabel
	;

ECPGColId: ecpg_ident
	| unreserved_keyword
	| col_name_keyword
	| ECPGunreserved_interval
	| ECPGKeywords
	| ECPGCKeywords
	| CHAR_P
	| VALUES
	;

/*
 * Name classification hierarchy.
 *
 * These productions should match those in the core grammar, except that
 * we use all_unreserved_keyword instead of unreserved_keyword, and
 * where possible include ECPG keywords as well as core keywords.
 */

/* Column identifier --- names that can be column, table, etc names.
 */
ColId: ecpg_ident
	| all_unreserved_keyword
	| col_name_keyword
	| ECPGKeywords
	| ECPGCKeywords
	| CHAR_P
	| VALUES
	;

/* Type/function identifier --- names that can be type or function names.
 */
type_function_name: ecpg_ident
	| all_unreserved_keyword
	| type_func_name_keyword
	| ECPGKeywords
	| ECPGCKeywords
	| ECPGTypeName
	;

/* Column label --- allowed labels in "AS" clauses.
 * This presently includes *all* Postgres keywords.
 */
ColLabel: ECPGColLabel
	| ECPGTypeName
	| CHAR_P
	| CURRENT_P
	| INPUT_P
	| INT_P
	| TO
	| UNION
	| VALUES
	| ECPGCKeywords
	| ECPGunreserved_interval
	;

ECPGColLabel: ecpg_ident
	| unreserved_keyword
	| col_name_keyword
	| type_func_name_keyword
	| reserved_keyword
	| ECPGKeywords_vanames
	| ECPGKeywords_rest
	| CONNECTION
	;

ECPGCKeywords: S_AUTO
	| S_CONST
	| S_EXTERN
	| S_REGISTER
	| S_STATIC
	| S_TYPEDEF
	| S_VOLATILE
	;

/* "Unreserved" keywords --- available for use as any kind of name.
 */

/*
 * The following symbols must be excluded from ECPGColLabel and directly
 * included into ColLabel to enable C variables to get names from ECPGColLabel:
 * DAY_P, HOUR_P, MINUTE_P, MONTH_P, SECOND_P, YEAR_P.
 *
 * We also have to exclude CONNECTION, CURRENT, and INPUT for various reasons.
 * CONNECTION can be added back in all_unreserved_keyword, but CURRENT and
 * INPUT are reserved for ecpg purposes.
 *
 * The mentioned exclusions are done by $replace_line settings in parse.pl.
 */
all_unreserved_keyword: unreserved_keyword
	| ECPGunreserved_interval
	| CONNECTION
	;

ECPGunreserved_interval: DAY_P
	| HOUR_P
	| MINUTE_P
	| MONTH_P
	| SECOND_P
	| YEAR_P
	;

into_list: coutputvariable | into_list ',' coutputvariable
	;

ecpgstart: SQL_START
	{
		reset_variables();
		pacounter = 1;
		@$ = "";
	}
	;

c_args: /* EMPTY */
	| c_list
	;

coutputvariable: cvariable indicator
	{
		add_variable_to_head(&argsresult, find_variable(@1), find_variable(@2));
	}
	| cvariable
	{
		add_variable_to_head(&argsresult, find_variable(@1), &no_indicator);
	}
	;


civarind: cvariable indicator
	{
		if (find_variable(@2)->type->type == ECPGt_array)
			mmerror(PARSE_ERROR, ET_ERROR, "arrays of indicators are not allowed on input");

		add_variable_to_head(&argsinsert, find_variable(@1), find_variable(@2));
		@$ = create_questionmarks(@1, false);
	}
	;

char_civar: char_variable
	{
		char	   *ptr = strstr(@1, ".arr");

		if (ptr)				/* varchar, we need the struct name here, not
								 * the struct element */
			*ptr = '\0';
		add_variable_to_head(&argsinsert, find_variable(@1), &no_indicator);
	}
	;

civar: cvariable
	{
		add_variable_to_head(&argsinsert, find_variable(@1), &no_indicator);
		@$ = create_questionmarks(@1, false);
	}
	;

indicator: cvariable
	{
		check_indicator((find_variable(@1))->type);
	}
	| SQL_INDICATOR cvariable
	{
		check_indicator((find_variable(@2))->type);
		@$ = @2;
	}
	| SQL_INDICATOR name
	{
		check_indicator((find_variable(@2))->type);
		@$ = @2;
	}
	;

cvariable: CVARIABLE
	{
		/*
		 * As long as multidimensional arrays are not implemented we have to
		 * check for those here
		 */
		const char *ptr = @1;
		int			brace_open = 0,
					brace = false;

		for (; *ptr; ptr++)
		{
			switch (*ptr)
			{
				case '[':
					if (brace)
						mmfatal(PARSE_ERROR, "multidimensional arrays for simple data types are not supported");
					brace_open++;
					break;
				case ']':
					brace_open--;
					if (brace_open == 0)
						brace = true;
					break;
				case '\t':
				case ' ':
					break;
				default:
					if (brace_open == 0)
						brace = false;
					break;
			}
		}
	}
	;

ecpg_param: PARAM
	;

ecpg_bconst: BCONST
	;

ecpg_fconst: FCONST
	;

ecpg_sconst: SCONST
	;

ecpg_xconst: XCONST
	;

ecpg_ident: IDENT
	| CSTRING
	{
		@$ = make3_str("\"", @1, "\"");
	}
	;

quoted_ident_stringvar: name
	{
		@$ = make3_str("\"", @1, "\"");
	}
	| char_variable
	{
		@$ = make3_str("(", @1, ")");
	}
	;

/*
 * C stuff
 */

c_stuff_item: c_anything
	| '(' ')'
	{
		@$ = "()";
	}
	| '(' c_stuff ')'
	;

c_stuff: c_stuff_item
	| c_stuff c_stuff_item
	;

c_list: c_term
	| c_list ',' c_term
	;

c_term: c_stuff
	| '{' c_list '}'
	;

c_thing: c_anything
	| '('
	| ')'
	| ','
	| ';'
	;

/*
 * Note: NULL_P is treated specially to force it to be output in upper case,
 * since it's likely meant as a reference to the standard C macro NULL.
 */
c_anything: ecpg_ident
	| Iconst
	| ecpg_fconst
	| ecpg_sconst
	| '*'
	| '+'
	| '-'
	| '/'
	| '%'
	| NULL_P						{ @$ = "NULL"; }
	| S_ADD
	| S_AND
	| S_ANYTHING
	| S_AUTO
	| S_CONST
	| S_DEC
	| S_DIV
	| S_DOTPOINT
	| S_EQUAL
	| S_EXTERN
	| S_INC
	| S_LSHIFT
	| S_MEMBER
	| S_MEMPOINT
	| S_MOD
	| S_MUL
	| S_NEQUAL
	| S_OR
	| S_REGISTER
	| S_RSHIFT
	| S_STATIC
	| S_SUB
	| S_TYPEDEF
	| S_VOLATILE
	| SQL_BOOL
	| ENUM_P
	| HOUR_P
	| INT_P
	| SQL_LONG
	| MINUTE_P
	| MONTH_P
	| SECOND_P
	| SQL_SHORT
	| SQL_SIGNED
	| SQL_STRUCT
	| SQL_UNSIGNED
	| YEAR_P
	| CHAR_P
	| FLOAT_P
	| TO
	| UNION
	| VARCHAR
	| '['
	| ']'
	| '='
	| ':'
	;

DeallocateStmt: DEALLOCATE prepared_name
	{
		check_declared_list(@2);
		@$ = @2;
	}
	| DEALLOCATE PREPARE prepared_name
	{
		check_declared_list(@3);
		@$ = @3;
	}
	| DEALLOCATE ALL
	{
		@$ = "all";
	}
	| DEALLOCATE PREPARE ALL
	{
		@$ = "all";
	}
	;

Iresult: Iconst
	| '(' Iresult ')'
	| Iresult '+' Iresult
	| Iresult '-' Iresult
	| Iresult '*' Iresult
	| Iresult '/' Iresult
	| Iresult '%' Iresult
	| ecpg_sconst
	| ColId
	| ColId '(' var_type ')'
	{
		if (pg_strcasecmp(@1, "sizeof") != 0)
			mmerror(PARSE_ERROR, ET_ERROR, "operator not allowed in variable definition");
		else
			@$ = cat_str(4, @1, "(", $3.type_str, ")");
	}
	;

execute_rest: /* EMPTY */
	| ecpg_using opt_ecpg_into
	| ecpg_into ecpg_using
	| ecpg_into
	;

ecpg_into: INTO into_list
	{
		/* always suppress this from the constructed string */
		@$ = "";
	}
	| into_descriptor
	;

opt_ecpg_into: /* EMPTY */
	| ecpg_into
	;

ecpg_fetch_into: ecpg_into
	| using_descriptor
	{
		struct variable *var;

		var = argsinsert->variable;
		remove_variable_from_list(&argsinsert, var);
		add_variable_to_head(&argsresult, var, &no_indicator);
	}
	;

opt_ecpg_fetch_into: /* EMPTY */
	| ecpg_fetch_into
	;

%%

void
base_yyerror(const char *error)
{
	/* translator: %s is typically the translation of "syntax error" */
	mmerror(PARSE_ERROR, ET_ERROR, "%s at or near \"%s\"",
			_(error), token_start ? token_start : base_yytext);
}

void
parser_init(void)
{
	/*
	 * This function is empty. It only exists for compatibility with the
	 * backend parser right now.
	 */
}