/***************************************************************************

    parser.y (IDL yacc parser and tree generation)

    Copyright (C) 1998, 1999 Andrew T. Veliath

    This library is free software; you can redistribute it and/or

    modify it under the terms of the GNU Library General Public

    License as published by the Free Software Foundation; either

    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public

    License along with this library; if not, write to the Free

    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

    $Id: parser.y,v 1.163 2004/11/12 15:37:11 michael Exp $

***************************************************************************/

%{

#include <assert.h>

#include <stdarg.h>

#include <stdio.h>

#include <stdlib.h>

#include <ctype.h>

#include <string.h>

#include <errno.h>

#include "rename.h"

#include "util.h"

#define REF_IDENTS

#define do_binop(rv,op,a,b)		do {		\

	if (IDL_binop_chktypes (op, a, b))		\

		YYABORT;				\

	if (!(__IDL_flags & IDLF_NO_EVAL_CONST)) {	\

		rv = IDL_binop_eval (op, a, b);		\

		IDL_tree_free (a);			\

		IDL_tree_free (b);			\

		if (!rv) YYABORT;			\

	} else {					\

		rv = IDL_binop_new (op, a, b);		\

	}						\

} while (0)

#define do_unaryop(rv,op,a)		do {		\

	if (IDL_unaryop_chktypes (op, a))		\

		YYABORT;				\

	if (!(__IDL_flags & IDLF_NO_EVAL_CONST)) {	\

		rv = IDL_unaryop_eval (op, a);		\

		IDL_tree_free (a);			\

		if (!rv) YYABORT;			\

	} else {					\

		rv = IDL_unaryop_new (op, a);		\

	}						\

} while (0)

#define IS_INHIBIT_STATE()				\

	(__IDL_inhibits > 0 ||				\

	  ((__IDL_flags & IDLF_INHIBIT_INCLUDES) &&	\

	     (__IDL_flagsi & IDLFP_IN_INCLUDES) ) )

#define assign_declspec(tree,declspec)	do {		\

	IDL_NODE_DECLSPEC (tree) = declspec;		\

	if ( IS_INHIBIT_STATE() ) {			\

		IDL_NODE_DECLSPEC (tree) |=		\

			IDLF_DECLSPEC_EXIST |		\

			IDLF_DECLSPEC_INHIBIT;		\

	}						\

	if ( __IDL_pidl > 0 ) {				\

		IDL_NODE_DECLSPEC (tree) |=		\

			IDLF_DECLSPEC_PIDL;		\

	}						\

} while (0)

#define assign_props(tree,props)	do {		\

	if (__IDL_flags & IDLF_PROPERTIES)		\

		IDL_NODE_PROPERTIES (tree) = (props);	\

	else						\

		__IDL_free_properties (props);		\

} while (0)

extern int		yylex				(void);

static IDL_declspec_t	IDL_parse_declspec		(const char *strspec);

static int		IDL_binop_chktypes		(enum IDL_binop op,

							 IDL_tree a,

							 IDL_tree b);

static int		IDL_unaryop_chktypes		(enum IDL_unaryop op,

							 IDL_tree a);

static IDL_tree		IDL_binop_eval			(enum IDL_binop op,

							 IDL_tree a,

							 IDL_tree b);

static IDL_tree		IDL_unaryop_eval		(enum IDL_unaryop op,

							 IDL_tree a);

static IDL_tree		list_start			(IDL_tree a,

							 gboolean filter_null);

static IDL_tree		list_chain			(IDL_tree a,

							 IDL_tree b,

							 gboolean filter_null);

static IDL_tree		zlist_chain			(IDL_tree a,

							 IDL_tree b,

							 gboolean filter_null);

static int		do_token_error			(IDL_tree p,

							 const char *message,

							 gboolean prev);

static void		illegal_context_type_error	(IDL_tree p,

							 const char *what);

static void		illegal_type_error		(IDL_tree p,

							 const char *message);

%}

%union {

	IDL_tree tree;

	struct {

		IDL_tree tree;

		gpointer data;

	} treedata;

	GHashTable *hash_table;

	char *str;

	gboolean boolean;

	IDL_declspec_t declspec;

	IDL_longlong_t integer;

	double floatp;

	enum IDL_unaryop unaryop;

	enum IDL_param_attr paramattr;

}

