/* $Header: /usr/export/home/marick/RCS/c-parse.y,v 1.23 1993/01/03 16:00:56 marick Exp $ $Log: c-parse.y,v $ * Revision 1.23 1993/01/03 16:00:56 marick * Copy in GNU C V2 support for ellipsis in odd places. Should let some * GCC 2.X programs be accepted. * * Revision 1.22 1992/11/04 03:40:41 marick * 1. Clean up initialization structure. * 2. Fixed gcc bug. (Too little space allocated for wide strings.) * * Revision 1.21 1992/09/21 21:11:24 marick * 1. Handle concatenated strings. * 2. Issue error message for wide strings and wide character constants. * * Revision 1.20 1992/09/04 14:41:23 marick * gct_hash_node had to be moved farther down for RS/6000. (Had to * follow a pragma from bison.simple.) * * Revision 1.19 1992/08/31 14:54:35 marick * Make gct_getc a macro for speed. * * Revision 1.18 1992/08/29 18:11:03 marick * GCT 1.4 alpha - first working version. * * Revision 1.17 1992/08/02 23:50:57 marick * Mapfile revision, part 1: each file uses its own pointer into Gct_table. * - Add necessary definitions to the GCT header at the front of the * instrumented file. * * Revision 1.16 1992/07/31 16:18:40 marick * 1. gcc.c now deletes temporaries for us. * 2. (option produce-object) now supported. * * Revision 1.15 1992/07/28 14:27:27 marick * Miscellaneous tidying. * * Revision 1.14 1992/06/17 13:53:23 marick * Support compound statements within expressions (the GNU C ({...}) * feature). GCC's private include files sometimes use this ( * and , in particular). * * Revision 1.13 1992/05/25 14:09:10 marick * Slight improvements in handling of backup files: * 1. Reset original file mode. * 2. Handle unreadable files in backup directory. * * Revision 1.12 1992/05/24 17:05:51 marick * gct_make_note has been split into gct_make_end_note and gct_make_current_note. * * Revision 1.11 1992/03/23 03:09:38 marick * Bugfix: nulls in C strings are now handled correctly for normal coverage. * * Revision 1.10 1991/11/19 15:17:55 marick * 1. Don't replace the file if the errorcount is positive. * 2. Don't call gct_finish when EOF is read -- the parser might still * declare a syntax error. Call it after yyparse() returns. * * Revision 1.9 91/08/27 11:25:46 marick * Pragmas are now handled. * * Revision 1.8 91/08/07 14:42:32 marick * 1. Patch for obscure bug when unary operator is followed by a hyperunary. * 2. Cretinous SysV filename limits (need to reduce further for RCS). * * Revision 1.7 91/04/14 13:29:23 marick * Bugfix: Mapfile filename was wrong for code in #included files. * * Revision 1.6 91/02/12 15:25:56 marick * 1. GCT no longer prohibits unnamed structs and unions. * 2. For some reason, some constant that's NULL on SunOS seems to be * "" on SysV88. Patched around for now; more investigation needed someday. * * Revision 1.5 91/01/12 14:54:01 marick * Let the TMPDIR environment variable override default location for * temporary files. * * Revision 1.4 91/01/07 12:05:50 marick * GCC bug: Lexer failed to null-terminate type-qualified integer * constants, like * */ /* YACC parser for C syntax. Copyright (C) 1987, 1988, 1989 Free Software Foundation, Inc. This file is part of GNU CC. GNU CC is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 1, or (at your option) any later version. GNU CC 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 General Public License for more details. You should have received a copy of the GNU General Public License along with GNU CC; see the file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ /* To whomever it may concern: I have heard that such a thing was once written by AT&T, but I have never seen it. */ %expect 8 /* These are the 8 conflicts you should get in parse.output; the state numbers may vary if minor changes in the grammar are made. State 41 contains 1 shift/reduce conflict. (Two ways to recover from error.) State 92 contains 1 shift/reduce conflict. (Two ways to recover from error.) State 99 contains 1 shift/reduce conflict. (Two ways to recover from error.) State 103 contains 1 shift/reduce conflict. (Two ways to recover from error.) State 119 contains 1 shift/reduce conflict. (See comment at component_decl.) State 183 contains 1 shift/reduce conflict. (Two ways to recover from error.) State 193 contains 1 shift/reduce conflict. (Two ways to recover from error.) State 199 contains 1 shift/reduce conflict. (Two ways to recover from error.) */ %{ #include "config.h" #include "tree.h" #include "input.h" #include "c-parse.h" #include "c-tree.h" #include #include /* GCT */ #include "gct-const.h" /* GCT */ #include "gct-util.h" /* GCT */ #include "gct-contro.h" /* GCT */ #include /* GCT */ #include "gct-tutil.h" /* GCT */ #include "gct-assert.h" /* GCT */ /* There are occasional "shift-reduce conflicts" in which the last node on the list may be an OTHER (unprocessed) node that stops the parse, but it may also be a processed node. An example of this is "(unsigned) sizeof(int)". The handling of such problems is special-casey, quick-and-dirty, kludgy, and ought to be rethought. */ #define GCT_LAST_MAYBE_SHIFT(list) \ ((GCT_LAST(list)->type == GCT_OTHER)? \ (GCT_LAST(list)->prev) : \ (GCT_LAST(list))) /* * Each function is hashed and that hash value is placed in the mapfile. * This hashval is calculated on all the tokens of a function. */ long Gct_function_hashval = 0; /* The code that does the hashing used to be here. It had to be moved down below because AIX is confused. */ #ifdef USG #define R_OK 4 /* From gcc.c */ #define W_OK 2 #define X_OK 1 #define vfork fork #endif /* USG */ #include #include #ifndef errno extern int errno; #endif void yyerror (); /* Cause the `yydebug' variable to be defined. */ #define YYDEBUG 1 %} %start program %union {long itype; tree ttype; enum tree_code code; } /* All identifiers that are not reserved words and are not declared typedefs in the current block */ %token IDENTIFIER /* All identifiers that are declared typedefs in the current block. In some contexts, they are treated just like IDENTIFIER, but they can also serve as typespecs in declarations. */ %token TYPENAME /* Reserved words that specify storage class. yylval contains an IDENTIFIER_NODE which indicates which one. */ %token SCSPEC /* Reserved words that specify type. yylval contains an IDENTIFIER_NODE which indicates which one. */ %token TYPESPEC /* Reserved words that qualify type: "const" or "volatile". yylval contains an IDENTIFIER_NODE which indicates which one. */ %token TYPE_QUAL /* Character or numeric constants. yylval is the node for the constant. */ %token CONSTANT /* String constants in raw form. yylval is a STRING_CST node. */ %token STRING /* "...", used for functions with variable arglists. */ %token ELLIPSIS /* the reserved words */ %token SIZEOF ENUM STRUCT UNION IF ELSE WHILE DO FOR SWITCH CASE DEFAULT %token BREAK CONTINUE RETURN GOTO ASM TYPEOF ALIGNOF %token ATTRIBUTE /* Add precedence rules to solve dangling else s/r conflict */ %nonassoc IF %nonassoc ELSE /* Define the operator tokens and their precedences. The value is an integer because, if used, it is the tree code to use in the expression made from the operator. */ %right ASSIGN '=' %right '?' ':' %left OROR %left ANDAND %left '|' %left '^' %left '&' %left EQCOMPARE %left ARITHCOMPARE %left LSHIFT RSHIFT %left '+' '-' %left '*' '/' '%' %right UNARY PLUSPLUS MINUSMINUS %left HYPERUNARY %left POINTSAT '.' '(' '[' %type unop %type identifier IDENTIFIER TYPENAME CONSTANT expr nonnull_exprlist exprlist %type expr_no_commas cast_expr unary_expr primary string STRING %type typed_declspecs reserved_declspecs %type typed_typespecs reserved_typespecquals %type declmods typespec typespecqual_reserved %type SCSPEC TYPESPEC TYPE_QUAL nonempty_type_quals maybe_type_qual %type initdecls notype_initdecls initdcl notype_initdcl %type init initlist maybeasm %type asm_operands nonnull_asm_operands asm_operand asm_clobbers %type maybe_attribute attribute_list attrib %type compstmt %type declarator %type notype_declarator after_type_declarator %type parm_declarator %type structsp component_decl_list component_decl components component_declarator %type enumlist enumerator %type typename absdcl absdcl1 type_quals %type xexpr parms parm identifiers %type parmlist parmlist_1 parmlist_2 %type parmlist_or_identifiers parmlist_or_identifiers_1 %type setspecs %{ /* the declaration found for the last IDENTIFIER token read in. yylex must look this up to detect typedefs, which get token type TYPENAME, so it is left around in case the identifier is not a typedef but is used in a context which makes it a reference to a variable. */ static tree lastiddecl; static tree make_pointer_declarator (); static tree combine_strings (); static void reinit_parse_for_function (); /* List of types and structure classes of the current declaration. */ tree current_declspecs; /* Stack of saved values of current_declspecs. */ tree declspec_stack; int undeclared_variable_notice; /* 1 if we explained undeclared var errors. */ static int yylex (); %} %% program: /* empty */ | extdefs ; /* the reason for the strange actions in this rule is so that notype_initdecls when reached via datadef can find a valid list of type and sc specs in $0. */ extdefs: {$$ = NULL_TREE; } extdef | extdefs {$$ = NULL_TREE; } extdef ; extdef: fndef | datadef | ASM '(' string ')' ';' { if (pedantic) warning ("ANSI C forbids use of `asm' keyword"); if (TREE_CHAIN ($3)) $3 = combine_strings ($3); assemble_asm ($3); } ; datadef: setspecs notype_initdecls ';' { if (pedantic) error ("ANSI C forbids data definition lacking type or storage class"); else if (!flag_traditional) warning ("data definition lacks type or storage class"); } | declmods setspecs notype_initdecls ';' {} | typed_declspecs setspecs initdecls ';' {} | declmods ';' { error ("empty declaration"); } | typed_declspecs ';' { shadow_tag ($1); } | error ';' | error '}' | ';' { if (pedantic) warning ("ANSI C does not allow extra `;' outside of a function"); } ; fndef: typed_declspecs setspecs declarator { if (! start_function ($1, $3)) YYERROR; Gct_function_hashval = 0; /* GCT */ reinit_parse_for_function (); } xdecls { store_parm_decls (); gct_parse_decls(); } compstmt_or_error { /* debug_dump_tree(current_function_decl); */ gct_ignore_decls(); gct_transform_function(GCT_LAST(Gct_all_nodes)); finish_function (lineno); } | typed_declspecs setspecs declarator error { } | declmods setspecs notype_declarator { if (! start_function ($1, $3)) YYERROR; Gct_function_hashval = 0; /* GCT */ reinit_parse_for_function (); } xdecls { store_parm_decls (); gct_parse_decls(); } compstmt_or_error { /* debug_dump_tree(current_function_decl); */ gct_transform_function(GCT_LAST(Gct_all_nodes)); gct_ignore_decls(); finish_function (lineno); } | declmods setspecs notype_declarator error { } | setspecs notype_declarator { if (! start_function (0, $2)) YYERROR; Gct_function_hashval = 0; /* GCT */ reinit_parse_for_function (); } xdecls { store_parm_decls (); gct_parse_decls(); } compstmt_or_error { /* debug_dump_tree(current_function_decl); */ gct_transform_function(GCT_LAST(Gct_all_nodes)); gct_ignore_decls(); finish_function (lineno); } | setspecs notype_declarator error { } ; identifier: IDENTIFIER | TYPENAME ; unop: '&' { $$ = ADDR_EXPR; } | '-' { $$ = NEGATE_EXPR; } | '+' { $$ = CONVERT_EXPR; } | PLUSPLUS { $$ = PREINCREMENT_EXPR; } | MINUSMINUS { $$ = PREDECREMENT_EXPR; } | '~' { $$ = BIT_NOT_EXPR; } | '!' { $$ = TRUTH_NOT_EXPR; } ; expr: nonnull_exprlist { if (GCT_COMMA == GCT_LAST(Gct_all_nodes)->prev->type) { gct_guard_comma(GCT_LAST(Gct_all_nodes)->prev); } $$ = build_compound_expr ($1); } ; exprlist: /* empty */ { $$ = NULL_TREE; } | nonnull_exprlist ; nonnull_exprlist: expr_no_commas { $$ = build_tree_list (NULL_TREE, $1); } | nonnull_exprlist ',' expr_no_commas { chainon ($1, build_tree_list (NULL_TREE, $3)); gct_build_comma_list(GCT_LAST(Gct_all_nodes)->prev->prev,$1); } ; unary_expr: primary | '*' cast_expr %prec UNARY { $$ = build_indirect_ref ($2, "unary *"); gct_build_unary(GCT_LAST(Gct_all_nodes)->prev->prev, GCT_DEREFERENCE, $$); } | unop cast_expr %prec UNARY { $$ = build_unary_op ($1, $2, 0); gct_build_unary_by_gcctype(GCT_LAST_MAYBE_SHIFT(Gct_all_nodes)->prev, $1, $$); } | SIZEOF unary_expr %prec UNARY { if (TREE_CODE ($2) == COMPONENT_REF && TREE_PACKED (TREE_OPERAND ($2, 1))) error ("`sizeof' applied to a bit-field"); /* ANSI says arrays and functions are converted inside comma. But we can't really convert them in build_compound_expr because that would break commas in lvalues. So do the conversion here if operand was a comma. */ if (TREE_CODE ($2) == COMPOUND_EXPR && (TREE_CODE (TREE_TYPE ($2)) == ARRAY_TYPE || TREE_CODE (TREE_TYPE ($2)) == FUNCTION_TYPE)) $2 = default_conversion ($2); $$ = c_sizeof (TREE_TYPE ($2)); gct_build_unary(GCT_LAST(Gct_all_nodes)->prev->prev, GCT_SIZEOF, $$); } | SIZEOF '(' typename ')' %prec HYPERUNARY { $$ = c_sizeof (groktypename ($3)); gct_build_of(GCT_LAST(Gct_all_nodes), GCT_SIZEOF, $$); } | ALIGNOF unary_expr %prec UNARY { if (TREE_CODE ($2) == COMPONENT_REF && TREE_PACKED (TREE_OPERAND ($2, 1))) error ("`__alignof' applied to a bit-field"); if (TREE_CODE ($2) == INDIRECT_REF) { tree t = TREE_OPERAND ($2, 0); tree best = t; int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t))); while (TREE_CODE (t) == NOP_EXPR && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE) { int thisalign; t = TREE_OPERAND (t, 0); thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t))); if (thisalign > bestalign) best = t, bestalign = thisalign; } $$ = c_alignof (TREE_TYPE (TREE_TYPE (best))); } else { /* ANSI says arrays and fns are converted inside comma. But we can't convert them in build_compound_expr because that would break commas in lvalues. So do the conversion here if operand was a comma. */ if (TREE_CODE ($2) == COMPOUND_EXPR && (TREE_CODE (TREE_TYPE ($2)) == ARRAY_TYPE || TREE_CODE (TREE_TYPE ($2)) == FUNCTION_TYPE)) $2 = default_conversion ($2); $$ = c_alignof (TREE_TYPE ($2)); } gct_build_unary(GCT_LAST(Gct_all_nodes)->prev->prev, GCT_ALIGNOF, $$); } | ALIGNOF '(' typename ')' %prec HYPERUNARY { $$ = c_alignof (groktypename ($3)); gct_build_of(GCT_LAST(Gct_all_nodes), GCT_ALIGNOF, $$); } ; cast_expr: unary_expr | '(' typename ')' cast_expr %prec UNARY { tree type = groktypename ($2); $$ = build_c_cast (type, $4); gct_build_cast(GCT_LAST_MAYBE_SHIFT(Gct_all_nodes), $$); } | '(' typename ')' '{' initlist maybecomma '}' %prec UNARY { tree type = groktypename ($2); /* GCT: Don't mess with this yet. if (pedantic) warning ("ANSI C forbids constructor expressions"); */ error("GCT doesn't handle constructor expressions."); YYERROR; /*NOTREACHED*/ #if 0 $$ = digest_init (type, build_nt (CONSTRUCTOR, NULL_TREE, nreverse ($5)), 0); if (TREE_CODE (type) == ARRAY_TYPE && TYPE_SIZE (type) == 0) { int failure = complete_array_type (type, $$, 1); if (failure) abort (); } #endif } ; expr_no_commas: cast_expr | expr_no_commas '+' expr_no_commas { $$ = build_binary_op ($2, $1, $3); /* There's a lookahead token on the tokenlist. */ gct_build_binary(GCT_LAST(Gct_all_nodes)->prev->prev, GCT_PLUS, $$); } | expr_no_commas '-' expr_no_commas { $$ = build_binary_op ($2, $1, $3); /* There's a lookahead token on the tokenlist. */ gct_build_binary(GCT_LAST(Gct_all_nodes)->prev->prev, GCT_MINUS, $$); } | expr_no_commas '*' expr_no_commas { $$ = build_binary_op ($2, $1, $3); /* There's a lookahead token on the tokenlist. */ gct_build_binary(GCT_LAST(Gct_all_nodes)->prev->prev, GCT_TIMES, $$); } | expr_no_commas '/' expr_no_commas { $$ = build_binary_op ($2, $1, $3); /* There's a lookahead token on the tokenlist. */ gct_build_binary(GCT_LAST(Gct_all_nodes)->prev->prev, GCT_DIV, $$); } | expr_no_commas '%' expr_no_commas { $$ = build_binary_op ($2, $1, $3); /* There's a lookahead token on the tokenlist. */ gct_build_binary(GCT_LAST(Gct_all_nodes)->prev->prev, GCT_MOD, $$); } | expr_no_commas LSHIFT expr_no_commas { $$ = build_binary_op ($2, $1, $3); /* There's a lookahead token on the tokenlist. */ gct_build_binary(GCT_LAST(Gct_all_nodes)->prev->prev, GCT_LSHIFT, $$); } | expr_no_commas RSHIFT expr_no_commas { $$ = build_binary_op ($2, $1, $3); /* There's a lookahead token on the tokenlist. */ gct_build_binary(GCT_LAST(Gct_all_nodes)->prev->prev, GCT_RSHIFT, $$); } | expr_no_commas ARITHCOMPARE expr_no_commas { $$ = build_binary_op ($2, $1, $3); /* There's a lookahead token on the tokenlist. */ gct_build_arithcompare(GCT_LAST(Gct_all_nodes)->prev->prev, $$); } | expr_no_commas EQCOMPARE expr_no_commas { $$ = build_binary_op ($2, $1, $3); /* There's a lookahead token on the tokenlist. */ gct_build_eqcompare(GCT_LAST(Gct_all_nodes)->prev->prev, $$); } | expr_no_commas '&' expr_no_commas { $$ = build_binary_op ($2, $1, $3); /* There's a lookahead token on the tokenlist. */ gct_build_binary(GCT_LAST(Gct_all_nodes)->prev->prev, GCT_BITAND, $$); } | expr_no_commas '|' expr_no_commas { $$ = build_binary_op ($2, $1, $3); /* There's a lookahead token on the tokenlist. */ gct_build_binary(GCT_LAST(Gct_all_nodes)->prev->prev, GCT_BITOR, $$); } | expr_no_commas '^' expr_no_commas { $$ = build_binary_op ($2, $1, $3); /* There's a lookahead token on the tokenlist. */ gct_build_binary(GCT_LAST(Gct_all_nodes)->prev->prev, GCT_BITXOR, $$); } | expr_no_commas ANDAND expr_no_commas { $$ = build_binary_op (TRUTH_ANDIF_EXPR, $1, $3); /* There's a lookahead token on the tokenlist. */ gct_build_binary(GCT_LAST(Gct_all_nodes)->prev->prev, GCT_ANDAND, $$); } | expr_no_commas OROR expr_no_commas { $$ = build_binary_op (TRUTH_ORIF_EXPR, $1, $3); /* There's a lookahead token on the tokenlist. */ gct_build_binary(GCT_LAST(Gct_all_nodes)->prev->prev, GCT_OROR, $$); } | expr_no_commas '?' xexpr ':' expr_no_commas { $$ = build_conditional_expr ($1, $3, $5); /* There's a lookahead token on the tokenlist. */ gct_build_quest(GCT_LAST(Gct_all_nodes)->prev->prev->prev->prev, $$); } | expr_no_commas '=' expr_no_commas { $$ = build_modify_expr ($1, NOP_EXPR, $3); /* There's a lookahead token on the tokenlist. */ gct_build_binary(GCT_LAST(Gct_all_nodes)->prev->prev, GCT_SIMPLE_ASSIGN, $$); } | expr_no_commas ASSIGN expr_no_commas { $$ = build_modify_expr ($1, $2, $3); /* There's a lookahead token on the tokenlist. */ gct_build_nonsimple_assign(GCT_LAST(Gct_all_nodes)->prev->prev, $$); } ; primary: IDENTIFIER { $$ = lastiddecl; if (!$$ || $$ == error_mark_node) { if (yychar == YYEMPTY) yychar = YYLEX; if (yychar == '(') { $$ = implicitly_declare ($1); assemble_external ($$); TREE_USED ($$) = 1; } else if (current_function_decl == 0) { error ("`%s' undeclared, outside of functions", IDENTIFIER_POINTER ($1)); $$ = error_mark_node; } else { if (IDENTIFIER_GLOBAL_VALUE ($1) != error_mark_node || IDENTIFIER_ERROR_LOCUS ($1) != current_function_decl) { error ("`%s' undeclared (first use this function)", IDENTIFIER_POINTER ($1)); if (! undeclared_variable_notice) { error ("(Each undeclared identifier is reported only once"); error ("for each function it appears in.)"); undeclared_variable_notice = 1; } } $$ = error_mark_node; /* Prevent repeated error messages. */ IDENTIFIER_GLOBAL_VALUE ($1) = error_mark_node; IDENTIFIER_ERROR_LOCUS ($1) = current_function_decl; } } else if (! TREE_USED ($$)) { if (TREE_EXTERNAL ($$)) assemble_external ($$); TREE_USED ($$) = 1; } if (TREE_CODE ($$) == CONST_DECL) $$ = DECL_INITIAL ($$); /* Note that constants are NOT replaced with their values. */ gct_build_item(GCT_LAST(Gct_all_nodes), GCT_IDENTIFIER, $$); } | CONSTANT { gct_build_item(GCT_LAST(Gct_all_nodes), GCT_CONSTANT, $$); } | string { gct_build_item(GCT_LAST(Gct_all_nodes)->prev, GCT_CONSTANT, $$); $$ = combine_strings ($1); } | '(' expr ')' { gct_flush_parens(GCT_LAST(Gct_all_nodes)->prev->prev); $$ = $2; } | '(' error ')' { $$ = error_mark_node; } | '(' { if (current_function_decl == 0) { error ("braced-group within expression allowed only inside a function"); YYERROR; } keep_next_level (); $$ = expand_start_stmt_expr (); } compstmt ')' { tree rtl_exp; if (pedantic) warning ("ANSI C forbids braced-groups within expressions"); rtl_exp = expand_end_stmt_expr ($2); $$ = $3; TREE_USED ($$) = 0; /* Since the statements have side effects, consider this volatile. */ TREE_VOLATILE ($$) = 1; TREE_TYPE ($$) = TREE_TYPE (rtl_exp); STMT_BODY ($$) = rtl_exp; gct_build_compound_expr(GCT_LAST(Gct_all_nodes)->prev, $$); } | primary '(' exprlist ')' %prec '.' { gct_node primary, exprlist; $$ = build_function_call ($1, $3); primary = $3 ? GCT_LAST(Gct_all_nodes)->prev->prev->prev : GCT_LAST(Gct_all_nodes)->prev->prev; exprlist = $3 ? primary->next->next : GCT_NULL_NODE; gct_build_function_call(primary, exprlist, $$); } | primary '[' expr ']' %prec '.' { $$ = build_array_ref ($1, $3); gct_build_ref(GCT_LAST(Gct_all_nodes)->prev->prev, GCT_ARRAYREF, $$); } | primary '.' identifier { $$ = build_component_ref ($1, $3); gct_build_ref(GCT_LAST(Gct_all_nodes)->prev, GCT_DOTREF, $$); } | primary POINTSAT identifier { $$ = build_component_ref (build_indirect_ref ($1, "->"), $3); gct_build_ref(GCT_LAST(Gct_all_nodes)->prev, GCT_ARROWREF, $$); } | primary PLUSPLUS { $$ = build_unary_op (POSTINCREMENT_EXPR, $1, 0); gct_build_post(GCT_LAST(Gct_all_nodes), GCT_POSTINCREMENT, $$); } | primary MINUSMINUS { $$ = build_unary_op (POSTDECREMENT_EXPR, $1, 0); gct_build_post(GCT_LAST(Gct_all_nodes), GCT_POSTDECREMENT, $$); } ; /* Produces a STRING_CST with perhaps more STRING_CSTs chained onto it. */ string: STRING | string STRING { $$ = chainon ($1, $2); /* Concatenate the strings. Done here, instead of in expr action, so that I don't have to worry about shift-reduce conflicts - whether the last element on the node list is really a string. */ gct_combine_strings(GCT_LAST(Gct_all_nodes)); } ; xdecls: /* empty */ | decls | decls ELLIPSIS /* * GCT - Ellipsis adapted from GCC 2.1.1. * Should let some GCC 2.X programs be * accepted. */ ; decls: decl | errstmt | decls decl | decl errstmt ; /* records the type and storage class specs to use for processing the declarators that follow. Maintains a stack of outer-level values of current_declspecs, for the sake of parm declarations nested in function declarators. */ setspecs: /* empty */ { $$ = suspend_momentary (); declspec_stack = tree_cons (0, current_declspecs, declspec_stack); current_declspecs = $0; } ; decl: typed_declspecs setspecs initdecls ';' { current_declspecs = TREE_VALUE (declspec_stack); declspec_stack = TREE_CHAIN (declspec_stack); resume_momentary ($2); if (NULL == current_function_decl) { fatal("Decl production outside function."); } gct_build_decl(GCT_LAST(Gct_all_nodes)); } | declmods setspecs notype_initdecls ';' { current_declspecs = TREE_VALUE (declspec_stack); declspec_stack = TREE_CHAIN (declspec_stack); resume_momentary ($2); if (NULL == current_function_decl) { fatal("Decl production outside function."); } gct_build_decl(GCT_LAST(Gct_all_nodes)); } | typed_declspecs ';' { shadow_tag ($1); if (NULL == current_function_decl) { fatal("Decl production outside function."); } gct_build_decl(GCT_LAST(Gct_all_nodes)); } | declmods ';' { warning ("empty declaration"); if (NULL == current_function_decl) { fatal("Decl production outside function."); } gct_build_decl(GCT_LAST(Gct_all_nodes)); } ; /* Declspecs which contain at least one type specifier or typedef name. (Just `const' or `volatile' is not enough.) A typedef'd name following these is taken as a name to be declared. */ typed_declspecs: typespec reserved_declspecs { $$ = tree_cons (NULL_TREE, $1, $2); } | declmods typespec reserved_declspecs { $$ = chainon ($3, tree_cons (NULL_TREE, $2, $1)); } ; reserved_declspecs: /* empty */ { $$ = NULL_TREE; } | reserved_declspecs typespecqual_reserved { $$ = tree_cons (NULL_TREE, $2, $1); } | reserved_declspecs SCSPEC { $$ = tree_cons (NULL_TREE, $2, $1); } ; /* List of just storage classes and type modifiers. A declaration can start with just this, but then it cannot be used to redeclare a typedef-name. */ declmods: TYPE_QUAL { $$ = tree_cons (NULL_TREE, $1, NULL_TREE); } | SCSPEC { $$ = tree_cons (NULL_TREE, $1, NULL_TREE); } | declmods TYPE_QUAL { $$ = tree_cons (NULL_TREE, $2, $1); } | declmods SCSPEC { $$ = tree_cons (NULL_TREE, $2, $1); } ; /* Used instead of declspecs where storage classes are not allowed (that is, for typenames and structure components). Don't accept a typedef-name if anything but a modifier precedes it. */ typed_typespecs: typespec reserved_typespecquals { $$ = tree_cons (NULL_TREE, $1, $2); } | nonempty_type_quals typespec reserved_typespecquals { $$ = chainon ($3, tree_cons (NULL_TREE, $2, $1)); } ; reserved_typespecquals: /* empty */ { $$ = NULL_TREE; } | reserved_typespecquals typespecqual_reserved { $$ = tree_cons (NULL_TREE, $2, $1); } ; /* A typespec (but not a type qualifier). Once we have seen one of these in a declaration, if a typedef name appears then it is being redeclared. */ typespec: TYPESPEC | structsp | TYPENAME | TYPEOF '(' expr ')' { $$ = TREE_TYPE ($3); if (pedantic) warning ("ANSI C forbids `typeof'"); } | TYPEOF '(' typename ')' { $$ = groktypename ($3); if (pedantic) warning ("ANSI C forbids `typeof'"); } ; /* A typespec that is a reserved word, or a type qualifier. */ typespecqual_reserved: TYPESPEC | TYPE_QUAL | structsp ; initdecls: initdcl | initdecls ',' initdcl ; notype_initdecls: notype_initdcl | notype_initdecls ',' initdcl ; maybeasm: /* empty */ { $$ = NULL_TREE; } | ASM '(' string ')' { if (TREE_CHAIN ($3)) $3 = combine_strings ($3); $$ = $3; if (pedantic) warning ("ANSI C forbids use of `asm' keyword"); } ; initdcl: declarator maybeasm maybe_attribute '=' { $$ = start_decl ($1, current_declspecs, 1); } init /* Note how the declaration of the variable is in effect while its init is parsed! */ { finish_decl ($5, $6, $2); } | declarator maybeasm maybe_attribute { tree d = start_decl ($1, current_declspecs, 0); finish_decl (d, NULL_TREE, $2); } ; notype_initdcl: notype_declarator maybeasm maybe_attribute '=' { $$ = start_decl ($1, current_declspecs, 1); } init /* Note how the declaration of the variable is in effect while its init is parsed! */ { finish_decl ($5, $6, $2); } | notype_declarator maybeasm maybe_attribute { tree d = start_decl ($1, current_declspecs, 0); finish_decl (d, NULL_TREE, $2); } ; /* the * rules are dummies to accept the Apollo extended syntax so that the header files compile. */ maybe_attribute: /* empty */ { $$ = NULL_TREE; } | ATTRIBUTE '(' '(' attribute_list ')' ')' { $$ = $4; } ; attribute_list : attrib | attribute_list ',' attrib ; attrib : IDENTIFIER { warning ("`%s' attribute directive ignored", IDENTIFIER_POINTER ($1)); $$ = $1; } | IDENTIFIER '(' CONSTANT ')' { /* if not "aligned(1)", then issue warning */ if (strcmp (IDENTIFIER_POINTER ($1), "aligned") != 0 || TREE_CODE ($3) != INTEGER_CST || TREE_INT_CST_LOW ($3) != 1) warning ("`%s' attribute directive ignored", IDENTIFIER_POINTER ($1)); $$ = $1; } | IDENTIFIER '(' identifiers ')' { warning ("`%s' attribute directive ignored", IDENTIFIER_POINTER ($1)); $$ = $1; } ; init: expr_no_commas | '{' '}' { $$ = build_nt (CONSTRUCTOR, NULL_TREE, NULL_TREE); if (pedantic) warning ("ANSI C forbids empty initializer braces"); } | '{' initlist '}' { $$ = build_nt (CONSTRUCTOR, NULL_TREE, nreverse ($2)); } | '{' initlist ',' '}' { $$ = build_nt (CONSTRUCTOR, NULL_TREE, nreverse ($2)); } | error { $$ = NULL_TREE; } ; /* This chain is built in reverse order, and put in forward order where initlist is used. */ initlist: init { $$ = build_tree_list (NULL_TREE, $1); } | initlist ',' init { $$ = tree_cons (NULL_TREE, $3, $1); } ; /* Any kind of declarator (thus, all declarators allowed after an explicit typespec). */ declarator: after_type_declarator | notype_declarator ; /* A declarator that is allowed only after an explicit typespec. */ after_type_declarator: '(' after_type_declarator ')' { $$ = $2; } | after_type_declarator '(' parmlist_or_identifiers %prec '.' { $$ = build_nt (CALL_EXPR, $1, $3, NULL_TREE); } /* | after_type_declarator '(' error ')' %prec '.' { $$ = build_nt (CALL_EXPR, $1, NULL_TREE, NULL_TREE); poplevel (0, 0, 0); } */ | after_type_declarator '[' expr ']' %prec '.' { $$ = build_nt (ARRAY_REF, $1, $3); } | after_type_declarator '[' ']' %prec '.' { $$ = build_nt (ARRAY_REF, $1, NULL_TREE); } | '*' type_quals after_type_declarator %prec UNARY { $$ = make_pointer_declarator ($2, $3); } | TYPENAME ; /* Kinds of declarator that can appear in a parameter list in addition to notype_declarator. This is like after_type_declarator but does not allow a typedef name in parentheses as an identifier (because it would conflict with a function with that typedef as arg). */ parm_declarator: parm_declarator '(' parmlist_or_identifiers %prec '.' { $$ = build_nt (CALL_EXPR, $1, $3, NULL_TREE); } /* | parm_declarator '(' error ')' %prec '.' { $$ = build_nt (CALL_EXPR, $1, NULL_TREE, NULL_TREE); poplevel (0, 0, 0); } */ | parm_declarator '[' expr ']' %prec '.' { $$ = build_nt (ARRAY_REF, $1, $3); } | parm_declarator '[' ']' %prec '.' { $$ = build_nt (ARRAY_REF, $1, NULL_TREE); } | '*' type_quals parm_declarator %prec UNARY { $$ = make_pointer_declarator ($2, $3); } | TYPENAME ; /* A declarator allowed whether or not there has been an explicit typespec. These cannot redeclare a typedef-name. */ notype_declarator: notype_declarator '(' parmlist_or_identifiers %prec '.' { $$ = build_nt (CALL_EXPR, $1, $3, NULL_TREE); } /* | notype_declarator '(' error ')' %prec '.' { $$ = build_nt (CALL_EXPR, $1, NULL_TREE, NULL_TREE); poplevel (0, 0, 0); } */ | '(' notype_declarator ')' { $$ = $2; } | '*' type_quals notype_declarator %prec UNARY { $$ = make_pointer_declarator ($2, $3); } | notype_declarator '[' expr ']' %prec '.' { $$ = build_nt (ARRAY_REF, $1, $3); } | notype_declarator '[' ']' %prec '.' { $$ = build_nt (ARRAY_REF, $1, NULL_TREE); } | IDENTIFIER { /* GCT */ GCT_LAST(Gct_all_nodes)->type = GCT_IDENTIFIER; } ; structsp: STRUCT identifier '{' { $$ = start_struct (RECORD_TYPE, $2); /* Start scope of tag before parsing components. */ } component_decl_list '}' { $$ = finish_struct ($4, $5); /* Really define the structure. */ } /* In GCT, all structs must be named. We fake this by adding a name. | STRUCT '{' component_decl_list '}' { $$ = finish_struct (start_struct (RECORD_TYPE, NULL_TREE), $3); } */ | STRUCT '{' { gct_node dummy = gct_tempnode("_GCT_DUMMY_"); gct_add_before(&Gct_all_nodes, GCT_LAST(Gct_all_nodes), dummy); $$ = start_struct (RECORD_TYPE, get_identifier(dummy->text)); /* Start scope of tag before parsing components. */ } component_decl_list '}' { $$ = finish_struct ($3, $4); /* Really define the structure. */ } | STRUCT identifier { $$ = xref_tag (RECORD_TYPE, $2); } | UNION identifier '{' { $$ = start_struct (UNION_TYPE, $2); } component_decl_list '}' { $$ = finish_struct ($4, $5); } /* GCT: Unions must be named, so we name them ourselves. | UNION '{' component_decl_list '}' { $$ = finish_struct (start_struct (UNION_TYPE, NULL_TREE), $3); } */ | UNION '{' { gct_node dummy = gct_tempnode("_GCT_DUMMY_"); gct_add_before(&Gct_all_nodes, GCT_LAST(Gct_all_nodes), dummy); $$ = start_struct (UNION_TYPE, get_identifier(dummy->text)); /* Start scope of tag before parsing components. */ } component_decl_list '}' { $$ = finish_struct ($3, $4); } | UNION identifier { $$ = xref_tag (UNION_TYPE, $2); } | ENUM identifier '{' { $3 = suspend_momentary (); $$ = start_enum ($2); } enumlist maybecomma_warn '}' { $$ = finish_enum ($4, nreverse ($5)); resume_momentary ($3); } /* We fudge enum names, just like structs and unions. | ENUM '{' { $2 = suspend_momentary (); $$ = start_enum (NULL_TREE); } enumlist maybecomma_warn '}' { $$ = finish_enum ($3, nreverse ($4)); resume_momentary ($2); } */ | ENUM '{' { gct_node dummy = gct_tempnode("_GCT_DUMMY_"); $2 = suspend_momentary (); gct_add_before(&Gct_all_nodes, GCT_LAST(Gct_all_nodes), dummy); $$ = start_enum (get_identifier(dummy->text)); } enumlist maybecomma_warn '}' { $$ = finish_enum ($3, nreverse ($4)); resume_momentary ($2); } | ENUM identifier { $$ = xref_tag (ENUMERAL_TYPE, $2); } ; maybecomma: /* empty */ | ',' ; maybecomma_warn: /* empty */ | ',' { if (pedantic) warning ("comma at end of enumerator list"); } ; component_decl_list: /* empty */ { $$ = NULL_TREE; } | component_decl_list component_decl ';' { $$ = chainon ($1, $2); } | component_decl_list ';' { if (pedantic) warning ("extra semicolon in struct or union specified"); } ; /* There is a shift-reduce conflict here, because `components' may start with a `typename'. It happens that shifting (the default resolution) does the right thing, because it treats the `typename' as part of a `typed_typespecs'. It is possible that this same technique would allow the distinction between `notype_initdecls' and `initdecls' to be eliminated. But I am being cautious and not trying it. */ component_decl: typed_typespecs setspecs components { $$ = $3; current_declspecs = TREE_VALUE (declspec_stack); declspec_stack = TREE_CHAIN (declspec_stack); resume_momentary ($2); } | nonempty_type_quals setspecs components { $$ = $3; current_declspecs = TREE_VALUE (declspec_stack); declspec_stack = TREE_CHAIN (declspec_stack); resume_momentary ($2); } | error { $$ = NULL_TREE; } ; components: /* empty */ { if (pedantic) warning ("ANSI C forbids member declarations with no members"); $$ = NULL_TREE; } | component_declarator | components ',' component_declarator { $$ = chainon ($1, $3); } ; component_declarator: declarator maybe_attribute { $$ = grokfield (input_filename, lineno, $1, current_declspecs, NULL_TREE); } | declarator ':' expr_no_commas maybe_attribute { $$ = grokfield (input_filename, lineno, $1, current_declspecs, $3); } | ':' expr_no_commas { $$ = grokfield (input_filename, lineno, NULL_TREE, current_declspecs, $2); } ; /* We chain the enumerators in reverse order. They are put in forward order where enumlist is used. (The order used to be significant, but no longer is so. However, we still maintain the order, just to be clean.) */ enumlist: enumerator | enumlist ',' enumerator { $$ = chainon ($3, $1); } ; enumerator: identifier { $$ = build_enumerator ($1, NULL_TREE); } | identifier '=' expr_no_commas { $$ = build_enumerator ($1, $3); } ; typename: typed_typespecs absdcl { $$ = build_tree_list ($1, $2); } | nonempty_type_quals absdcl { $$ = build_tree_list ($1, $2); } ; absdcl: /* an absolute declarator */ /* empty */ { $$ = NULL_TREE; } | absdcl1 ; nonempty_type_quals: TYPE_QUAL { $$ = tree_cons (NULL_TREE, $1, NULL_TREE); } | nonempty_type_quals TYPE_QUAL { $$ = tree_cons (NULL_TREE, $2, $1); } ; type_quals: /* empty */ { $$ = NULL_TREE; } | type_quals TYPE_QUAL { $$ = tree_cons (NULL_TREE, $2, $1); } ; absdcl1: /* a nonempty absolute declarator */ '(' absdcl1 ')' { $$ = $2; } /* `(typedef)1' is `int'. */ | '*' type_quals absdcl1 %prec UNARY { $$ = make_pointer_declarator ($2, $3); } | '*' type_quals %prec UNARY { $$ = make_pointer_declarator ($2, NULL_TREE); } | absdcl1 '(' parmlist %prec '.' { $$ = build_nt (CALL_EXPR, $1, $3, NULL_TREE); } | absdcl1 '[' expr ']' %prec '.' { $$ = build_nt (ARRAY_REF, $1, $3); } | absdcl1 '[' ']' %prec '.' { $$ = build_nt (ARRAY_REF, $1, NULL_TREE); } | '(' parmlist %prec '.' { $$ = build_nt (CALL_EXPR, NULL_TREE, $2, NULL_TREE); } | '[' expr ']' %prec '.' { $$ = build_nt (ARRAY_REF, NULL_TREE, $2); } | '[' ']' %prec '.' { $$ = build_nt (ARRAY_REF, NULL_TREE, NULL_TREE); } ; /* at least one statement, the first of which parses without error. */ /* stmts is used only after decls, so an invalid first statement is actually regarded as an invalid decl and part of the decls. */ /* GCTSTOPPED */ stmts: stmt | stmts stmt | stmts errstmt ; xstmts: /* empty */ | stmts ; errstmt: error ';' ; pushlevel: /* empty */ { pushlevel (0); clear_last_expr (); push_momentary (); expand_start_bindings (0); } ; /* This is the body of a function definition. It causes syntax errors to ignore to the next openbrace. */ compstmt_or_error: compstmt {} | error compstmt ; compstmt: '{' '}' { $$ = 0; gct_build_compound_stmt(GCT_LAST(Gct_all_nodes)); } | '{' pushlevel decls xstmts '}' { expand_end_bindings (getdecls (), 1, 0); /* print_lexical_environment(Gct_textout); */ $$ = poplevel (1, 1, 0); gct_build_compound_stmt(GCT_LAST(Gct_all_nodes)); pop_momentary (); } | '{' pushlevel error '}' { expand_end_bindings (getdecls (), kept_level_p (), 0); $$ = poplevel (kept_level_p (), 0, 0); gct_build_compound_stmt(GCT_LAST(Gct_all_nodes)); pop_momentary (); } | '{' pushlevel stmts '}' { expand_end_bindings (getdecls (), kept_level_p (), 0); /* GCT: We keep all levels of compound statements. $$ = poplevel (kept_level_p (), 0, 0); */ $$ = poplevel (1, 0, 0); gct_build_compound_stmt(GCT_LAST(Gct_all_nodes)); pop_momentary (); } ; simple_if: IF '(' expr ')' { emit_line_note (input_filename, lineno); expand_start_cond (truthvalue_conversion ($3), 0); } stmt ; stmt: compstmt {} | expr ';' { emit_line_note (input_filename, lineno); /* Do default conversion if safe and possibly important, in case within ({...}). */ if ((TREE_CODE (TREE_TYPE ($1)) == ARRAY_TYPE && lvalue_p ($1)) || TREE_CODE (TREE_TYPE ($1)) == FUNCTION_TYPE) $1 = default_conversion ($1); expand_expr_stmt ($1); gct_build_simple_stmt(GCT_LAST(Gct_all_nodes)); clear_momentary (); } | simple_if ELSE { expand_start_else (); } stmt { expand_end_else (); gct_build_if_else(GCT_LAST(Gct_all_nodes)); } | simple_if %prec IF { expand_end_cond (); gct_build_simple_if(GCT_LAST(Gct_all_nodes)->prev); } | WHILE { emit_nop (); emit_line_note (input_filename, lineno); expand_start_loop (1); } '(' expr ')' { emit_line_note (input_filename, lineno); expand_exit_loop_if_false (truthvalue_conversion ($4)); } stmt { expand_end_loop (); gct_build_while_stmt(GCT_LAST(Gct_all_nodes)); } | DO { emit_nop (); emit_line_note (input_filename, lineno); expand_start_loop_continue_elsewhere (1); } stmt WHILE { expand_loop_continue_here (); } '(' expr ')' ';' { emit_line_note (input_filename, lineno); expand_exit_loop_if_false (truthvalue_conversion ($7)); expand_end_loop (); clear_momentary (); gct_build_do_stmt(GCT_LAST(Gct_all_nodes)); } | FOR '(' xexpr ';' { emit_nop (); emit_line_note (input_filename, lineno); if ($3) expand_expr_stmt ($3); expand_start_loop_continue_elsewhere (1); } xexpr ';' { emit_line_note (input_filename, lineno); if ($6) expand_exit_loop_if_false (truthvalue_conversion ($6)); } xexpr ')' /* Don't let the tree nodes for $9 be discarded by clear_momentary during the parsing of the next stmt. */ { push_momentary (); $10 = lineno; } stmt { emit_line_note (input_filename, $10); expand_loop_continue_here (); if ($9) expand_expr_stmt ($9); pop_momentary (); expand_end_loop (); gct_build_for_stmt(GCT_LAST(Gct_all_nodes)); } | SWITCH '(' expr ')' { emit_line_note (input_filename, lineno); c_expand_start_case ($3); /* Don't let the tree nodes for $3 be discarded by clear_momentary during the parsing of the next stmt. */ push_momentary (); } stmt { expand_end_case ($3); pop_momentary (); gct_build_switch(GCT_LAST(Gct_all_nodes)); } | CASE expr ':' { register tree value = fold ($2); register tree label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE); /* build_c_cast puts on a NOP_EXPR to make a non-lvalue. Strip such NOP_EXPRs. */ if (TREE_CODE (value) == NOP_EXPR && TREE_TYPE (value) == TREE_TYPE (TREE_OPERAND (value, 0))) value = TREE_OPERAND (value, 0); if (TREE_CODE (value) != INTEGER_CST && value != error_mark_node) { error ("case label does not reduce to an integer constant"); value = error_mark_node; } else /* Promote char or short to int. */ value = default_conversion (value); if (value != error_mark_node) { int success = pushcase (value, label); if (success == 1) error ("case label not within a switch statement"); else if (success == 2) error ("duplicate case value"); else if (success == 3) warning ("case value out of range"); } } stmt { gct_build_case(GCT_LAST(Gct_all_nodes)); } | DEFAULT ':' { register tree label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE); int success = pushcase (NULL_TREE, label); if (success == 1) error ("default label not within a switch statement"); else if (success == 2) error ("multiple default labels in one switch"); } stmt { gct_build_default(GCT_LAST(Gct_all_nodes)); } | BREAK ';' { emit_line_note (input_filename, lineno); if ( ! expand_exit_something ()) error ("break statement not within loop or switch"); gct_build_break(GCT_LAST(Gct_all_nodes)); } | CONTINUE ';' { emit_line_note (input_filename, lineno); if (! expand_continue_loop ()) error ("continue statement not within a loop"); gct_build_continue(GCT_LAST(Gct_all_nodes)); } | RETURN ';' { emit_line_note (input_filename, lineno); c_expand_return (NULL_TREE); gct_build_return(GCT_LAST(Gct_all_nodes)); } | RETURN expr ';' { emit_line_note (input_filename, lineno); c_expand_return ($2); gct_build_return(GCT_LAST(Gct_all_nodes)); } | ASM maybe_type_qual '(' string ')' ';' { if (TREE_CHAIN ($4)) $4 = combine_strings ($4); emit_line_note (input_filename, lineno); expand_asm ($4); gct_build_asm(GCT_LAST(Gct_all_nodes)); } /* This is the case with just output operands. */ | ASM maybe_type_qual '(' string ':' asm_operands ')' ';' { if (TREE_CHAIN ($4)) $4 = combine_strings ($4); emit_line_note (input_filename, lineno); c_expand_asm_operands ($4, $6, NULL_TREE, NULL_TREE, $2 == ridpointers[(int)RID_VOLATILE], input_filename, lineno); gct_build_asm(GCT_LAST(Gct_all_nodes)); } /* This is the case with input operands as well. */ | ASM maybe_type_qual '(' string ':' asm_operands ':' asm_operands ')' ';' { if (TREE_CHAIN ($4)) $4 = combine_strings ($4); emit_line_note (input_filename, lineno); c_expand_asm_operands ($4, $6, $8, NULL_TREE, $2 == ridpointers[(int)RID_VOLATILE], input_filename, lineno); gct_build_asm(GCT_LAST(Gct_all_nodes)); } /* This is the case with clobbered registers as well. */ | ASM maybe_type_qual '(' string ':' asm_operands ':' asm_operands ':' asm_clobbers ')' ';' { if (TREE_CHAIN ($4)) $4 = combine_strings ($4); emit_line_note (input_filename, lineno); c_expand_asm_operands ($4, $6, $8, $10, $2 == ridpointers[(int)RID_VOLATILE], input_filename, lineno); gct_build_asm(GCT_LAST(Gct_all_nodes)); } | GOTO identifier ';' { tree decl; emit_line_note (input_filename, lineno); decl = lookup_label ($2); TREE_USED (decl) = 1; expand_goto (decl); gct_build_goto(GCT_LAST(Gct_all_nodes)); } | identifier ':' { tree label = define_label (input_filename, lineno, $1); emit_nop (); if (label) expand_label (label); } stmt { gct_build_label(GCT_LAST(Gct_all_nodes)); } | ';' { gct_build_null_stmt(GCT_LAST(Gct_all_nodes)); } ; /* Either a type-qualifier or nothing. First thing in an `asm' statement. */ maybe_type_qual: /* empty */ { if (pedantic) warning ("ANSI C forbids use of `asm' keyword"); emit_line_note (input_filename, lineno); } | TYPE_QUAL { if (pedantic) warning ("ANSI C forbids use of `asm' keyword"); emit_line_note (input_filename, lineno); } ; xexpr: /* empty */ { $$ = NULL_TREE; } | expr ; /* These are the operands other than the first string and colon in asm ("addextend %2,%1": "=dm" (x), "0" (y), "g" (*x)) */ asm_operands: /* empty */ { $$ = NULL_TREE; } | nonnull_asm_operands ; nonnull_asm_operands: asm_operand | nonnull_asm_operands ',' asm_operand { $$ = chainon ($1, $3); } ; asm_operand: STRING '(' expr ')' { $$ = build_tree_list ($1, $3); } ; asm_clobbers: string { $$ = tree_cons (NULL_TREE, combine_strings ($1), NULL_TREE); } | asm_clobbers ',' string { $$ = tree_cons (NULL_TREE, combine_strings ($3), $1); } ; /* This is what appears inside the parens in a function declarator. Its value is a list of ..._TYPE nodes. */ parmlist: { pushlevel (0); declare_parm_level (); } parmlist_1 { $$ = $2; parmlist_tags_warning (); poplevel (0, 0, 0); } ; /* This is referred to where either a parmlist or an identifier list is ok. Its value is a list of ..._TYPE nodes or a list of identifiers. */ parmlist_or_identifiers: { pushlevel (0); declare_parm_level (); } parmlist_or_identifiers_1 { $$ = $2; parmlist_tags_warning (); poplevel (0, 0, 0); } ; parmlist_or_identifiers_1: parmlist_2 ')' | identifiers ')' { $$ = tree_cons (NULL_TREE, NULL_TREE, $1); } | error ')' { $$ = tree_cons (NULL_TREE, NULL_TREE, NULL_TREE); } ; parmlist_1: parmlist_2 ')' | error ')' { $$ = tree_cons (NULL_TREE, NULL_TREE, NULL_TREE); } ; /* This is what appears inside the parens in a function declarator. Is value is represented in the format that grokdeclarator expects. */ parmlist_2: /* empty */ { $$ = get_parm_info (0); } /* * GCT: Ellipsis adapted from gcc 2.1.1 - should let some GCC 2.X * programs be accepted by GCT. */ | ELLIPSIS { $$ = get_parm_info (0); if (pedantic) warning ("ANSI C requires a named argument before `...'"); } | parms { $$ = get_parm_info (1); } | parms ',' ELLIPSIS { $$ = get_parm_info (0); } ; parms: parm { push_parm_decl ($1); } | parms ',' parm { push_parm_decl ($3); } ; /* A single parameter declaration or parameter type name, as found in a parmlist. */ parm: typed_declspecs parm_declarator { $$ = build_tree_list ($1, $2) ; } | typed_declspecs notype_declarator { $$ = build_tree_list ($1, $2) ; } | typed_declspecs absdcl { $$ = build_tree_list ($1, $2); } | declmods notype_declarator { $$ = build_tree_list ($1, $2) ; } | declmods absdcl { $$ = build_tree_list ($1, $2); } ; /* A nonempty list of identifiers. */ identifiers: IDENTIFIER { $$ = build_tree_list (NULL_TREE, $1); } | identifiers ',' IDENTIFIER { $$ = chainon ($1, build_tree_list (NULL_TREE, $3)); } ; %% /* Return something to represent absolute declarators containing a *. TARGET is the absolute declarator that the * contains. TYPE_QUALS is a list of modifiers such as const or volatile to apply to the pointer type, represented as identifiers. We return an INDIRECT_REF whose "contents" are TARGET and whose type is the modifier list. */ static tree make_pointer_declarator (type_quals, target) tree type_quals, target; { return build (INDIRECT_REF, type_quals, target); } /* Given a chain of STRING_CST nodes, concatenate them into one STRING_CST and give it a suitable array-of-chars data type. */ static tree combine_strings (strings) tree strings; { register tree value, t; register int length = 1; int wide_length = 0; int wide_flag = 0; if (TREE_CHAIN (strings)) { /* More than one in the chain, so concatenate. */ register char *p, *q; /* Don't include the \0 at the end of each substring, except for the last one. Count wide strings and ordinary strings separately. */ for (t = strings; t; t = TREE_CHAIN (t)) { if (TREE_TYPE (t) == int_array_type_node) { wide_length += (TREE_STRING_LENGTH (t) - 1); wide_flag = 1; } else length += (TREE_STRING_LENGTH (t) - 1); } /* If anything is wide, the non-wides will be converted, which makes them take more space. */ if (wide_flag) length = length * UNITS_PER_WORD + wide_length; p = (char *) savealloc (length); /* Copy the individual strings into the new combined string. If the combined string is wide, convert the chars to ints for any individual strings that are not wide. */ q = p; for (t = strings; t; t = TREE_CHAIN (t)) { int len = TREE_STRING_LENGTH (t) - 1; if ((TREE_TYPE (t) == int_array_type_node) == wide_flag) { bcopy (TREE_STRING_POINTER (t), q, len); q += len; } else { int i; for (i = 0; i < len; i++) ((int *) q)[i] = TREE_STRING_POINTER (t)[i]; q += len * UNITS_PER_WORD; } } *q = 0; value = make_node (STRING_CST); TREE_STRING_POINTER (value) = p; TREE_STRING_LENGTH (value) = length; TREE_LITERAL (value) = 1; } else { value = strings; length = TREE_STRING_LENGTH (value); if (TREE_TYPE (value) == int_array_type_node) wide_flag = 1; } /* Create the array type for the string constant. -Wwrite-strings says make the string constant an array of const char so that copying it to a non-const pointer will get a warning. */ if (warn_write_strings) { tree elements = build_type_variant (wide_flag ? integer_type_node : char_type_node, 1, 0); TREE_TYPE (value) = build_array_type (elements, build_index_type (build_int_2 (length - 1, 0))); } else TREE_TYPE (value) = build_array_type (wide_flag ? integer_type_node : char_type_node, build_index_type (build_int_2 (length - 1, 0))); TREE_LITERAL (value) = 1; TREE_STATIC (value) = 1; return value; } int lineno; /* current line number in file being read */ FILE *finput; /* input file. Normally a pipe from the preprocessor. */ /* GCT: We wish to count character position on line as well as lineno. */ /* * Charno is the number of the character in the current file. (This will * be convenient if we ever use emacs to mark characters. It will be * inconvenient if line-oriented tools are used. Take your pick.) */ int charno = 0; int Gct_initialized = 0; /* The name of the temporary file we put rewritten output into. */ char *Gct_tempname = "GCT-TEMP"; /* Normally overwritten, except when debugging. */ /* check_newline calls yylex to pull in tokens. Such calls shouldn't add to the parse tree. Neither should the initial call to check_newline made in toplev.c. */ int Gct_ignore_tokens = 0; #define gct_getc(filep) (charno++, getc(filep)) #define gct_ungetc(c, filep) (charno--, ungetc((c), (filep))) /* Note: because getc is a macro, can't use #define getc gct_getc hack to rename uses of getc below. Have to do it by hand. */ /* Functions for use outside this file */ int gct_fgetc(filep) FILE *filep; { return gct_getc(filep); } int gct_fungetc(c, filep) int c; FILE *filep; { return gct_ungetc(c, filep); } /* * Initialize GCT. The Gct_textout file is passed in as -o argument. * * The instrumented file contains a header that * - marks it as instrumented * - includes gct-ps-defs.h and gct-defs.h * - declares the local pointers into Gct_table and Gct_group_table * * This routine requires that main_input_filename be known. That means * it can't be called until the source file has been opened and the * filename discovered. * * This function also calls other initialization routines for other * modules. See file STATE for more about what initialization is needed * and why. */ gct_init() { extern char *Gct_full_defs_file; extern char *Gct_full_per_session_file; extern char *Gct_full_map_file_name; assert(!Gct_initialized); Gct_initialized = 1; init_instrumentation(); /* Retrieve per-session instrumentation */ gct_initialize_groups(); /* Set up utility tables, vars. */ init_mapfile(Gct_full_map_file_name); fprintf(Gct_textout, "/* __GCT_INSTRUMENTATION_TAG */\n"); fprintf(Gct_textout, "#define GCT_TABLE_POINTER_FOR_THIS_FILE Gct_per_file_table_pointer_%d\n", Gct_num_files); fprintf(Gct_textout, "#define GCT_RACE_TABLE_POINTER_FOR_THIS_FILE Gct_per_file_race_table_pointer_%d\n", Gct_num_files); fprintf(Gct_textout, "#include \"%s\"\n", Gct_full_per_session_file); fprintf(Gct_textout, "#include \"%s\"\n", Gct_full_defs_file); fprintf(Gct_textout, "extern GCT_CONDITION_TYPE *Gct_per_file_table_pointer_%d;\n", Gct_num_files); fprintf(Gct_textout, "extern long *Gct_per_file_race_table_pointer_%d;\n", Gct_num_files); fprintf(Gct_textout, "#line 1\n"); } /* * Finish processing of the instrumented file. This depends on the style * of instrumentation: * * In the new style of instrumentation (where GCT calls the compiler), * this routine does nothing. The driver program (gcc) is responsible * for the next step. * * In the old style of instrumentation, the temporary file must be placed * in the source file's directory. Normally, it replaces the original * source. If OPT_REPLACE is turned off, the instrumented file has the * name of the original file, prefixed with 'T'. * * There's more to finishing a GCT invocation than just mucking with the * instrumented file. Handling of the instrumentation state is done by * finish_instrumentation(). See file STATE for more. */ gct_finish() { extern int errorcount; if (Gct_initialized) { Gct_initialized = 0; gct_write_list(Gct_all_nodes); /* GCT */ gct_recursive_free_node(Gct_all_nodes); fputc('\n', Gct_textout); fflush(Gct_textout); /* About to copy contents - make sure all in file */ /* Probably should close the file, but I'm letting original GCC code do it. */ finish_instrumentation(); if (OFF == gct_option_value(OPT_PRODUCE_OBJECT)) { /* * Replace the original source with the temp file. If * OPT_PRODUCE_OBJECT, the compiler driver will immediately * compile the temp file and the source file is untouched. */ char *system_buffer; /* Sloppy size calculation. */ system_buffer = (char *)xmalloc(1000+strlen(Gct_tempname)+2*strlen(main_input_filename)); if (errorcount > 0) { /* Would rather use a "note" function, but there isn't one. Using warning would be misleading. */ error("The original file is unchanged."); } else if (OFF == gct_option_value(OPT_REPLACE)) { /* Of course, on SysV, this will run into filename limits. But this is not for general user's use. */ sprintf(system_buffer, "cp %s T%s", Gct_tempname, main_input_filename); if (0 != system(system_buffer)) { error("Couldn't create 'T' file."); fatal("Failed: %s\n", system_buffer); } } else { extern char *Gct_full_restore_log_file; char *main_directory; char *main_file; char *full_backup; /* Full name of backup directory. */ struct stat backup_statbuf; /* Stat of backup directory */ struct stat orig_statbuf; /* Stat of original file. */ /* Find current modes of file. */ if (-1==stat(main_input_filename, &orig_statbuf)) { fatal ("Can't find current modes for %s.", main_input_filename); } split_file(main_input_filename, &main_directory, &main_file); full_backup = (char *)xmalloc(strlen(main_directory)+1+strlen(GCT_BACKUP_DIR)+1); sprintf(full_backup, "%s/%s", main_directory, GCT_BACKUP_DIR); /* Make the backup directory if needed. */ if (-1==stat(full_backup, &backup_statbuf)) { if (-1==mkdir (full_backup,00777)) fatal ("Can't create backup directory %s.", full_backup); } /* Backup the file. */ sprintf (system_buffer,"/bin/rm -f %s/%s \n", full_backup, main_file); /* printf (system_buffer); */ if (0!=system (system_buffer)) fatal ("Already an unremovable backup file for %s", main_input_filename); sprintf (system_buffer,"/bin/mv %s %s \n", main_input_filename, full_backup); if (0!=system (system_buffer)) fatal ("Can't backup source file %s", main_input_filename); /* * Make the replaced file. Note: I don't know what's portable for * the mode bits, so I'll only preserve the bottom part, which * has been other-group-owner rwx since time immemorial. * * Copy is used so that the .c file is newer than the .o file. * I might delete the backup copy now, but in case something * goes wrong, having a copy of the original file in the backup * directory might save the day. */ sprintf(system_buffer, "echo \"cd `pwd`;\" 'cp %s/%s %s/%s; chmod %o %s/%s' >> %s\n", full_backup, main_file, main_directory, main_file, orig_statbuf.st_mode & 0777, main_directory, main_file, Gct_full_restore_log_file); /* printf(system_buffer); */ if (0!=system (system_buffer)) fatal ("Can't update %s", Gct_full_restore_log_file); /* Replace the file. */ sprintf(system_buffer, "cp %s %s", Gct_tempname, main_input_filename); if (0 != system(system_buffer)) { error("Couldn't replace original source with instrumented source."); fatal("Failed: %s\n", system_buffer); } free(main_directory); free(main_file); } free(system_buffer); } } } /* End GCT */ /* lexical analyzer */ static int maxtoken; /* Current nominal length of token buffer. */ static char *token_buffer; /* Pointer to token buffer. Actual allocated length is maxtoken + 2. */ static int max_wide; /* Current nominal length of wide_buffer. */ static int *wide_buffer; /* Pointer to wide-string buffer. Actual allocated length is max_wide + 1. */ /* Nonzero if end-of-file has been seen on input. */ static int end_of_file; /* Data type that represents the GNU C reserved words. */ struct resword { char *name; short token; enum rid rid; }; #define MIN_WORD_LENGTH 2 /* minimum size for C keyword */ #define MAX_WORD_LENGTH 13 /* maximum size for C keyword */ #define MIN_HASH_VALUE 7 /* range of the hash keys values */ #define MAX_HASH_VALUE 91 /* for the perfect hash generator */ #define NORID RID_UNUSED /* This function performs the minimum-perfect hash mapping from input string to reswords table index. It only looks at the first and last characters in the string, thus assuring the O(1) lookup time (this keeps our constant down to an insignificant amount!). Compiling the following 2 functions as inline removes all overhead of the function calls. */ #ifdef __GNUC__ __inline #endif static int hash (str, len) register char *str; register int len; { /* This table is used to build the hash table index that recognizes reserved words in 0(1) steps. It is larger than strictly necessary, but I'm trading off the space for the time-saving luxury of avoiding subtraction of an offset. All those ``91's'' (actually just a short-hand for MAX_HASH_VALUE #defined above) are used to speed up the search when the string found on the input stream doesn't have a first or last character that is part of the set of alphabetic characters that comprise the first or last characters in C reserved words. */ static int hash_table[] = { 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 1, 91, 2, 1, 32, 7, 5, 18, 20, 1, 17, 91, 1, 18, 1, 28, 1, 23, 91, 12, 20, 1, 41, 7, 15, 91, 91, 10, 91, 91, 91, 91, 91, }; register int hval = len ; switch (hval) { default: case 3: hval += hash_table[str[2]]; case 2: case 1: return hval + hash_table[str[0]] + hash_table[str[len - 1]]; } } /* This routine attempts to match the string found in the reswords table with the one from the input stream. If all the relevant details match then an actual strcmp comparison is performed and the address of correct struct resword entry is returned. Otherwise, a NULL pointer is returned. */ #ifdef __GNUC__ __inline #endif struct resword * is_reserved_word (str, len) register char *str; register int len; { /* This is the hash table of keywords. The order of keywords has been chosen for perfect hashing. Therefore, this table cannot be updated by hand. Use the program ``gperf,'' available with the latest libg++ distribution, to generate an updated table. A file called c-parse.gperf, distributed with GNU C, contains the keyword file. */ static struct resword reswords[] = { { "", }, { "", }, { "", }, { "", }, { "", }, { "", }, { "", }, {"asm", ASM, NORID }, {"auto", SCSPEC, RID_AUTO }, {"__asm", ASM, NORID }, {"do", DO, NORID }, {"__asm__", ASM, NORID }, {"break", BREAK, NORID }, {"__typeof__", TYPEOF, NORID }, { "", }, {"__alignof__", ALIGNOF, NORID }, { "", }, {"__attribute__", ATTRIBUTE, NORID }, { "", }, {"__attribute", ATTRIBUTE, NORID }, { "", }, {"__volatile__", TYPE_QUAL, RID_VOLATILE }, {"int", TYPESPEC, RID_INT }, {"__volatile", TYPE_QUAL, RID_VOLATILE }, { "", }, {"float", TYPESPEC, RID_FLOAT }, {"goto", GOTO, NORID }, {"short", TYPESPEC, RID_SHORT }, {"__typeof", TYPEOF, NORID }, {"__inline__", SCSPEC, RID_INLINE }, {"__alignof", ALIGNOF, NORID }, {"__inline", SCSPEC, RID_INLINE }, {"__signed__", TYPESPEC, RID_SIGNED }, {"default", DEFAULT, NORID }, {"else", ELSE, NORID }, {"void", TYPESPEC, RID_VOID }, {"__signed", TYPESPEC, RID_SIGNED }, {"if", IF, NORID }, {"volatile", TYPE_QUAL, RID_VOLATILE }, {"struct", STRUCT, NORID }, {"extern", SCSPEC, RID_EXTERN }, {"__const", TYPE_QUAL, RID_CONST }, {"while", WHILE, NORID }, {"__const__", TYPE_QUAL, RID_CONST }, {"switch", SWITCH, NORID }, {"for", FOR, NORID }, {"inline", SCSPEC, RID_INLINE }, {"return", RETURN, NORID }, {"typeof", TYPEOF, NORID }, {"typedef", SCSPEC, RID_TYPEDEF }, {"char", TYPESPEC, RID_CHAR }, {"enum", ENUM, NORID }, {"register", SCSPEC, RID_REGISTER }, {"signed", TYPESPEC, RID_SIGNED }, {"sizeof", SIZEOF, NORID }, { "", }, { "", }, { "", }, { "", }, {"double", TYPESPEC, RID_DOUBLE }, {"static", SCSPEC, RID_STATIC }, {"case", CASE, NORID }, { "", }, { "", }, { "", }, { "", }, {"const", TYPE_QUAL, RID_CONST }, { "", }, { "", }, { "", }, {"long", TYPESPEC, RID_LONG }, { "", }, { "", }, {"continue", CONTINUE, NORID }, { "", }, { "", }, {"unsigned", TYPESPEC, RID_UNSIGNED }, { "", }, { "", }, { "", }, { "", }, { "", }, { "", }, { "", }, { "", }, { "", }, { "", }, { "", }, { "", }, { "", }, { "", }, {"union", UNION, NORID }, }; if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH) { register int key = hash (str, len); if (key <= MAX_HASH_VALUE) { register char *s = reswords[key].name; if (*s == *str && !strcmp (str + 1, s + 1)) return &reswords[key]; } } return 0; } /* The elements of `ridpointers' are identifier nodes for the reserved type names and storage classes. It is indexed by a RID_... value. */ tree ridpointers[(int) RID_MAX]; int check_newline (); void init_lex () { /* Start it at 0, because check_newline is called at the very beginning and will increment it to 1. */ lineno = 0; maxtoken = 40; token_buffer = (char *) xmalloc (maxtoken + 2); max_wide = 40; /* GCT: allocation was in terms of bytes, not ints */ wide_buffer = (int *) xmalloc (sizeof(int) * (max_wide + 1)); ridpointers[(int) RID_INT] = get_identifier ("int"); ridpointers[(int) RID_CHAR] = get_identifier ("char"); ridpointers[(int) RID_VOID] = get_identifier ("void"); ridpointers[(int) RID_FLOAT] = get_identifier ("float"); ridpointers[(int) RID_DOUBLE] = get_identifier ("double"); ridpointers[(int) RID_SHORT] = get_identifier ("short"); ridpointers[(int) RID_LONG] = get_identifier ("long"); ridpointers[(int) RID_UNSIGNED] = get_identifier ("unsigned"); ridpointers[(int) RID_SIGNED] = get_identifier ("signed"); ridpointers[(int) RID_INLINE] = get_identifier ("inline"); ridpointers[(int) RID_CONST] = get_identifier ("const"); ridpointers[(int) RID_VOLATILE] = get_identifier ("volatile"); ridpointers[(int) RID_AUTO] = get_identifier ("auto"); ridpointers[(int) RID_STATIC] = get_identifier ("static"); ridpointers[(int) RID_EXTERN] = get_identifier ("extern"); ridpointers[(int) RID_TYPEDEF] = get_identifier ("typedef"); ridpointers[(int) RID_REGISTER] = get_identifier ("register"); } static void reinit_parse_for_function () { } /* If C is not whitespace, return C. Otherwise skip whitespace and return first nonwhite char read. */ static int skip_white_space (c) register int c; { #if 0 register int inside; #endif for (;;) { switch (c) { /* Don't recognize comments in cc1: all comments are removed by cpp, and cpp output can include / and * consecutively as operators. */ #if 0 case '/': c = gct_getc (finput); if (c != '*') { gct_ungetc (c, finput); return '/'; } c = gct_getc (finput); inside = 1; while (inside) { if (c == '*') { while (c == '*') c = gct_getc (finput); if (c == '/') { inside = 0; c = gct_getc (finput); } } else if (c == '\n') { lineno++; c = gct_getc (finput); } else if (c == EOF) { error ("unterminated comment"); break; } else c = gct_getc (finput); } break; #endif case '\n': c = check_newline (); break; case ' ': case '\t': case '\f': case '\r': case '\v': case '\b': c = gct_getc (finput); break; case '\\': c = gct_getc (finput); if (c == '\n') lineno++; else error ("stray '\\' in program"); c = gct_getc (finput); break; default: return (c); } } } /* Make the token buffer longer, preserving the data in it. P should point to just beyond the last valid character in the old buffer. The value we return is a pointer to the new buffer at a place corresponding to P. */ static char * extend_token_buffer (p) char *p; { int offset = p - token_buffer; maxtoken = maxtoken * 2 + 10; token_buffer = (char *) xrealloc (token_buffer, maxtoken + 2); return token_buffer + offset; } /* At the beginning of a line, increment the line number and process any #-directive on this line. If the line is a #-directive, read the entire line and return a newline. Otherwise, return the line's first non-whitespace character. */ int check_newline () { register int c; register int token; lineno++; /* Read first nonwhite char on the line. */ c = gct_getc (finput); while (c == ' ' || c == '\t') c = gct_getc (finput); if (c != '#') { /* If not #, return it so caller will use it. */ return c; } /* Read first nonwhite char after the `#'. */ c = gct_getc (finput); while (c == ' ' || c == '\t') c = gct_getc (finput); /* If a letter follows, then if the word here is `line', skip it and ignore it; otherwise, ignore the line, with an error if the word isn't `pragma'. */ if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) { if (c == 'p') { if (gct_getc (finput) == 'r' && gct_getc (finput) == 'a' && gct_getc (finput) == 'g' && gct_getc (finput) == 'm' && gct_getc (finput) == 'a' && ((c = gct_getc (finput)) == ' ' || c == '\t' || c == '\n')) { /* GCT */ gct_make_end_note(gct_build_pragma(finput), Gct_all_nodes); c = '\n'; goto skipline; } } else if (c == 'l') { if (gct_getc (finput) == 'i' && gct_getc (finput) == 'n' && gct_getc (finput) == 'e' && ((c = gct_getc (finput)) == ' ' || c == '\t')) goto linenum; } else if (c == 'i') { if (gct_getc (finput) == 'd' && gct_getc (finput) == 'e' && gct_getc (finput) == 'n' && gct_getc (finput) == 't' && ((c = gct_getc (finput)) == ' ' || c == '\t')) { extern FILE *asm_out_file; if (pedantic) error ("ANSI C does not allow #ident"); /* Here we have just seen `#ident '. A string constant should follow. */ while (c == ' ' || c == '\t') c = gct_getc (finput); /* If no argument, ignore the line. */ if (c == '\n') return c; gct_ungetc (c, finput); token = yylex (); if (token != STRING || TREE_CODE (yylval.ttype) != STRING_CST) { error ("invalid #ident"); goto skipline; } #ifdef ASM_OUTPUT_IDENT ASM_OUTPUT_IDENT (asm_out_file, TREE_STRING_POINTER (yylval.ttype)); #endif /* Skip the rest of this line. */ goto skipline; } } error ("undefined or invalid # directive"); goto skipline; } linenum: /* Here we have either `#line' or `# '. In either case, it should be a line number; a digit should follow. */ while (c == ' ' || c == '\t') c = gct_getc (finput); /* If the # is the only nonwhite char on the line, just ignore it. Check the new newline. */ if (c == '\n') return c; /* Something follows the #; read a token. */ gct_ungetc (c, finput); token = yylex (); if (token == CONSTANT && TREE_CODE (yylval.ttype) == INTEGER_CST) { int old_lineno = lineno; /* subtract one, because it is the following line that gets the specified number */ int l = TREE_INT_CST_LOW (yylval.ttype) - 1; /* Is this the last nonwhite stuff on the line? */ c = gct_getc (finput); while (c == ' ' || c == '\t') c = gct_getc (finput); if (c == '\n') { /* No more: store the line number and check following line. */ lineno = l; return c; } gct_ungetc (c, finput); /* More follows: it must be a string constant (filename). */ token = yylex (); if (token != STRING || TREE_CODE (yylval.ttype) != STRING_CST) { error ("invalid #line"); goto skipline; } input_filename = (char *) permalloc (TREE_STRING_LENGTH (yylval.ttype) + 1); strcpy (input_filename, TREE_STRING_POINTER (yylval.ttype)); lineno = l; if (main_input_filename == 0) { /* GCT */ extern char* Gct_test_dir; main_input_filename = input_filename; /* Old Code */ gct_set_file_context(main_input_filename, Gct_test_dir); gct_init(); } /* GCT */ gct_make_end_note(gct_build_line_note(input_filename, lineno+1), Gct_all_nodes); /* Is this the last nonwhite stuff on the line? */ c = gct_getc (finput); while (c == ' ' || c == '\t') c = gct_getc (finput); if (c == '\n') return c; gct_ungetc (c, finput); token = yylex (); /* `1' after file name means entering new file. `2' after file name means just left a file. */ if (token == CONSTANT && TREE_CODE (yylval.ttype) == INTEGER_CST) { if (TREE_INT_CST_LOW (yylval.ttype) == 1) { struct file_stack *p = (struct file_stack *) xmalloc (sizeof (struct file_stack)); input_file_stack->line = old_lineno; p->next = input_file_stack; p->name = input_filename; input_file_stack = p; input_file_stack_tick++; } else if (input_file_stack->next) { struct file_stack *p = input_file_stack; input_file_stack = p->next; free (p); input_file_stack_tick++; } else error ("#-lines for entering and leaving files don't match"); } } else error ("invalid #-line"); /* skip the rest of this line. */ skipline: if (c == '\n') return c; while ((c = gct_getc (finput)) != EOF && c != '\n'); return c; } #define isalnum(char) ((char >= 'a' && char <= 'z') || (char >= 'A' && char <= 'Z') || (char >= '0' && char <= '9')) #define isdigit(char) (char >= '0' && char <= '9') #define ENDFILE -1 /* token that represents end-of-file */ /* GCT */ #define isprint(char) ((char >= ' ') && (char <= '~')) static int readescape () { register int c = gct_getc (finput); register int count, code; int firstdig; switch (c) { case 'x': code = 0; count = 0; while (1) { c = gct_getc (finput); if (!(c >= 'a' && c <= 'f') && !(c >= 'A' && c <= 'F') && !(c >= '0' && c <= '9')) { gct_ungetc (c, finput); break; } code *= 16; if (c >= 'a' && c <= 'f') code += c - 'a' + 10; if (c >= 'A' && c <= 'F') code += c - 'A' + 10; if (c >= '0' && c <= '9') code += c - '0'; if (count == 0) firstdig = code; count++; } if (count == 0) error ("\\x used with no following hex digits"); else if ((count - 1) * 4 >= TYPE_PRECISION (integer_type_node) || ((1 << (TYPE_PRECISION (integer_type_node) - (count - 1) * 4)) <= firstdig)) warning ("hex escape out of range"); return code; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': code = 0; count = 0; while ((c <= '7') && (c >= '0') && (count++ < 3)) { code = (code * 8) + (c - '0'); c = gct_getc (finput); } gct_ungetc (c, finput); return code; case '\\': case '\'': case '"': return c; case '\n': lineno++; return -1; case 'n': return TARGET_NEWLINE; case 't': return TARGET_TAB; case 'r': return TARGET_CR; case 'f': return TARGET_FF; case 'b': return TARGET_BS; case 'a': return TARGET_BELL; case 'v': return TARGET_VT; case 'E': return 033; case '?': /* `\(', etc, are used at beginning of line to avoid confusing Emacs. */ case '(': case '{': case '[': return c; } if (c >= 040 && c <= 0177) warning ("unknown escape sequence `\\%c'", c); else warning ("unknown escape sequence: `\\' followed by char code 0x%x", c); return c; } void yyerror (string) char *string; { char buf[200]; strcpy (buf, string); /* We can't print string and character constants well because the token_buffer contains the result of processing escapes. */ if (end_of_file) strcat (buf, " at end of input"); else if (token_buffer[0] == 0) strcat (buf, " at null character"); else if (token_buffer[0] == '"') strcat (buf, " before string constant"); else if (token_buffer[0] == '\'') strcat (buf, " before character constant"); else if (token_buffer[0] < 040 || token_buffer[0] >= 0177) sprintf (buf + strlen (buf), " before character 0%o", token_buffer[0]); else strcat (buf, " before `%s'"); error (buf, token_buffer); } static int nextchar = -1; /* * This hashes a node. I include the node type in the hash to avoid * pathological equalities like the old "a =- 5 vs. a = -5". Note that * the node type in this case is always GCT_OTHER. That doesn't matter * because the hashing is order-dependent. That is, a hash of * * GCT-OTHER a GCT-OTHER = - GCT-OTHER 5 * * will be different from * * GCT-OTHER a GCT-OTHER = GCT-OTHER - 5 */ static void gct_hash_node(node) gct_node node; { int i; GCT_HASH(Gct_function_hashval, (int) node->type); if (node->text) { for (i = 0 ; i < node->textlen ; i++) GCT_HASH(Gct_function_hashval, (int) (node->text[i])); } else { warning("Node passed to gct_hash_node has no text.\n"); } } /* * GCT Note: EVERY token that's read has a TEXT field attached. This is * redundant -- for many tokens, TEXT is redundant with the TYPE field * (consider WHILE). However, this saves having to write special case * code here in yylex and also in the printing code. */ static int yylex () { register int c; register char *p; register int value; int wide_flag = 0; int starting_char; /* GCT: First character of token */ int gct_nulls_in_string; /* GCT: How many nulls in current string. */ /* NOTE: Nulls in character constants are */ /* handled differently. */ Gct_ignore_tokens++; /* GCT: Ignore on recursive calls. */ yylval.code = LAST_AND_UNUSED_TREE_CODE; /* GCT: Don't retain previous value into tests at end of routine. */ if (nextchar >= 0) c = nextchar, nextchar = -1; else c = gct_getc (finput); /* Effectively do c = skip_white_space (c) but do it faster in the usual cases. */ while (1) switch (c) { case ' ': case '\t': case '\f': case '\r': case '\v': case '\b': c = gct_getc (finput); break; case '\n': case '/': case '\\': c = skip_white_space (c); default: goto found_nonwhite; } found_nonwhite: starting_char = charno; /* GCT */ gct_nulls_in_string = 0; /* GCT */ token_buffer[0] = c; token_buffer[1] = 0; /* yylloc.first_line = lineno; */ switch (c) { case EOF: end_of_file = 1; token_buffer[0] = 0; value = ENDFILE; break; case '$': if (dollars_in_ident) goto letter; return '$'; /* GCT: Causes error -- no need to save node. */ case 'L': /* Capital L may start a wide-string or wide-character constant. */ { register int c = gct_getc (finput); if (c == '\'') { error("GCT does not accept wide character constants (L'c').\n"); wide_flag = 1; goto char_constant; } if (c == '"') { error("GCT does not accept wide strings (L\"string\").\n"); wide_flag = 1; goto string_constant; } gct_ungetc (c, finput); } case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G': case 'H': case 'I': case 'J': case 'K': case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T': case 'U': case 'V': case 'W': case 'X': case 'Y': case 'Z': case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g': case 'h': case 'i': case 'j': case 'k': case 'l': case 'm': case 'n': case 'o': case 'p': case 'q': case 'r': case 's': case 't': case 'u': case 'v': case 'w': case 'x': case 'y': case 'z': case '_': letter: p = token_buffer; while (isalnum (c) || c == '_' || c == '$') { if (p >= token_buffer + maxtoken) p = extend_token_buffer (p); if (c == '$' && ! dollars_in_ident) break; *p++ = c; c = gct_getc (finput); } *p = 0; nextchar = c; value = IDENTIFIER; yylval.itype = 0; /* Try to recognize a keyword. Uses minimum-perfect hash function */ { register struct resword *ptr; if (ptr = is_reserved_word (token_buffer, p - token_buffer)) { if (ptr->rid) yylval.ttype = ridpointers[(int) ptr->rid]; if ((! flag_no_asm /* -fno-asm means don't recognize the non-ANSI keywords. */ || ((int) ptr->token != ASM && (int) ptr->token != TYPEOF && ptr->rid != RID_INLINE) /* Recognize __asm and __inline despite -fno-asm. */ || token_buffer[0] == '_') /* -ftraditional means don't recognize nontraditional keywords typeof, const, volatile, signed or inline. */ && (! flag_traditional || ((int) ptr->token != TYPE_QUAL && (int) ptr->token != TYPEOF && ptr->rid != RID_SIGNED && ptr->rid != RID_INLINE) /* Recognize __inline, etc. despite -ftraditional. */ || token_buffer[0] == '_')) value = (int) ptr->token; } } /* If we did not find a keyword, look for an identifier (or a typename). */ if (value == IDENTIFIER) { yylval.ttype = get_identifier (token_buffer); lastiddecl = lookup_name (yylval.ttype); if (lastiddecl != 0 && TREE_CODE (lastiddecl) == TYPE_DECL) value = TYPENAME; } break; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': case '.': { int base = 10; int count = 0; int largest_digit = 0; int numdigits = 0; /* for multi-precision arithmetic, we store only 8 live bits in each short, giving us 64 bits of reliable precision */ short shorts[8]; int overflow = 0; enum anon1 { NOT_FLOAT, AFTER_POINT, TOO_MANY_POINTS} floatflag = NOT_FLOAT; for (count = 0; count < 8; count++) shorts[count] = 0; p = token_buffer; *p++ = c; if (c == '0') { *p++ = (c = gct_getc (finput)); if ((c == 'x') || (c == 'X')) { base = 16; *p++ = (c = gct_getc (finput)); } else { base = 8; numdigits++; } } /* Read all the digits-and-decimal-points. */ while (c == '.' || (isalnum (c) && (c != 'l') && (c != 'L') && (c != 'u') && (c != 'U') && (floatflag == NOT_FLOAT || ((c != 'f') && (c != 'F'))))) { if (c == '.') { if (base == 16) error ("floating constant may not be in radix 16"); if (floatflag == AFTER_POINT) { error ("malformed floating constant"); floatflag = TOO_MANY_POINTS; } else floatflag = AFTER_POINT; base = 10; *p++ = c = gct_getc (finput); /* Accept '.' as the start of a floating-point number only when it is followed by a digit. Otherwise, unread the following non-digit and use the '.' as a structural token. */ if (p == token_buffer + 2 && !isdigit (c)) { if (c == '.') { c = gct_getc (finput); if (c == '.') { *p++ = c; *p = 0; /* return ELLIPSIS; */ /* GCT: Send to DONE so that gct_node is built. */ value = ELLIPSIS; goto done; } error ("parse error at `..'"); } gct_ungetc (c, finput); token_buffer[1] = 0; value = '.'; goto done; } } else { /* It is not a decimal point. It should be a digit (perhaps a hex digit). */ if (isdigit (c)) { c = c - '0'; } else if (base <= 10) { if ((c&~040) == 'E') { base = 10; floatflag = AFTER_POINT; break; /* start of exponent */ } error ("nondigits in number and not hexadecimal"); c = 0; } else if (c >= 'a') { c = c - 'a' + 10; } else { c = c - 'A' + 10; } if (c >= largest_digit) largest_digit = c; numdigits++; for (count = 0; count < 8; count++) { shorts[count] *= base; if (count) { shorts[count] += (shorts[count-1] >> 8); shorts[count-1] &= (1<<8)-1; } else shorts[0] += c; } if (shorts[7] >= 1<<8 || shorts[7] < - (1 << 8)) overflow = TRUE; if (p >= token_buffer + maxtoken - 3) p = extend_token_buffer (p); *p++ = (c = gct_getc (finput)); } } if (numdigits == 0) error ("numeric constant with no digits"); if (largest_digit >= base) error ("numeric constant contains digits beyond the radix"); /* Remove terminating char from the token buffer and delimit the string */ *--p = 0; if (floatflag != NOT_FLOAT) { tree type = double_type_node; char f_seen = 0; char l_seen = 0; REAL_VALUE_TYPE value; /* Read explicit exponent if any, and put it in tokenbuf. */ if ((c == 'e') || (c == 'E')) { if (p >= token_buffer + maxtoken - 3) p = extend_token_buffer (p); *p++ = c; c = gct_getc (finput); if ((c == '+') || (c == '-')) { *p++ = c; c = gct_getc (finput); } if (! isdigit (c)) error ("floating constant exponent has no digits"); while (isdigit (c)) { if (p >= token_buffer + maxtoken - 3) p = extend_token_buffer (p); *p++ = c; c = gct_getc (finput); } } *p = 0; errno = 0; value = REAL_VALUE_ATOF (token_buffer); #ifdef ERANGE if (errno == ERANGE && !flag_traditional) { char *p1 = token_buffer; /* Check for "0.0" and variants; Sunos 4 spuriously returns ERANGE for them. */ while (*p1 == '0') p1++; if (*p1 == '.') { p1++; while (*p1 == '0') p1++; } if (*p1 == 'e' || *p1 == 'E') { /* with significand==0, ignore the exponent */ p1++; while (*p1 != 0) p1++; } /* ERANGE is also reported for underflow, so test the value to distinguish overflow from that. */ if (*p1 != 0 && (value > 1.0 || value < 1.0)) warning ("floating point number exceeds range of `double'"); } #endif /* Read the suffixes to choose a data type. */ while (1) { if (c == 'f' || c == 'F') { float floater; if (f_seen) error ("two `f's in floating constant"); f_seen = 1; type = float_type_node; floater = value; value = floater; } else if (c == 'l' || c == 'L') { if (l_seen) error ("two `l's in floating constant"); l_seen = 1; type = long_double_type_node; } else { if (isalnum (c)) { error ("garbage at end of number"); while (isalnum (c)) { if (p >= token_buffer + maxtoken - 3) p = extend_token_buffer (p); *p++ = c; c = gct_getc (finput); } } break; } if (p >= token_buffer + maxtoken - 3) p = extend_token_buffer (p); *p++ = c; c = gct_getc (finput); } /* Create a node with determined type and value. */ yylval.ttype = build_real (type, value); gct_ungetc (c, finput); *p = 0; } else { tree type; int spec_unsigned = 0; int spec_long = 0; int spec_long_long = 0; while (1) { if (c == 'u' || c == 'U') { if (spec_unsigned) error ("two `u's in integer constant"); spec_unsigned = 1; } else if (c == 'l' || c == 'L') { if (spec_long) { if (spec_long_long) error ("three `l's in integer constant"); else if (pedantic) warning ("ANSI C forbids long long integer constants"); spec_long_long = 1; } spec_long = 1; } else { if (isalnum (c)) { error ("garbage at end of number"); while (isalnum (c)) { if (p >= token_buffer + maxtoken - 3) p = extend_token_buffer (p); *p++ = c; c = gct_getc (finput); } } break; } if (p >= token_buffer + maxtoken - 3) p = extend_token_buffer (p); *p++ = c; c = gct_getc (finput); } gct_ungetc (c, finput); *p = 0; if ((overflow || shorts[7] || shorts[6] || shorts[5] || shorts[4]) && !spec_long_long) warning ("integer constant out of range"); /* If it won't fit in a signed long long, make it unsigned. We can't distinguish based on the tree node because any integer constant fits any long long type. */ if (shorts[7] >= (1<<8)) spec_unsigned = 1; /* This is simplified by the fact that our constant is always positive. */ yylval.ttype = (build_int_2 ((shorts[3]<<24) + (shorts[2]<<16) + (shorts[1]<<8) + shorts[0], (spec_long_long ? (shorts[7]<<24) + (shorts[6]<<16) + (shorts[5]<<8) + shorts[4] : 0))); if (!spec_long && !spec_unsigned && int_fits_type_p (yylval.ttype, integer_type_node)) type = integer_type_node; else if (!spec_long && base != 10 && int_fits_type_p (yylval.ttype, unsigned_type_node)) type = unsigned_type_node; else if (!spec_unsigned && !spec_long_long && int_fits_type_p (yylval.ttype, long_integer_type_node)) type = long_integer_type_node; else if (! spec_long_long && int_fits_type_p (yylval.ttype, long_unsigned_type_node)) type = long_unsigned_type_node; else if (! spec_unsigned && int_fits_type_p (yylval.ttype, long_long_integer_type_node)) type = long_long_integer_type_node; else if (int_fits_type_p (yylval.ttype, long_long_unsigned_type_node)) type = long_long_unsigned_type_node; else { type = long_long_integer_type_node; warning ("integer constant out of range"); } TREE_TYPE (yylval.ttype) = type; } value = CONSTANT; break; } case '\'': char_constant: { register int result = 0; register num_chars = 0; int width = TYPE_PRECISION (char_type_node); int max_chars; if (wide_flag) width = TYPE_PRECISION (integer_type_node); max_chars = TYPE_PRECISION (integer_type_node) / width; while (1) { tryagain: c = gct_getc (finput); if (c == '\'' || c == EOF) break; if (c == '\\') { c = readescape (); if (c < 0) goto tryagain; if (width < HOST_BITS_PER_INT && (unsigned) c >= (1 << width)) warning ("escape sequence out of range for character"); } else if (c == '\n') { if (pedantic) warning ("ANSI C forbids newline in character constant"); warning("GCT: Newline in character constant means line number off by one."); lineno++; } num_chars++; if (num_chars > maxtoken - 4) extend_token_buffer (token_buffer); token_buffer[num_chars] = c; /* Merge character into result; ignore excess chars. */ if (num_chars < max_chars + 1) { if (width < HOST_BITS_PER_INT) result = (result << width) | (c & ((1 << width) - 1)); else result = c; } } token_buffer[num_chars + 1] = '\''; token_buffer[num_chars + 2] = 0; if (c != '\'') error ("malformatted character constant"); else if (num_chars == 0) error ("empty character constant"); else if (num_chars > max_chars) { num_chars = max_chars; error ("character constant too long"); } else if (num_chars != 1 && ! flag_traditional) warning ("multi-character character constant"); /* If char type is signed, sign-extend the constant. */ if (! wide_flag) { int num_bits = num_chars * width; if (TREE_UNSIGNED (char_type_node) || ((result >> (num_bits - 1)) & 1) == 0) yylval.ttype = build_int_2 (result & ((unsigned) ~0 >> (HOST_BITS_PER_INT - num_bits)), 0); else yylval.ttype = build_int_2 (result | ~((unsigned) ~0 >> (HOST_BITS_PER_INT - num_bits)), -1); } else yylval.ttype = build_int_2 (result, 0); TREE_TYPE (yylval.ttype) = integer_type_node; /* * GCT: put full character constant in token_buffer. This is a * problem, in that the value returned here and stored forever * more is a character constant -- something that's clumsy to * manipulate. A possible solution is to let the first character * (') be a CHARACTER tag and have the second character be the * actual value. The printer would print it correctly. * * Note that we can't use the node's TYPE field for the tag, * because the lexer must not set that field to anything other * than GCT_OTHER. The parser assigns all other values, and * there is code that depends on this (scanning for GCT_OTHER to * find an unparsed statement). It might be better to just burn * a bit to denote "parsed" and let the lexer set the type in * some cases. * * Note that the current handling of characters avoids the * "null in string" problems that strings have. Change this code, * and you'll have to deal with that problem. (character tests * include null characters.) */ if (maxtoken < 10) /* This will doubtless never happen. */ extend_token_buffer(token_buffer); if ('\\' == result) { sprintf(token_buffer, "'\\\\'", result); } else if ('\'' == result) { sprintf(token_buffer, "'\\''", result); } else if ('\t' == result) { strcpy(token_buffer, "'\\t'"); } else if ('\n' == result) { strcpy(token_buffer, "'\\n'"); } else if (isprint(result)) { sprintf(token_buffer, "'%c'", result); } else { sprintf(token_buffer, "'\\%o'", result); } value = CONSTANT; break; } case '"': string_constant: { int *widep; c = gct_getc (finput); p = token_buffer + 1; if (wide_flag) widep = wide_buffer; while (c != '"' && c >= 0) { if (c == '\\') { c = readescape (); if ('\0' == c) /* GCT */ gct_nulls_in_string++; if (c < 0) goto skipnewline; if (!wide_flag && c >= (1 << TYPE_PRECISION (char_type_node))) warning ("escape sequence out of range for character"); } else if (c == '\n') { if (pedantic) warning ("ANSI C forbids newline in string constant"); warning("GCT: Newline in string means line number off by one."); lineno++; } /* Store the char in C into the appropriate buffer. */ if (wide_flag) { if (widep == wide_buffer + max_wide) { int n = widep - wide_buffer; max_wide *= 2; wide_buffer = (int *) xrealloc (wide_buffer, max_wide + 1); widep = wide_buffer + n; } *widep++ = c; } else { if (p == token_buffer + maxtoken) p = extend_token_buffer (p); *p++ = c; } skipnewline: c = gct_getc (finput); } /* We have read the entire constant. Construct a STRING_CST for the result. */ if (wide_flag) { /* If this is a L"..." wide-string, make a vector of the ints in wide_buffer. */ *widep = 0; /* We have not implemented the case where `int' on the target and on the execution machine differ in size. */ if (TYPE_PRECISION (integer_type_node) != sizeof (int) * BITS_PER_UNIT) abort (); yylval.ttype = build_string ((widep - wide_buffer + 1) * sizeof (int), wide_buffer); TREE_TYPE (yylval.ttype) = int_array_type_node; } else { *p = 0; yylval.ttype = build_string (p - token_buffer, token_buffer + 1); TREE_TYPE (yylval.ttype) = char_array_type_node; } *p++ = '"'; *p = 0; value = STRING; break; } case '+': case '-': case '&': case '|': case '<': case '>': case '*': case '/': case '%': case '^': case '!': case '=': { register int c1; combine: switch (c) { case '+': yylval.code = PLUS_EXPR; break; case '-': yylval.code = MINUS_EXPR; break; case '&': yylval.code = BIT_AND_EXPR; break; case '|': yylval.code = BIT_IOR_EXPR; break; case '*': yylval.code = MULT_EXPR; break; case '/': yylval.code = TRUNC_DIV_EXPR; break; case '%': yylval.code = TRUNC_MOD_EXPR; break; case '^': yylval.code = BIT_XOR_EXPR; break; case LSHIFT: yylval.code = LSHIFT_EXPR; break; case RSHIFT: yylval.code = RSHIFT_EXPR; break; case '<': yylval.code = LT_EXPR; break; case '>': yylval.code = GT_EXPR; break; } token_buffer[1] = c1 = gct_getc (finput); token_buffer[2] = 0; if (c1 == '=') { switch (c) { case '<': value = ARITHCOMPARE; yylval.code = LE_EXPR; goto done; case '>': value = ARITHCOMPARE; yylval.code = GE_EXPR; goto done; case '!': value = EQCOMPARE; yylval.code = NE_EXPR; goto done; case '=': value = EQCOMPARE; yylval.code = EQ_EXPR; goto done; } value = ASSIGN; goto done; } else if (c == c1) switch (c) { case '+': value = PLUSPLUS; goto done; case '-': value = MINUSMINUS; goto done; case '&': value = ANDAND; goto done; case '|': value = OROR; goto done; case '<': c = LSHIFT; goto combine; case '>': c = RSHIFT; goto combine; } else if ((c == '-') && (c1 == '>')) { value = POINTSAT; goto done; } gct_ungetc (c1, finput); token_buffer[1] = 0; if ((c == '<') || (c == '>')) value = ARITHCOMPARE; else value = c; goto done; } case 0: /* Don't make yyparse think this is eof. */ value = 1; break; default: value = c; } done: /* yylloc.last_line = lineno; */ Gct_ignore_tokens--; /* GCT */ if (0 == Gct_ignore_tokens) { if (! end_of_file) { /* Have to handle shift-type operators specially, since token_buffer doesn't contain all the characters. */ char * string_to_save = token_buffer; gct_node new_node; if (LSHIFT_EXPR == yylval.code && ASSIGN == value) string_to_save = "<<="; else if (LSHIFT_EXPR == yylval.code) string_to_save = "<<"; else if (RSHIFT_EXPR == yylval.code && ASSIGN == value) string_to_save = ">>="; else if (RSHIFT_EXPR == yylval.code) string_to_save = ">>"; new_node = gct_node_from_string(string_to_save, gct_nulls_in_string, input_filename, lineno, starting_char); gct_hash_node(new_node); gct_add_last(&Gct_all_nodes, new_node); } } return value; }