Go to:
Gentoo Home
Documentation
Forums
Lists
Bugs
Planet
Store
Wiki
Get Gentoo!
Gentoo's Bugzilla – Attachment 171699 Details for
Bug 246681
=sys-devel/bison-2.4-r1 fail to compile parser.y from dev-libs/libIDL configure
Home
|
New
–
[Ex]
|
Browse
|
Search
|
Privacy Policy
|
[?]
|
Reports
|
Requests
|
Help
|
New Account
|
Log In
[x]
|
Forgot Password
Login:
[x]
tmp/portage/dev-libs/libIDL-0.8.11/work/libIDL-0.8.11/parser.y
parser.y (text/plain), 49.58 KB, created by
Francesco Riosa
on 2008-11-14 09:44:18 UTC
(
hide
)
Description:
tmp/portage/dev-libs/libIDL-0.8.11/work/libIDL-0.8.11/parser.y
Filename:
MIME Type:
Creator:
Francesco Riosa
Created:
2008-11-14 09:44:18 UTC
Size:
49.58 KB
patch
obsolete
>/*************************************************************************** > > 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); > $$ = 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); > $$ = 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 >| add_expr '+' mult_expr { do_binop ($$, IDL_BINOP_ADD, $1, $3); } >| add_expr '-' mult_expr { do_binop ($$, IDL_BINOP_SUB, $1, $3); } > ; > >mult_expr: unary_expr >| mult_expr '*' unary_expr { do_binop ($$, IDL_BINOP_MULT, $1, $3); } >| mult_expr '/' unary_expr { do_binop ($$, IDL_BINOP_DIV, $1, $3); } >| mult_expr '%' unary_expr { do_binop ($$, IDL_BINOP_MOD, $1, $3); } > ; > >unary_expr: unary_op primary_expr { do_unaryop ($$, $1, $2); } >| primary_expr > ; > >unary_op: '-' { $$ = IDL_UNARYOP_MINUS; } >| '+' { $$ = IDL_UNARYOP_PLUS; } >| '~' { $$ = IDL_UNARYOP_COMPLEMENT; } > ; > >primary_expr: scoped_name { > IDL_tree p, literal; > > assert (IDL_NODE_TYPE ($1) == IDLN_IDENT); > > p = IDL_NODE_UP ($1); > > if ((literal = IDL_resolve_const_exp ($1, IDLN_ANY))) { > ++IDL_NODE_REFS (literal); > $$ = literal; > IDL_tree_free ($1); > } else > $$ = $1; >} >| literal >| '(' const_exp ')' { $$ = $2; } > ; > >literal: integer_lit >| string_lit >| char_lit >| fixed_pt_lit >| floating_pt_lit >| boolean_lit > ; > >enum_type: z_props TOK_ENUM > { $<str>$ = "enum"; } > z_new_ident_catch '{' > enumerator_list > '}' { > $$ = IDL_type_enum_new ($4, $6); > assign_props (IDL_TYPE_ENUM ($$).ident, $1); >} > ; > >scoped_name: ns_scoped_name { > assert ($1 != NULL); > assert (IDL_NODE_TYPE ($1) == IDLN_GENTREE); > assert (IDL_NODE_TYPE (IDL_GENTREE ($1).data) == IDLN_IDENT); > $$ = IDL_GENTREE ($1).data; >} > ; > >ns_scoped_name: ns_prev_ident >| TOK_OP_SCOPE ns_global_ident { $$ = $2; } >| ns_scoped_name TOK_OP_SCOPE > ident { > IDL_tree p; > > assert (IDL_NODE_TYPE ($1) == IDLN_GENTREE); > assert (IDL_NODE_TYPE ($3) == IDLN_IDENT); > >#ifdef YYDEBUG > if (yydebug) > fprintf (stderr, "ns: looking in `%s' for `%s'\n", > IDL_IDENT (IDL_GENTREE ($1).data).str, IDL_IDENT($3).str); >#endif > > if ((p = IDL_ns_lookup_this_scope (__IDL_root_ns, $1, $3, NULL)) == NULL) { > yyerrorv ("`%s' undeclared identifier", IDL_IDENT ($3).str); > IDL_tree_free ($3); > YYABORT; > } > IDL_tree_free ($3); >#ifdef REF_IDENTS > ++IDL_NODE_REFS (IDL_GENTREE (p).data); >#endif > $$ = p; >} > ; > >enumerator_list: new_ident { $$ = list_start ($1, TRUE); } >| enumerator_list > check_comma new_ident { $$ = list_chain ($1, $3, TRUE); } > ; > >member_list: member { $$ = list_start ($1, TRUE); } >| member_list member { $$ = list_chain ($1, $2, TRUE); } > ; > >member: type_spec declarator_list > check_semicolon { > char *s; > > $$ = IDL_member_new ($1, $2); > if (IDL_NODE_TYPE ($1) == IDLN_IDENT && > g_hash_table_lookup (__IDL_structunion_ht, $1)) { > s = IDL_ns_ident_to_qstring (IDL_LIST ($2).data, "::", 0); > yyerrorv ("Member `%s'", s); > do_token_error (IDL_NODE_UP ($1), "recurses", TRUE); > g_free (s); > } >} > ; > >base_type_spec: floating_pt_type >| integer_type >| char_type >| wide_char_type >| boolean_type >| octet_type >| any_type >| object_type >| typecode_type > ; > >template_type_spec: sequence_type >| string_type >| wide_string_type >| fixed_pt_type > ; > >sequence_type: TOK_SEQUENCE '<' > simple_type_spec ',' positive_int_const > '>' { $$ = IDL_type_sequence_new ($3, $5); } >| TOK_SEQUENCE '<' > simple_type_spec > '>' { $$ = IDL_type_sequence_new ($3, NULL); } > ; > >floating_pt_type: TOK_FLOAT { $$ = IDL_type_float_new (IDL_FLOAT_TYPE_FLOAT); } >| TOK_DOUBLE { $$ = IDL_type_float_new (IDL_FLOAT_TYPE_DOUBLE); } >| TOK_LONG TOK_DOUBLE { $$ = IDL_type_float_new (IDL_FLOAT_TYPE_LONGDOUBLE); } > ; > >fixed_pt_type: TOK_FIXED '<' > positive_int_const ',' integer_lit > '>' { $$ = IDL_type_fixed_new ($3, $5); } > ; > >fixed_pt_const_type: TOK_FIXED { $$ = IDL_type_fixed_new (NULL, NULL); } > ; > >integer_type: signed_int { $$ = IDL_type_integer_new (TRUE, $1); } >| unsigned_int { $$ = IDL_type_integer_new (FALSE, $1); } > ; > >signed_int: signed_short_int { $$ = IDL_INTEGER_TYPE_SHORT; } >| signed_long_int { $$ = IDL_INTEGER_TYPE_LONG; } >| signed_longlong_int { $$ = IDL_INTEGER_TYPE_LONGLONG; } > ; > >signed_short_int: TOK_SHORT > ; > >signed_long_int: TOK_LONG > ; > >signed_longlong_int: TOK_LONG TOK_LONG > ; > >unsigned_int: unsigned_short_int { $$ = IDL_INTEGER_TYPE_SHORT; } >| unsigned_long_int { $$ = IDL_INTEGER_TYPE_LONG; } >| unsigned_longlong_int { $$ = IDL_INTEGER_TYPE_LONGLONG; } > ; > >unsigned_short_int: TOK_UNSIGNED TOK_SHORT > ; > >unsigned_long_int: TOK_UNSIGNED TOK_LONG > ; > >unsigned_longlong_int: TOK_UNSIGNED TOK_LONG TOK_LONG > ; > >char_type: TOK_CHAR { $$ = IDL_type_char_new (); } > ; > >wide_char_type: TOK_WCHAR { $$ = IDL_type_wide_char_new (); } > ; > >boolean_type: TOK_BOOLEAN { $$ = IDL_type_boolean_new (); } > ; > >octet_type: TOK_OCTET { $$ = IDL_type_octet_new (); } > ; > >any_type: TOK_ANY { $$ = IDL_type_any_new (); } > ; > >object_type: TOK_OBJECT { $$ = IDL_type_object_new (); } > ; > >typecode_type: TOK_TYPECODE { $$ = IDL_type_typecode_new (); } > ; > >string_type: TOK_STRING '<' > positive_int_const > '>' { $$ = IDL_type_string_new ($3); } >| TOK_STRING { $$ = IDL_type_string_new (NULL); } > ; > >wide_string_type: TOK_WSTRING '<' > positive_int_const > '>' { $$ = IDL_type_wide_string_new ($3); } >| TOK_WSTRING { $$ = IDL_type_wide_string_new (NULL); } > ; > >declarator_list: declarator { $$ = list_start ($1, TRUE); } >| declarator_list > check_comma declarator { $$ = list_chain ($1, $3, TRUE); } > ; > >declarator: simple_declarator >| complex_declarator > ; > >simple_declarator: new_ident > ; > >complex_declarator: array_declarator > ; > >simple_declarator_list: simple_declarator { $$ = list_start ($1, TRUE); } >| simple_declarator_list > check_comma simple_declarator { $$ = list_chain ($1, $3, TRUE); } > ; > >array_declarator: new_ident > fixed_array_size_list { > IDL_tree p; > int i; > > $$ = IDL_type_array_new ($1, $2); > for (i = 1, p = $2; p; ++i, p = IDL_LIST (p).next) > if (!IDL_LIST (p).data) { > char *s = IDL_ns_ident_to_qstring ($1, "::", 0); > yyerrorv ("Missing value in dimension %d of array `%s'", i, s); > g_free (s); > } >} > ; > >fixed_array_size_list: fixed_array_size { $$ = list_start ($1, FALSE); } >| fixed_array_size_list > fixed_array_size { $$ = list_chain ($1, $2, FALSE); } > ; > >fixed_array_size: '[' positive_int_const ']' { $$ = $2; } >| '[' ']' { $$ = NULL; } > ; > >prop_hash: TOK_PROP_KEY > TOK_PROP_VALUE { > $$ = g_hash_table_new (IDL_strcase_hash, IDL_strcase_equal); > g_hash_table_insert ($$, $1, $2); >} >| prop_hash ',' > TOK_PROP_KEY > TOK_PROP_VALUE { > $$ = $1; > g_hash_table_insert ($$, $3, $4); >} >| TOK_PROP_KEY { > $$ = g_hash_table_new (IDL_strcase_hash, IDL_strcase_equal); > g_hash_table_insert ($$, $1, g_strdup ("")); >} >| prop_hash ',' > TOK_PROP_KEY { > $$ = $1; > g_hash_table_insert ($$, $3, g_strdup ("")); >} > ; > >ident: TOK_IDENT { $$ = IDL_ident_new ($1); } > ; > >new_ident: ns_new_ident { > assert ($1 != NULL); > assert (IDL_NODE_TYPE ($1) == IDLN_GENTREE); > assert (IDL_NODE_TYPE (IDL_GENTREE ($1).data) == IDLN_IDENT); > $$ = IDL_GENTREE ($1).data; >} > ; > >new_scope: ns_new_ident { > IDL_tree old_top = IDL_GENTREE (IDL_NS (__IDL_root_ns).current).data; > IDL_ns_push_scope (__IDL_root_ns, $1); >#ifdef YYDEBUG > if (yydebug) > fprintf (stderr, "ns: entering new scope `%s' of `%s'\n", > IDL_IDENT (IDL_GENTREE (IDL_NS (__IDL_root_ns).current).data).str, IDL_IDENT(old_top).str); >#endif > assert (IDL_NODE_TYPE (IDL_GENTREE ($1).data) == IDLN_IDENT); > $$ = IDL_GENTREE ($1).data; >} > ; > >new_or_prev_scope: cur_ns_new_or_prev_ident { > IDL_tree old_top = IDL_GENTREE (IDL_NS (__IDL_root_ns).current).data; > IDL_ns_push_scope (__IDL_root_ns, $1); > assert (IDL_NS (__IDL_root_ns).current != NULL); > assert (IDL_NODE_TYPE (IDL_NS (__IDL_root_ns).current) == IDLN_GENTREE); > assert (IDL_GENTREE (IDL_NS (__IDL_root_ns).current).data != NULL); > assert (IDL_NODE_TYPE (IDL_GENTREE (IDL_NS (__IDL_root_ns).current).data) == IDLN_IDENT); >#ifdef YYDEBUG > if (yydebug) > fprintf (stderr,"ns: entering new/prev scope `%s' of `%s'\n", > IDL_IDENT (IDL_GENTREE (IDL_NS (__IDL_root_ns).current).data).str, IDL_IDENT(old_top).str); >#endif > assert (IDL_NODE_TYPE (IDL_GENTREE ($1).data) == IDLN_IDENT); > $$ = IDL_GENTREE ($1).data; >} > ; > >pop_scope: /* empty */ { > IDL_tree cur_top = IDL_GENTREE (IDL_NS (__IDL_root_ns).current).data; > IDL_ns_pop_scope (__IDL_root_ns); >#ifdef YYDEBUG > if (yydebug) > fprintf (stderr, "ns: pop scope from `%s' to `%s'\n", > IDL_IDENT(cur_top).str, > IDL_IDENT (IDL_GENTREE (IDL_NS (__IDL_root_ns).current).data).str); >#endif >} > ; > >ns_new_ident: ident { > IDL_tree p; > > if ((p = IDL_ns_place_new (__IDL_root_ns, $1)) == NULL) { > IDL_tree q; > int i; > > p = IDL_ns_lookup_cur_scope (__IDL_root_ns, $1, NULL); > > for (i = 0, q = IDL_GENTREE (p).data; > q && (IDL_NODE_TYPE (q) == IDLN_IDENT || > IDL_NODE_TYPE (q) == IDLN_LIST) && i < 4; > ++i) > if (IDL_NODE_UP (q)) > q = IDL_NODE_UP (q); > > if (q) { > IDL_tree_error ($1, "`%s' conflicts", IDL_IDENT ($1).str); > do_token_error (q, "with", FALSE); > } else > yyerrorv ("`%s' duplicate identifier", IDL_IDENT ($1).str); > > IDL_tree_free ($1); > YYABORT; > } > assert (IDL_IDENT ($1)._ns_ref == p); >#ifdef REF_IDENTS > ++IDL_NODE_REFS (IDL_GENTREE (p).data); >#endif > if (__IDL_new_ident_comments != NULL) { > assert (IDL_IDENT ($1).comments == NULL); > IDL_IDENT ($1).comments = __IDL_new_ident_comments; > __IDL_new_ident_comments = NULL; > } > $$ = p; >} > ; > >ns_prev_ident: ident { > IDL_tree p; > > if ((p = IDL_ns_resolve_ident (__IDL_root_ns, $1)) == NULL) { > yyerrorv ("`%s' undeclared identifier", IDL_IDENT ($1).str); > IDL_tree_free ($1); > YYABORT; > } > IDL_tree_free ($1); > assert (IDL_GENTREE (p).data != NULL); > assert (IDL_IDENT (IDL_GENTREE (p).data)._ns_ref == p); >#ifdef REF_IDENTS > ++IDL_NODE_REFS (IDL_GENTREE (p).data); >#endif > $$ = p; >} > ; > >cur_ns_new_or_prev_ident: > ident { > IDL_tree p; > > if ((p = IDL_ns_lookup_cur_scope (__IDL_root_ns, $1, NULL)) == NULL) { >#ifdef YYDEBUG > if (yydebug) > fprintf (stderr, "ns: place_new `%s' in `%s'\n", > IDL_IDENT($1).str, > IDL_IDENT(IDL_GENTREE (IDL_NS (__IDL_root_ns).current).data).str ); >#endif > p = IDL_ns_place_new (__IDL_root_ns, $1); > assert (p != NULL); > assert (IDL_IDENT ($1)._ns_ref == p); > if (__IDL_new_ident_comments != NULL) { > assert (IDL_IDENT ($1).comments == NULL); > IDL_IDENT ($1).comments = __IDL_new_ident_comments; > __IDL_new_ident_comments = NULL; > } > } else { > IDL_tree_free ($1); > assert (IDL_GENTREE (p).data != NULL); > assert (IDL_IDENT (IDL_GENTREE (p).data)._ns_ref == p); > } >#ifdef REF_IDENTS > ++IDL_NODE_REFS (IDL_GENTREE (p).data); >#endif > $$ = p; >} > ; > >ns_global_ident: ident { > IDL_tree p; > > if ((p = IDL_ns_lookup_this_scope ( > __IDL_root_ns,IDL_NS (__IDL_root_ns).file, $1, NULL)) == NULL) { > yyerrorv ("`%s' undeclared identifier", IDL_IDENT ($1).str); > IDL_tree_free ($1); > YYABORT; > } > IDL_tree_free ($1); > assert (IDL_GENTREE (p).data != NULL); > assert (IDL_IDENT (IDL_GENTREE (p).data)._ns_ref == p); >#ifdef REF_IDENTS > ++IDL_NODE_REFS (IDL_GENTREE (p).data); >#endif > $$ = p; >} > ; > >string_lit_list: string_lit { $$ = list_start ($1, TRUE); } >| string_lit_list > check_comma string_lit { $$ = list_chain ($1, $3, TRUE); } > ; > >positive_int_const: const_exp { > IDL_tree literal, ident = NULL; > IDL_longlong_t value = 0; > > if ((literal = IDL_resolve_const_exp ($1, IDLN_INTEGER))) { > assert (IDL_NODE_TYPE (literal) == IDLN_INTEGER); > ++IDL_NODE_REFS (literal); > value = IDL_INTEGER (literal).value; > if ( literal != $1 ) > IDL_tree_free ($1); > } > > if (literal && IDL_NODE_UP (literal) && > IDL_NODE_TYPE (IDL_NODE_UP (literal)) == IDLN_CONST_DCL) > ident = IDL_CONST_DCL (IDL_NODE_UP (literal)).ident; > > if (literal == NULL) { > if (!(__IDL_flags & IDLF_NO_EVAL_CONST)) > yyerror ("Could not resolve constant expression"); > $$ = $1; > } else if (value == 0) { > yyerror ("Zero array size is illegal"); > if (ident) > IDL_tree_error (ident, "From constant declared here"); > $$ = NULL; > } else if (value < 0) { > yywarningv (IDL_WARNING1, "Cannot use negative value %" > IDL_LL "d, using %" IDL_LL "d", > value, -value); > if (ident) > IDL_tree_warning (ident, > IDL_WARNING1, "From constant declared here"); > $$ = IDL_integer_new (-value); > } > else > $$ = IDL_integer_new (value); >} > ; > >z_declspec: /* empty */ { $$ = 0; } >| TOK_DECLSPEC { > $$ = IDL_parse_declspec ($1); > g_free ($1); >} > ; > >z_props: /* empty */ { $$ = NULL; } >| '[' { > /* Enable property scanning */ > if (__IDL_flags & IDLF_PROPERTIES) > __IDL_flagsi |= IDLFP_PROPERTIES; > else { > yyerror ("Property syntax not enabled"); > YYABORT; > } >} prop_hash > ']' { $$ = $3; } > ; > >integer_lit: TOK_INTEGER { $$ = IDL_integer_new ($1); } > ; > >string_lit: dqstring_cat { $$ = IDL_string_new ($1); } > ; > >char_lit: sqstring { $$ = IDL_char_new ($1); } > ; > >fixed_pt_lit: TOK_FIXEDP { $$ = IDL_fixed_new ($1); } > ; > >floating_pt_lit: TOK_FLOATP { $$ = IDL_float_new ($1); } > ; > >boolean_lit: TOK_TRUE { $$ = IDL_boolean_new (TRUE); } >| TOK_FALSE { $$ = IDL_boolean_new (FALSE); } > ; > >codefrag: z_declspec TOK_CODEFRAG { > $$ = $2; > assign_declspec ($$, $1); >} > ; > >srcfile: TOK_SRCFILE { > $$ = $1; >} > ; > >dqstring_cat: dqstring >| dqstring_cat dqstring { > char *catstr = g_malloc (strlen ($1) + strlen ($2) + 1); > strcpy (catstr, $1); g_free ($1); > strcat (catstr, $2); g_free ($2); > $$ = catstr; >} > ; > >dqstring: TOK_DQSTRING { > char *s = IDL_do_escapes ($1); > g_free ($1); > $$ = s; >} > ; > >sqstring: TOK_SQSTRING { > char *s = IDL_do_escapes ($1); > g_free ($1); > $$ = s; >} > ; > >%% > >void __IDL_parser_reset (void) >{ > yyclearin; >} > >static const char *IDL_ns_get_cur_prefix (IDL_ns ns) >{ > IDL_tree p; > > p = IDL_NS (ns).current; > > assert (p != NULL); > > while (p && !IDL_GENTREE (p)._cur_prefix) > p = IDL_NODE_UP (p); > > return p ? IDL_GENTREE (p)._cur_prefix : NULL; >} > >gchar *IDL_ns_ident_make_repo_id (IDL_ns ns, IDL_tree p, > const char *p_prefix, int *major, int *minor) >{ > GString *s = g_string_new (NULL); > const char *prefix; > char *q; > > assert (p != NULL); > > if (IDL_NODE_TYPE (p) == IDLN_IDENT) > p = IDL_IDENT_TO_NS (p); > > assert (p != NULL); > > prefix = p_prefix ? p_prefix : IDL_ns_get_cur_prefix (ns); > > q = IDL_ns_ident_to_qstring (p, "/", 0); > g_string_printf (s, "IDL:%s%s%s:%d.%d", > prefix ? prefix : "", > prefix && *prefix ? "/" : "", > q, > major ? *major : 1, > minor ? *minor : 0); > g_free (q); > > q = s->str; > g_string_free (s, FALSE); > > return q; >} > >static const char *get_name_token (const char *s, char **tok) >{ > const char *begin = s; > int state = 0; > > if (!s) > return NULL; > > while (g_ascii_isspace (*s)) ++s; > > while (1) switch (state) { > case 0: /* Unknown */ > if (*s == ':') > state = 1; > else if (isalnum ((int)*s) || *s == '_') { > begin = s; > state = 2; > } else > return NULL; > break; > case 1: /* Scope */ > if (strncmp (s, "::", 2) == 0) { > char *r = g_malloc (3); > strcpy (r, "::"); > *tok = r; > return s + 2; > } else /* Invalid */ > return NULL; > break; > case 2: > if (isalnum ((int)*s) || *s == '_') > ++s; > else { > char *r = g_malloc (s - begin + 1); > strncpy (r, begin, s - begin + 1); > r[s - begin] = 0; > *tok = r; > return s; > } > break; > } >} > >static IDL_tree IDL_ns_pragma_parse_name (IDL_ns ns, const char *s) >{ > IDL_tree p = IDL_NS (ns).current, q; > int start = 1; > char *tok; > > /* This is a hack to allow directives for an ident (such > * as and interface) to be located within the scope of > * that identifier. */ > if ( p && (q=IDL_GENTREE(p).data)!=0 > && IDL_NODE_TYPE(q)==IDLN_IDENT > && strcmp(s,IDL_IDENT(q).str)==0 ) { > return p; > } > > while (p && *s && (s = get_name_token (s, &tok))) { > if (tok == NULL) > return NULL; > if (strcmp (tok, "::") == 0) { > if (start) { > /* Globally scoped */ > p = IDL_NS (ns).file; > } > g_free (tok); > } else { > IDL_tree ident = IDL_ident_new (tok); > p = IDL_ns_lookup_this_scope (__IDL_root_ns, p, ident, NULL); > IDL_tree_free (ident); > } > start = 0; > } > > return p; >} > >void IDL_ns_ID (IDL_ns ns, const char *s) >{ > char name[1024], id[1024]; > IDL_tree p, ident; > int n; > > n = sscanf (s, "%1023s \"%1023s\"", name, id); > if (n < 2 && __IDL_is_parsing) { > yywarning (IDL_WARNING1, "Malformed pragma ID"); > return; > } > if (id[strlen (id) - 1] == '"') > id[strlen (id) - 1] = 0; > > p = IDL_ns_pragma_parse_name (__IDL_root_ns, name); > if (!p && __IDL_is_parsing) { > yywarningv (IDL_WARNING1, "Unknown identifier `%s' in pragma ID", name); > return; > } > > /* We have resolved the identifier, so assign the repo id */ > assert (IDL_NODE_TYPE (p) == IDLN_GENTREE); > assert (IDL_GENTREE (p).data != NULL); > assert (IDL_NODE_TYPE (IDL_GENTREE (p).data) == IDLN_IDENT); > ident = IDL_GENTREE (p).data; > > if (IDL_IDENT_REPO_ID (ident) != NULL) > g_free (IDL_IDENT_REPO_ID (ident)); > > IDL_IDENT_REPO_ID (ident) = g_strdup (id); >} > >void IDL_ns_version (IDL_ns ns, const char *s) >{ > char name[1024]; > int n, major, minor; > IDL_tree p, ident; > > n = sscanf (s, "%1023s %u.%u", name, &major, &minor); > if (n < 3 && __IDL_is_parsing) { > yywarning (IDL_WARNING1, "Malformed pragma version"); > return; > } > > p = IDL_ns_pragma_parse_name (__IDL_root_ns, name); > if (!p && __IDL_is_parsing) { > yywarningv (IDL_WARNING1, "Unknown identifier `%s' in pragma version", name); > return; > } > > /* We have resolved the identifier, so assign the repo id */ > assert (IDL_NODE_TYPE (p) == IDLN_GENTREE); > assert (IDL_GENTREE (p).data != NULL); > assert (IDL_NODE_TYPE (IDL_GENTREE (p).data) == IDLN_IDENT); > ident = IDL_GENTREE (p).data; > > if (IDL_IDENT_REPO_ID (ident) != NULL) { > char *v = strrchr (IDL_IDENT_REPO_ID (ident), ':'); > if (v) { > GString *s; > > *v = 0; > s = g_string_new (NULL); > g_string_printf (s, "%s:%d.%d", > IDL_IDENT_REPO_ID (ident), major, minor); > g_free (IDL_IDENT_REPO_ID (ident)); > IDL_IDENT_REPO_ID (ident) = s->str; > g_string_free (s, FALSE); > } else if (__IDL_is_parsing) > yywarningv (IDL_WARNING1, "Cannot find RepositoryID OMG IDL version in ID `%s'", > IDL_IDENT_REPO_ID (ident)); > } else > IDL_IDENT_REPO_ID (ident) = > IDL_ns_ident_make_repo_id ( > __IDL_root_ns, p, NULL, &major, &minor); >} > >int IDL_inhibit_get (void) >{ > g_return_val_if_fail (__IDL_is_parsing, -1); > > return __IDL_inhibits; >} > >void IDL_inhibit_push (void) >{ > g_return_if_fail (__IDL_is_parsing); > > ++__IDL_inhibits; >} > >void IDL_inhibit_pop (void) >{ > g_return_if_fail (__IDL_is_parsing); > > if (--__IDL_inhibits < 0) > __IDL_inhibits = 0; >} > >static void IDL_inhibit (IDL_ns ns, const char *s) >{ > if (g_ascii_strcasecmp ("push", s) == 0) > IDL_inhibit_push (); > else if (g_ascii_strcasecmp ("pop", s) == 0) > IDL_inhibit_pop (); >} > >static void IDL_typecodes_as_tok (IDL_ns ns, const char *s) >{ > if (g_ascii_strcasecmp ("push", s) == 0) > ++(__IDL_typecodes_as_tok); > else if (g_ascii_strcasecmp ("pop", s) == 0) > --(__IDL_typecodes_as_tok); >} > >static void IDL_pidl (IDL_ns ns, const char *s) >{ > if (g_ascii_strcasecmp ("push", s) == 0) > ++(__IDL_pidl); > else if (g_ascii_strcasecmp ("pop", s) == 0) > --(__IDL_pidl); >} > >void __IDL_do_pragma (const char *s) >{ > int n; > char directive[256]; > > g_return_if_fail (__IDL_is_parsing); > g_return_if_fail (s != NULL); > > if (sscanf (s, "%255s%n", directive, &n) < 1) > return; > s += n; > while (g_ascii_isspace (*s)) ++s; > > if (strcmp (directive, "prefix") == 0) > IDL_ns_prefix (__IDL_root_ns, s); > else if (strcmp (directive, "ID") == 0) > IDL_ns_ID (__IDL_root_ns, s); > else if (strcmp (directive, "version") == 0) > IDL_ns_version (__IDL_root_ns, s); > else if (strcmp (directive, "inhibit") == 0) > IDL_inhibit (__IDL_root_ns, s); > else if (strcmp (directive, "typecodes_as_tok") == 0) > IDL_typecodes_as_tok (__IDL_root_ns, s); > else if (strcmp (directive, "pidl") == 0) > IDL_pidl (__IDL_root_ns, s); >} > >static IDL_declspec_t IDL_parse_declspec (const char *strspec) >{ > IDL_declspec_t flags = IDLF_DECLSPEC_EXIST; > > if (strspec == NULL) > return flags; > > if (strcmp (strspec, "inhibit") == 0) > flags |= IDLF_DECLSPEC_INHIBIT; > if (strcmp (strspec, "pidl") == 0) > flags |= IDLF_DECLSPEC_PIDL; > else if (__IDL_is_parsing) > yywarningv (IDL_WARNING1, "Ignoring unknown declspec `%s'", strspec); > > return flags; >} > >IDL_tree IDL_file_set (const char *filename, int line) >{ > IDL_fileinfo *fi; > IDL_tree tree = NULL; > > g_return_val_if_fail (__IDL_is_parsing, NULL); > > if (filename) { > const char *oldfilename = __IDL_cur_filename; > gboolean wasInhibit = IS_INHIBIT_STATE(); > gboolean isTop = >#ifdef HAVE_CPP_PIPE_STDIN > strlen (filename)==0; >#else > __IDL_tmp_filename && > strcmp (filename, __IDL_tmp_filename)==0; >#endif > if ( isTop ) { > filename = __IDL_real_filename; > __IDL_flagsi &= ~IDLFP_IN_INCLUDES; > } else { > __IDL_flagsi |= IDLFP_IN_INCLUDES; > } > > if ((fi=g_hash_table_lookup(__IDL_filename_hash, filename)) ) { > __IDL_cur_fileinfo = fi; > ++(fi->seenCnt); > } else { > fi = g_new0 (IDL_fileinfo, 1); > fi->name = g_strdup(filename); > g_hash_table_insert (__IDL_filename_hash, fi->name, fi); > } > __IDL_cur_fileinfo = fi; > __IDL_cur_filename = fi->name; > if ( (__IDL_flags & IDLF_SRCFILES)!=0 > && (oldfilename==0 > || strcmp(oldfilename,fi->name)!=0) ) { > tree = IDL_srcfile_new(fi->name, fi->seenCnt, isTop, wasInhibit); > } > } > > if (__IDL_cur_line > 0) > __IDL_cur_line = line; > return tree; >} > >void IDL_file_get (const char **filename, int *line) >{ > g_return_if_fail (__IDL_is_parsing); > > if (filename) > *filename = __IDL_cur_filename; > > if (line) > *line = __IDL_cur_line; >} > >static int do_token_error (IDL_tree p, const char *message, gboolean prev) >{ > int dienow; > char *what = NULL, *who = NULL; > > assert (p != NULL); > > dienow = IDL_tree_get_node_info (p, &what, &who); > > assert (what != NULL); > > if (who && *who) > IDL_tree_error (p, "%s %s `%s'", message, what, who); > else > IDL_tree_error (p, "%s %s", message, what); > > return dienow; >} > >static void illegal_context_type_error (IDL_tree p, const char *what) >{ > GString *s = g_string_new (NULL); > > g_string_printf (s, "Illegal type `%%s' for %s", what); > illegal_type_error (p, s->str); > g_string_free (s, TRUE); >} > >static void illegal_type_error (IDL_tree p, const char *message) >{ > GString *s; > > s = IDL_tree_to_IDL_string (p, NULL, IDLF_OUTPUT_NO_NEWLINES); > yyerrorv (message, s->str); > g_string_free (s, TRUE); >} > >static IDL_tree list_start (IDL_tree a, gboolean filter_null) >{ > IDL_tree p; > > if (!a && filter_null) > return NULL; > > p = IDL_list_new (a); > > return p; >} > >static IDL_tree list_chain (IDL_tree a, IDL_tree b, gboolean filter_null) >{ > IDL_tree p; > > if (filter_null) { > if (!b) > return a; > if (!a) > return list_start (b, filter_null); > } > > p = IDL_list_new (b); > a = IDL_list_concat (a, p); > > return a; >} > >static IDL_tree zlist_chain (IDL_tree a, IDL_tree b, gboolean filter_null) >{ > if (a == NULL) > return list_start (b, filter_null); > else > return list_chain (a, b, filter_null); >} > >static int IDL_binop_chktypes (enum IDL_binop op, IDL_tree a, IDL_tree b) >{ > if (IDL_NODE_TYPE (a) != IDLN_BINOP && > IDL_NODE_TYPE (b) != IDLN_BINOP && > IDL_NODE_TYPE (a) != IDLN_UNARYOP && > IDL_NODE_TYPE (b) != IDLN_UNARYOP && > IDL_NODE_TYPE (a) != IDL_NODE_TYPE (b)) { > yyerror ("Invalid mix of types in constant expression"); > return -1; > } > > switch (op) { > case IDL_BINOP_MULT: > case IDL_BINOP_DIV: > case IDL_BINOP_ADD: > case IDL_BINOP_SUB: > break; > > case IDL_BINOP_MOD: > case IDL_BINOP_SHR: > case IDL_BINOP_SHL: > case IDL_BINOP_AND: > case IDL_BINOP_OR: > case IDL_BINOP_XOR: > if ((IDL_NODE_TYPE (a) != IDLN_INTEGER || > IDL_NODE_TYPE (b) != IDLN_INTEGER) && > !(IDL_NODE_TYPE (a) == IDLN_BINOP || > IDL_NODE_TYPE (b) == IDLN_BINOP || > IDL_NODE_TYPE (a) == IDLN_UNARYOP || > IDL_NODE_TYPE (b) == IDLN_UNARYOP)) { > yyerror ("Invalid operation on non-integer value"); > return -1; > } > break; > } > > return 0; >} > >static int IDL_unaryop_chktypes (enum IDL_unaryop op, IDL_tree a) >{ > switch (op) { > case IDL_UNARYOP_PLUS: > case IDL_UNARYOP_MINUS: > break; > > case IDL_UNARYOP_COMPLEMENT: > if (IDL_NODE_TYPE (a) != IDLN_INTEGER && > !(IDL_NODE_TYPE (a) == IDLN_BINOP || > IDL_NODE_TYPE (a) == IDLN_UNARYOP)) { > yyerror ("Operand to complement must be integer"); > return -1; > } > break; > } > > return 0; >} > >static IDL_tree IDL_binop_eval_integer (enum IDL_binop op, IDL_tree a, IDL_tree b) >{ > IDL_tree p = NULL; > > assert (IDL_NODE_TYPE (a) == IDLN_INTEGER); > > switch (op) { > case IDL_BINOP_MULT: > p = IDL_integer_new (IDL_INTEGER (a).value * IDL_INTEGER (b).value); > break; > > case IDL_BINOP_DIV: > if (IDL_INTEGER (b).value == 0) { > yyerror ("Divide by zero in constant expression"); > return NULL; > } > p = IDL_integer_new (IDL_INTEGER (a).value / IDL_INTEGER (b).value); > break; > > case IDL_BINOP_ADD: > p = IDL_integer_new (IDL_INTEGER (a).value + IDL_INTEGER (b).value); > break; > > case IDL_BINOP_SUB: > p = IDL_integer_new (IDL_INTEGER (a).value - IDL_INTEGER (b).value); > break; > > case IDL_BINOP_MOD: > if (IDL_INTEGER (b).value == 0) { > yyerror ("Modulo by zero in constant expression"); > return NULL; > } > p = IDL_integer_new (IDL_INTEGER (a).value % IDL_INTEGER (b).value); > break; > > case IDL_BINOP_SHR: > p = IDL_integer_new (IDL_INTEGER (a).value >> IDL_INTEGER (b).value); > break; > > case IDL_BINOP_SHL: > p = IDL_integer_new (IDL_INTEGER (a).value << IDL_INTEGER (b).value); > break; > > case IDL_BINOP_AND: > p = IDL_integer_new (IDL_INTEGER (a).value & IDL_INTEGER (b).value); > break; > > case IDL_BINOP_OR: > p = IDL_integer_new (IDL_INTEGER (a).value | IDL_INTEGER (b).value); > break; > > case IDL_BINOP_XOR: > p = IDL_integer_new (IDL_INTEGER (a).value ^ IDL_INTEGER (b).value); > break; > } > > return p; >} > >static IDL_tree IDL_binop_eval_float (enum IDL_binop op, IDL_tree a, IDL_tree b) >{ > IDL_tree p = NULL; > > assert (IDL_NODE_TYPE (a) == IDLN_FLOAT); > > switch (op) { > case IDL_BINOP_MULT: > p = IDL_float_new (IDL_FLOAT (a).value * IDL_FLOAT (b).value); > break; > > case IDL_BINOP_DIV: > if (IDL_FLOAT (b).value == 0.0) { > yyerror ("Divide by zero in constant expression"); > return NULL; > } > p = IDL_float_new (IDL_FLOAT (a).value / IDL_FLOAT (b).value); > break; > > case IDL_BINOP_ADD: > p = IDL_float_new (IDL_FLOAT (a).value + IDL_FLOAT (b).value); > break; > > case IDL_BINOP_SUB: > p = IDL_float_new (IDL_FLOAT (a).value - IDL_FLOAT (b).value); > break; > > default: > break; > } > > return p; >} > >static IDL_tree IDL_binop_eval (enum IDL_binop op, IDL_tree a, IDL_tree b) >{ > assert (IDL_NODE_TYPE (a) == IDL_NODE_TYPE (b)); > > switch (IDL_NODE_TYPE (a)) { > case IDLN_INTEGER: return IDL_binop_eval_integer (op, a, b); > case IDLN_FLOAT: return IDL_binop_eval_float (op, a, b); > default: return NULL; > } >} > >static IDL_tree IDL_unaryop_eval_integer (enum IDL_unaryop op, IDL_tree a) >{ > IDL_tree p = NULL; > > assert (IDL_NODE_TYPE (a) == IDLN_INTEGER); > > switch (op) { > case IDL_UNARYOP_PLUS: > p = IDL_integer_new (IDL_INTEGER (a).value); > break; > > case IDL_UNARYOP_MINUS: > p = IDL_integer_new (-IDL_INTEGER (a).value); > break; > > case IDL_UNARYOP_COMPLEMENT: > p = IDL_integer_new (~IDL_INTEGER (a).value); > break; > } > > return p; >} > >static IDL_tree IDL_unaryop_eval_fixed (enum IDL_unaryop op, IDL_tree a) >{ > IDL_tree p = NULL; > > assert (IDL_NODE_TYPE (a) == IDLN_FIXED); > > switch (op) { > case IDL_UNARYOP_PLUS: > p = IDL_fixed_new (IDL_FIXED (a).value); > break; > > default: > break; > } > > return p; >} > >static IDL_tree IDL_unaryop_eval_float (enum IDL_unaryop op, IDL_tree a) >{ > IDL_tree p = NULL; > > assert (IDL_NODE_TYPE (a) == IDLN_FLOAT); > > switch (op) { > case IDL_UNARYOP_PLUS: > p = IDL_float_new (IDL_FLOAT (a).value); > break; > > case IDL_UNARYOP_MINUS: > p = IDL_float_new (-IDL_FLOAT (a).value); > break; > > default: > break; > } > > return p; >} > >static IDL_tree IDL_unaryop_eval (enum IDL_unaryop op, IDL_tree a) >{ > switch (IDL_NODE_TYPE (a)) { > case IDLN_INTEGER: return IDL_unaryop_eval_integer (op, a); > case IDLN_FIXED: return IDL_unaryop_eval_fixed (op, a); > case IDLN_FLOAT: return IDL_unaryop_eval_float (op, a); > default: return NULL; > } >} > >IDL_tree IDL_resolve_const_exp (IDL_tree p, IDL_tree_type type) >{ > gboolean resolved_value = FALSE, die = FALSE; > gboolean wrong_type = FALSE; > > while (!resolved_value && !die) { > if (IDL_NODE_TYPE (p) == IDLN_IDENT) { > IDL_tree q = IDL_NODE_UP (p); > > assert (q != NULL); > if (IDL_NODE_UP (q) && > IDL_NODE_TYPE (IDL_NODE_UP (q)) == IDLN_TYPE_ENUM) { > p = q; > die = TRUE; > break; > } else if (IDL_NODE_TYPE (q) != IDLN_CONST_DCL) { > p = q; > wrong_type = TRUE; > die = TRUE; > } else > p = IDL_CONST_DCL (q).const_exp; > } > > if (p == NULL || > IDL_NODE_TYPE (p) == IDLN_BINOP || > IDL_NODE_TYPE (p) == IDLN_UNARYOP) { > die = TRUE; > continue; > } > > resolved_value = IDL_NODE_IS_LITERAL (p); > } > > if (resolved_value && > type != IDLN_ANY && > IDL_NODE_TYPE (p) != type) > wrong_type = TRUE; > > if (wrong_type) { > yyerror ("Invalid type for constant"); > IDL_tree_error (p, "Previous resolved type declaration"); > return NULL; > } > > return resolved_value ? p : NULL; >} > >void IDL_queue_new_ident_comment (const char *str) >{ > g_return_if_fail (str != NULL); > > __IDL_new_ident_comments = g_slist_append (__IDL_new_ident_comments, g_strdup (str)); >} > >/* > * Local variables: > * mode: C > * c-basic-offset: 8 > * tab-width: 8 > * indent-tabs-mode: t > * End: > */
You cannot view the attachment while viewing its details because your browser does not support IFRAMEs.
View the attachment on a separate page
.
View Attachment As Raw
Actions:
View
Attachments on
bug 246681
: 171699