/* Terminals */

%token			TOK_ANY

%token			TOK_ATTRIBUTE

%token			TOK_BOOLEAN

%token			TOK_CASE

%token			TOK_CHAR

%token			TOK_CONST

%token			TOK_CONTEXT

%token			TOK_DEFAULT

%token			TOK_DOUBLE

%token			TOK_ENUM

%token			TOK_EXCEPTION

%token			TOK_FALSE

%token			TOK_FIXED

%token			TOK_FLOAT

%token			TOK_IN 

%token			TOK_INOUT

%token			TOK_INTERFACE

%token			TOK_LONG

%token			TOK_MODULE

%token			TOK_NATIVE

%token			TOK_OBJECT

%token			TOK_OCTET

%token			TOK_ONEWAY

%token			TOK_OP_SCOPE

%token			TOK_OP_SHL

%token			TOK_OP_SHR

%token			TOK_OUT

%token			TOK_RAISES

%token			TOK_READONLY 

%token			TOK_SEQUENCE

%token			TOK_SHORT

%token			TOK_STRING

%token			TOK_STRUCT

%token			TOK_SWITCH

%token			TOK_TRUE

%token			TOK_TYPECODE

%token			TOK_TYPEDEF

%token			TOK_UNION

%token			TOK_UNSIGNED

%token			TOK_VARARGS

%token			TOK_VOID

%token			TOK_WCHAR

%token			TOK_WSTRING

%token <floatp>		TOK_FLOATP

%token <integer>	TOK_INTEGER

%token <str>		TOK_DECLSPEC TOK_PROP_KEY

%token <str>		TOK_PROP_VALUE TOK_NATIVE_TYPE

%token <str>		TOK_IDENT TOK_SQSTRING TOK_DQSTRING TOK_FIXEDP

%token <tree>		TOK_CODEFRAG

%token <tree>		TOK_SRCFILE

/* Non-Terminals */

%type <tree>		add_expr

%type <tree>		and_expr

%type <tree>		any_type

%type <tree>		array_declarator

%type <tree>		attr_dcl

%type <tree>		attr_dcl_def

%type <tree>		base_type_spec

%type <tree>		boolean_lit

%type <tree>		boolean_type

%type <tree>		case_label

%type <tree>		case_label_list

%type <tree>		case_stmt

%type <tree>		case_stmt_list

%type <tree>		char_lit

%type <tree>		char_type

%type <tree>		codefrag

%type <tree>		complex_declarator

%type <tree>		const_dcl

%type <tree>		const_dcl_def

%type <tree>		const_exp

%type <tree>		const_type

%type <tree>		constr_type_spec

%type <tree>		context_expr

%type <tree>		cur_ns_new_or_prev_ident

%type <tree>		declarator

%type <tree>		declarator_list

%type <tree>		definition

%type <tree>		definition_list

%type <tree>		element_spec

%type <tree>		enum_type

%type <tree>		enumerator_list

%type <tree>		except_dcl

%type <tree>		except_dcl_def

%type <tree>		export

%type <tree>		export_list

%type <tree>		fixed_array_size

%type <tree>		fixed_array_size_list

%type <tree>		fixed_pt_const_type

%type <tree>		fixed_pt_lit

%type <tree>		fixed_pt_type

%type <tree>		floating_pt_lit

%type <tree>		floating_pt_type

%type <tree>		ident

%type <tree>		illegal_ident

%type <tree>		integer_lit

%type <tree>		integer_type

%type <tree>		interface

%type <tree>		interface_body

%type <tree>		interface_catch_ident

%type <tree>		is_context_expr

%type <tree>		is_raises_expr

%type <tree>		literal

%type <tree>		member

%type <tree>		member_list

%type <tree>		member_zlist

%type <tree>		module

%type <tree>		mult_expr

%type <tree>		new_ident

%type <tree>		new_or_prev_scope

%type <tree>		new_scope

%type <tree>		ns_global_ident

%type <tree>		ns_new_ident

%type <tree>		ns_prev_ident

%type <tree>		ns_scoped_name

%type <tree>		object_type

%type <tree>		octet_type

%type <tree>		op_dcl

%type <tree>		op_dcl_def

%type <tree>		op_param_type_spec

%type <tree>		op_param_type_spec_illegal

%type <tree>		op_type_spec

%type <tree>		or_expr

%type <tree>		param_dcl

%type <tree>		param_dcl_list

%type <tree>		param_type_spec

%type <tree>		pop_scope

%type <tree>		positive_int_const

%type <tree>		primary_expr

%type <tree>		raises_expr

%type <tree>		scoped_name

%type <tree>		scoped_name_list

%type <tree>		sequence_type

%type <tree>		shift_expr

%type <tree>		simple_declarator

%type <tree>		simple_declarator_list

%type <tree>		simple_type_spec

%type <tree>		specification

%type <tree>		srcfile

%type <tree>		string_lit

%type <tree>		string_lit_list

%type <tree>		string_type

%type <tree>		struct_type

%type <tree>		switch_body

%type <tree>		switch_type_spec

%type <tree>		template_type_spec

%type <tree>		type_dcl

%type <tree>		type_dcl_def

%type <tree>		type_declarator

%type <tree>		type_spec

%type <tree>		unary_expr

%type <tree>		union_type

%type <tree>		useless_semicolon

%type <tree>		wide_char_type

%type <tree>		wide_string_type

%type <tree>		xor_expr

%type <tree>		z_definition_list

%type <tree>		z_inheritance

%type <tree>		z_new_ident_catch

%type <tree>		z_new_scope_catch

%type <tree>		typecode_type

%type <treedata>	parameter_dcls

%type <declspec>	z_declspec module_declspec

%type <hash_table>	z_props prop_hash

%type <boolean>		is_readonly is_oneway

%type <boolean>		is_varargs is_cvarargs

%type <integer>		signed_int unsigned_int

%type <paramattr>	param_attribute

%type <str>		sqstring dqstring dqstring_cat

%type <unaryop>		unary_op

%%

specification:		/* empty */			{ yyerror ("Empty file"); YYABORT; }

|			definition_list			{ __IDL_root = $1; }

	;

z_definition_list:	/* empty */			{ $$ = NULL; }

|			definition_list

	;

definition_list:	definition			{ $$ = list_start ($1, TRUE); }

|			definition_list definition	{ $$ = list_chain ($1, $2, TRUE); }

	;

check_semicolon:	';'

|			/* empty */			{

	if (do_token_error ($<tree>0, "Missing semicolon after", TRUE))

		YYABORT;

}

	;

useless_semicolon:	';'				{

	yyerror ("Dangling semicolon has no effect");

	$$ = NULL;

}

	;

check_comma:		','

|			/* empty */			{

	if (do_token_error ($<tree>0, "Missing comma after", TRUE))

		YYABORT;

}

	;

illegal_ident:		scoped_name			{

	if (IDL_NODE_UP ($1))

		do_token_error (IDL_NODE_UP ($1), "Illegal context for", FALSE);

	else

		yyerror ("Illegal context for identifier");

	YYABORT;

}

	;

definition:		type_dcl check_semicolon

|			const_dcl check_semicolon

|			except_dcl check_semicolon

|			interface check_semicolon

|			module check_semicolon

|			codefrag

|			srcfile

|			illegal_ident

|			useless_semicolon

	;

module_declspec:	z_declspec TOK_MODULE

	;

module:			module_declspec

			new_or_prev_scope		{

	if (IDL_NODE_UP ($2) != NULL &&

	    IDL_NODE_TYPE (IDL_NODE_UP ($2)) != IDLN_MODULE) {

		yyerror ("Module definition conflicts");

		do_token_error (IDL_NODE_UP ($2), "with", FALSE);

		YYABORT;

	}

}			'{'

				z_definition_list

			'}' pop_scope			{

	IDL_tree module;

	if ($5 == NULL) {

		yyerrorv ("Empty module declaration `%s' is not legal IDL",

			  IDL_IDENT ($2).str);

		module = NULL;

	}

	if (__IDL_flags & IDLF_COMBINE_REOPENED_MODULES) {

		if (IDL_NODE_UP ($2) == NULL)

			module = IDL_module_new ($2, $5);

		else {

			module = IDL_NODE_UP ($2);

			IDL_MODULE (module).definition_list =

				IDL_list_concat (IDL_MODULE (module).definition_list, $5);

			module = NULL;

		}

	} else

		module = IDL_module_new ($2, $5);

	$$ = module;

	if ($$) assign_declspec ($$, $1);

}

	;

/* We only catch these errors for non-pidl because we want to be able to compile

   the OMG CORBA .idl files which define interfaces by these names */

interface_catch_ident:	new_or_prev_scope

|			TOK_OBJECT			{

	yyerror ("Interfaces cannot be named `Object'");

	YYABORT;

}

|			TOK_TYPECODE			{

	yyerror ("Interfaces cannot be named `TypeCode'");

	YYABORT;

}

	;

interface:		z_declspec

			z_props

			TOK_INTERFACE

			interface_catch_ident		{

	assert ($4 != NULL);

	assert (IDL_NODE_TYPE ($4) == IDLN_IDENT);

	assert (IDL_IDENT_TO_NS ($4) != NULL);

	assert (IDL_NODE_TYPE (IDL_IDENT_TO_NS ($4)) == IDLN_GENTREE);

	if (IDL_NODE_UP ($4) != NULL &&

	    IDL_NODE_TYPE (IDL_NODE_UP ($4)) != IDLN_INTERFACE &&

	    IDL_NODE_TYPE (IDL_NODE_UP ($4)) != IDLN_FORWARD_DCL) {

		yyerrorl ("Interface definition conflicts",

			  __IDL_prev_token_line - __IDL_cur_token_line);

		do_token_error (IDL_NODE_UP ($4), "with", FALSE);

		YYABORT;

	} else if (IDL_NODE_UP ($4) != NULL &&

		   IDL_NODE_TYPE (IDL_NODE_UP ($4)) != IDLN_FORWARD_DCL) {

		yyerrorv ("Cannot redeclare interface `%s'", IDL_IDENT ($4).str);

		IDL_tree_error ($4, "Previous declaration of interface `%s'", IDL_IDENT ($4).str);

		YYABORT;

	} else if (IDL_NODE_UP ($4) != NULL &&

		   IDL_NODE_TYPE (IDL_NODE_UP ($4)) == IDLN_FORWARD_DCL)

		__IDL_assign_this_location ($4, __IDL_cur_filename, __IDL_cur_line);

}

			pop_scope

			z_inheritance			{

	IDL_GENTREE (IDL_IDENT_TO_NS ($4))._import = $7;

	IDL_ns_push_scope (__IDL_root_ns, IDL_IDENT_TO_NS ($4));

	if (IDL_ns_check_for_ambiguous_inheritance ($4, $7))

		__IDL_is_okay = FALSE;

}			'{'

				interface_body

			'}' pop_scope			{

 	$$ = IDL_interface_new ($4, $7, $10);

	assign_declspec ($$, $1);

	assign_props (IDL_INTERFACE ($$).ident, $2);

}

|			z_declspec

			z_props

			TOK_INTERFACE

			interface_catch_ident

			pop_scope			{

	if ($2) yywarningv (IDL_WARNING1,

			    "Ignoring properties for forward declaration `%s'",

			    IDL_IDENT ($4).str);

	$$ = IDL_forward_dcl_new ($4);

	assign_declspec ($$, $1);

}

	;

z_inheritance:		/* empty */			{ $$ = NULL; }

|			':' scoped_name_list		{

	GHashTable *table = g_hash_table_new (g_direct_hash, g_direct_equal);

	gboolean die = FALSE;

	IDL_tree p = $2;

	assert (IDL_NODE_TYPE (p) == IDLN_LIST);

	for (; p != NULL && !die; p = IDL_LIST (p).next) {

		assert (IDL_LIST (p).data != NULL);

		assert (IDL_NODE_TYPE (IDL_LIST (p).data) == IDLN_IDENT);

		if (g_hash_table_lookup_extended (table, IDL_LIST (p).data, NULL, NULL)) {

			char *s = IDL_ns_ident_to_qstring (IDL_LIST (p).data, "::", 0);

			yyerrorv ("Cannot inherit from interface `%s' more than once", s);

			g_free (s);

			die = TRUE;

			break;

		} else

			g_hash_table_insert (table, IDL_LIST (p).data, NULL);

		if (IDL_NODE_TYPE (IDL_NODE_UP (IDL_LIST (p).data)) == IDLN_FORWARD_DCL) {

			char *s = IDL_ns_ident_to_qstring (IDL_LIST (p).data, "::", 0);

			yyerrorv ("Incomplete definition of interface `%s'", s);

			IDL_tree_error (IDL_LIST (p).data,

					"Previous forward declaration of `%s'", s);

			g_free (s);

			die = TRUE;

		}

		else if (IDL_NODE_TYPE (IDL_NODE_UP (IDL_LIST (p).data)) != IDLN_INTERFACE) {

			char *s = IDL_ns_ident_to_qstring (IDL_LIST (p).data, "::", 0);

			yyerrorv ("`%s' is not an interface", s);

			IDL_tree_error (IDL_LIST (p).data,

					"Previous declaration of `%s'", s);

			g_free (s);

			die = TRUE;

		}

	}

	g_hash_table_destroy (table);

	if (die)

		YYABORT;

	$$ = $2;

}

	;

scoped_name_list:	scoped_name			{ $$ = list_start ($1, TRUE); }

|			scoped_name_list

			check_comma scoped_name		{ $$ = list_chain ($1, $3, TRUE); }

	;

interface_body:		export_list

	;

export_list:		/* empty */			{ $$ = NULL; }

|			export_list export		{ $$ = zlist_chain ($1, $2, TRUE); }

	;

export:			type_dcl check_semicolon

|			except_dcl check_semicolon

|			op_dcl check_semicolon

|			attr_dcl check_semicolon

|			const_dcl check_semicolon

|			codefrag

|			useless_semicolon

	;

type_dcl:		z_declspec type_dcl_def		{

	$$ = $2;

	assign_declspec ($$, $1);

}

	;

type_dcl_def:		z_props TOK_TYPEDEF

			type_declarator			{

	IDL_tree_node node;

	IDL_tree p, dcl;

	$$ = $3;

	node.properties = $1;

	for (p = IDL_TYPE_DCL ($3).dcls; p; p = IDL_LIST (p).next) {

		dcl = IDL_LIST (p).data;

		IDL_tree_properties_copy (&node, dcl);

	}

	__IDL_free_properties (node.properties);

}

|			struct_type

|			union_type

|			enum_type

|			z_props TOK_NATIVE

			simple_declarator		{

	$$ = IDL_native_new ($3);

	assign_props (IDL_NATIVE ($$).ident, $1);

}

|			z_props TOK_NATIVE simple_declarator

			'('				{

	/* Enable native type scanning */

	if (__IDL_pidl > 0)

		__IDL_flagsi |= IDLFP_NATIVE;

	else {

		yyerror ("Native syntax not enabled");

		YYABORT;

	}

}			TOK_NATIVE_TYPE			{

	$$ = IDL_native_new ($3);

	IDL_NATIVE ($$).user_type = $6;

	assign_props (IDL_NATIVE ($$).ident, $1);

}

	;

type_declarator:	type_spec declarator_list	{ $$ = IDL_type_dcl_new ($1, $2); }

	;

type_spec:		simple_type_spec

|			constr_type_spec

	;

simple_type_spec:	base_type_spec

|			template_type_spec

|			scoped_name

	;

constr_type_spec:	struct_type

|			union_type

|			enum_type

	;

z_new_ident_catch:	/* empty */			{

	yyerrorv ("Missing identifier in %s definition", $<str>0);

	YYABORT;

}

|			new_ident

	;

z_new_scope_catch:	/* empty */			{

	yyerrorv ("Missing identifier in %s definition", $<str>0);

	YYABORT;

}

|			new_scope

	;

struct_type:		z_props TOK_STRUCT

			{ $<str>$ = "struct"; }

			z_new_scope_catch '{'		{

	g_hash_table_insert (__IDL_structunion_ht, $4, $4);

	$<tree>$ = IDL_type_struct_new ($4, NULL);

}				member_list

			'}' pop_scope			{

	g_hash_table_remove (__IDL_structunion_ht, $4);

	$$ = $<tree>6;

	__IDL_assign_up_node ($$, $7);

	IDL_TYPE_STRUCT ($$).member_list = $7;

	assign_props (IDL_TYPE_STRUCT ($$).ident, $1);

}

	;

union_type:		z_props TOK_UNION

			{ $<str>$ = "union"; }

			z_new_scope_catch TOK_SWITCH '('

				switch_type_spec

			')' '{'				{

	g_hash_table_insert (__IDL_structunion_ht, $4, $4);

	$<tree>$ = IDL_type_union_new ($4, $7, NULL);

}				switch_body

			'}' pop_scope			{

	g_hash_table_remove (__IDL_structunion_ht, $4);

	$$ = $<tree>10;

	__IDL_assign_up_node ($$, $11);

	IDL_TYPE_UNION ($$).switch_body = $11;

	assign_props (IDL_TYPE_UNION ($$).ident, $1);

}

	;

switch_type_spec:	integer_type

|			char_type

|			boolean_type

|			enum_type

|			scoped_name

	;

switch_body:		case_stmt_list

	;

case_stmt_list:		case_stmt			{ $$ = list_start ($1, TRUE); }

|			case_stmt_list case_stmt	{ $$ = list_chain ($1, $2, TRUE); }

	;

case_stmt:		case_label_list

			element_spec check_semicolon	{ $$ = IDL_case_stmt_new ($1, $2); }

	;

element_spec:		type_spec declarator		{

	char *s;

	$$ = IDL_member_new ($1, list_start ($2, TRUE));

	if (IDL_NODE_TYPE ($1) == IDLN_IDENT &&

	    g_hash_table_lookup (__IDL_structunion_ht, $1)) {

		s = IDL_ns_ident_to_qstring ($2, "::", 0);

		yyerrorv ("Member `%s'", s);

		do_token_error (IDL_NODE_UP ($1), "recurses", TRUE);

		g_free (s);

	}

}

	;

case_label_list:	case_label			{ $$ = list_start ($1, FALSE); }

|			case_label_list case_label	{ $$ = list_chain ($1, $2, FALSE); }

	;

case_label:		TOK_CASE const_exp ':'		{ $$ = $2; }

|			TOK_DEFAULT ':'			{ $$ = NULL; }

	;

const_dcl:		z_declspec const_dcl_def	{

	$$ = $2;

	assign_declspec ($$, $1);

}

	;

const_dcl_def:		TOK_CONST const_type new_ident

			'=' const_exp			{

	$$ = IDL_const_dcl_new ($2, $3, $5);

	/* Should probably do some type checking here... */

}

	;

except_dcl:		z_declspec except_dcl_def	{

	$$ = $2;

	assign_declspec ($$, $1);

}

	;

except_dcl_def:		TOK_EXCEPTION new_scope '{'

				member_zlist

			'}' pop_scope			{ $$ = IDL_except_dcl_new ($2, $4); }

	;

member_zlist:		/* empty */			{ $$ = NULL; }

|			member_zlist member		{ $$ = zlist_chain ($1, $2, TRUE); }

	;

is_readonly:		/* empty */			{ $$ = FALSE; }

|			TOK_READONLY			{ $$ = TRUE; }

	;

attr_dcl:		z_declspec attr_dcl_def		{

	$$ = $2;

	assign_declspec ($$, $1);

}

	;

attr_dcl_def:		z_props

			is_readonly

			TOK_ATTRIBUTE

			{ $<str>$ = "attribute"; }

			param_type_spec

			simple_declarator_list		{

	IDL_tree_node node;

	IDL_tree p, dcl;

	$$ = IDL_attr_dcl_new ($2, $5, $6);

	node.properties = $1;

	for (p = $6; p; p = IDL_LIST (p).next) {

		dcl = IDL_LIST (p).data;

		IDL_tree_properties_copy (&node, dcl);

	}

	__IDL_free_properties (node.properties);

}

	;

param_type_spec:	op_param_type_spec

|			TOK_VOID			{

	yyerrorv ("Illegal type `void' for %s", $<str>0);

	$$ = NULL;

}

	;

op_param_type_spec_illegal:

			sequence_type

|			constr_type_spec

	;

op_param_type_spec:	base_type_spec

|			string_type

|			wide_string_type

|			fixed_pt_type

|			scoped_name

|			op_param_type_spec_illegal	{

	illegal_context_type_error ($1, $<str>0);

	$$ = $1;

}

	;

is_oneway:		/* empty */			{ $$ = FALSE; }

|			TOK_ONEWAY			{ $$ = TRUE; }

	;

op_dcl:		z_declspec op_dcl_def			{

	$$ = $2;

	assign_declspec ($$, $1);

}

	;

op_dcl_def:		z_props

			is_oneway

			op_type_spec

			new_scope parameter_dcls pop_scope

			is_raises_expr

			is_context_expr			{

	$$ = IDL_op_dcl_new ($2, $3, $4, $5.tree, $7, $8);

	IDL_OP_DCL ($$).f_varargs = GPOINTER_TO_INT ($5.data);

	assign_props (IDL_OP_DCL ($$).ident, $1);

}

	;

op_type_spec:		{ $<str>$ = "operation return value"; }

			op_param_type_spec		{ $$ = $2; }

|			TOK_VOID			{ $$ = NULL; }

	;

is_varargs:		/* empty */			{ $$ = FALSE; }

|			TOK_VARARGS			{ $$ = TRUE; }

	;

is_cvarargs:		/* empty */			{ $$ = FALSE; }

|			',' TOK_VARARGS			{ $$ = TRUE; }

	;

parameter_dcls:		'('

			param_dcl_list

			is_cvarargs

			')'				{

	$$.tree = $2;

	$$.data = GINT_TO_POINTER ($3);

}

|			'(' is_varargs ')'		{

	$$.tree = NULL;

	$$.data = GINT_TO_POINTER ($2);

}

	;

param_dcl_list:		param_dcl			{ $$ = list_start ($1, TRUE); }

|			param_dcl_list

			check_comma param_dcl		{ $$ = list_chain ($1, $3, TRUE); }

	;

param_dcl:		z_props

			param_attribute

			{ $<str>$ = "parameter"; }

			param_type_spec

			simple_declarator		{

	$$ = IDL_param_dcl_new ($2, $4, $5);

	assign_props (IDL_PARAM_DCL ($$).simple_declarator, $1);

}

	;

param_attribute:	TOK_IN				{ $$ = IDL_PARAM_IN; }

|			TOK_OUT				{ $$ = IDL_PARAM_OUT; }

|			TOK_INOUT			{ $$ = IDL_PARAM_INOUT; }

|			param_type_spec			{

	yyerrorv ("Missing direction attribute (in, out, inout) before parameter");

	IDL_tree_free ($1);

}

	;

is_raises_expr:		/* empty */			{ $$ = NULL; }

|			raises_expr

	;

is_context_expr:	/* empty */			{ $$ = NULL; }

|			context_expr

	;

raises_expr:		TOK_RAISES '('

				scoped_name_list

			')'				{ $$ = $3; }

	;

context_expr:		TOK_CONTEXT '('

				string_lit_list

			')'				{ $$ = $3; }

	;

const_type:		integer_type

|			char_type

|			octet_type

|			wide_char_type

|			boolean_type

|			floating_pt_type

|			string_type

|			wide_string_type

|			fixed_pt_const_type

|			scoped_name

	;

const_exp:		or_expr

	;

or_expr:		xor_expr

|			or_expr '|' xor_expr		{ do_binop ($$, IDL_BINOP_OR, $1, $3); }

	;

xor_expr:		and_expr

|			xor_expr '^' and_expr		{ do_binop ($$, IDL_BINOP_XOR, $1, $3); }

	;

and_expr:		shift_expr

|			and_expr '&' shift_expr		{ do_binop ($$, IDL_BINOP_AND, $1, $3); }

	;

shift_expr:		add_expr

|			shift_expr TOK_OP_SHR add_expr	{ do_binop ($$, IDL_BINOP_SHR, $1, $3); }

|			shift_expr TOK_OP_SHL add_expr	{ do_binop ($$, IDL_BINOP_SHL, $1, $3); }

	;

add_expr:		mult_expr