Polaris: parser.cc Source File

parser.cc Go to the documentation of this file. /* * A n t l r T r a n s l a t i o n H e a d e r * * Terence Parr, Will Cohen, and Hank Dietz: 1989-1994 * Purdue University Electrical Engineering * With AHPCRC, University of Minnesota * ANTLR Version 1.23 */ #include <stdio.h> #define ANTLR_VERSION 123 /// We want to provide our own error-printing routine, so define this symbol: /// #define USER_ZZSYN /// removed--maybe add later -- s.a.w. #include "parser_charbuf.h" #include "ParserContext.h" #include "../Boolean.h" #include "../utilities/string_util.h" class Expression; class Symbol; class Symtab; /// ExpressionList is simply a List<Expression>, but we will use it /// instead of List<Expression> in order to keep from having to /// drag in List.h and Expression.h into all the header files. class ExpressionList; //_ class DistributeExpr; #define zzEOF_TOKEN 1 #define zzSET_SIZE 16 #include "antlr.h" #include "tokens.h" #include "dlgdef.h" #include "mode.h" ANTLR_INFO #include "parser_prepass.h" #include "parser_util.h" #include "parser.h" #include <ctype.h> #include <stream.h> #include <strstream.h> #include "../Boolean.h" #include "../p-assert.h" #include "Assertion.h" #include "Assertion.all.h" #include "Directive.h" #include "../Expression/Expression.h" #include "../Expression/BinaryExpr.h" #include "../Expression/LogicalConstExpr.h" #include "../Expression/RealConstExpr.h" #include "../Expression/IntConstExpr.h" #include "../Expression/StringConstExpr.h" #include "../ProgramUnit.h" #include "../Statement/Statement.h" #include "../Statement/BlockEntryStmt.h" #include "../Statement/BlockExitStmt.h" #include "../Symbol/Symbol.h" #include "../Symtab.h" #include "TreeBuilder.h" //_ #include "../Expression/DistributeExpr.h" class ExpressionList : public List<Expression> { /// ... nothing to do }; Expression *make_afi_node(Expression *arg1, Expression *arg2); void parse_error(const char *); /// Aborb 'to_append_and_delete' into 'source', and delete /// 'to_append_and_delete' when done. static void list_absorb(List<Expression> &source, List<Expression> *to_append_and_delete) { if (to_append_and_delete != 0) { while (to_append_and_delete->first_ref() != 0) { source.ins_last(to_append_and_delete->grab( *to_append_and_delete->first_ref())); } /// ... Go ahead and delete the secondary list p_assert(to_append_and_delete->entries() == 0, "Internal Error"); delete to_append_and_delete; } } /// Make sure that all expressions in the list are of the given types. If /// one is found that is not of the given type, it is deleted, and an error /// message is given through parse_error(err_message) static void validate_expr_list_types(ExpressionList &list, const char *err_message, OP_TYPE op_type1, OP_TYPE op_type2 = (OP_TYPE)(-1)) { for (Mutator<Expression> iter = list; iter.valid(); ++iter) { if (iter.current().op() == op_type1 || iter.current().op() == op_type2) { /// ... We're okay -- nothing to do } else { /// ... Error discovered ostrstream s; s << "Expected " << err_message << " but found: " << iter.current() << ends; char *str = s.str(); parse_error(str); delete str; /// ... Remove the one that was an error iter.del(); } } } Boolean is_array_symbol(Expression &expr) { if ( expr.op() == ID_OP ) { Symbol &sym = expr.symbol(); if ( sym.sym_class() == VARIABLE_CLASS && sym.is_array() ) return True; } return False; } Boolean is_scalar_var(Expression &expr) { if (expr.op() == ID_OP) { Symbol &sym = expr.symbol(); if (sym.sym_class() == VARIABLE_CLASS && !sym.is_array()) return True; } return False; } /// Make sure that all expressions in the list are either /// scalar variables (if 'can_be_scalar_var') or array elements /// (if 'can_be_array_elem'), or entire array reference (if /// 'can_be_entire_array), or all, as given. static void validate_expr_list_types(ExpressionList &list, const char *err_message, Boolean can_be_scalar_var, Boolean can_be_array_elem, Boolean can_be_entire_array) { p_assert(can_be_scalar_var || can_be_array_elem, "Arguments error"); for (Mutator<Expression> iter = list; iter.valid(); ++iter) { if ( can_be_scalar_var && is_scalar_var( iter.current() ) ) { continue; /// ... Okay -- try next expression } else if ( can_be_array_elem && iter.current().op() == ARRAY_REF_OP ) { continue; /// ... Okay -- try next expression } else if ( can_be_entire_array && is_array_symbol( iter.current() ) ) { continue; /// ... Okay -- try next expression } else { /// Error discovered ostrstream s; s << "Expected " << err_message << " but found: " << iter.current() << ends; char *str = s.str(); parse_error(str); delete str; /// ... Remove the one that was an error iter.del(); } } } /// Given the following format of Fortran expression: /// arg1 ( arg2 ) /* (where arg2 should be a comma-expr) */ /// return an appropriate Expression for this expression. /// Depending on the type of arg1, this may take one of several forms: /// -- intrinsic function call /// -- function call /// -- substring expression /// -- array ref Expression * make_afi_node(Expression *arg1, Expression *arg2) { if (arg1 == 0 || arg2 == 0) { /// ... must be syntax error -- return NULL if (arg1) delete arg1; if (arg2) delete arg2; return 0; } /// ... arg1 MUST be an ID_OP, or else of type character, /// ... else there is an error if (arg1->op() != ID_OP) { if (arg1->type().data_type() == CHARACTER_TYPE) { /// ... We have a substring expression return substring(arg1, arg2); } else { /// ... Error ostrstream oss; oss << "function call/array ref syntax " << "for invalid object type: `" << *arg1 << "'" << ends; char *s = oss.str(); parse_error(s); delete [] s; return 0; } } Symbol &sym = arg1->symbol(); switch(sym.sym_class()) { default: { String msg = (String)"function call/array ref syntax " "for non-function and non-variable `" + sym.name_ref() + "'"; parse_error(msg); } break; case FUNCTION_CLASS: /// ... Here we are guaranteed success, but there are /// ... two possibilities--intrinsic call or function call if (sym.intrinsic() == IS_INTRINSIC) return intrinsic_call(arg1, arg2); else return function_call(arg1, arg2); break; case VARIABLE_CLASS: { if (!sym.is_array()) { String msg = (String)"variable `" + sym.name_ref() + "' is not an array"; parse_error(msg); return 0; } /// ... We need more exact checks here--ie. number of dimensions, etc. return array_reference(id(sym), arg2); } break; } } static void force_parallel(ParserContext &context, Symbol *scalar, const char *directive_name) { Statement *s_do = &context.s_next; AssertParallel *as_par = (AssertParallel *) assertion_of_type( s_do->assertions(), AS_PARALLEL ); if (as_par == 0) { as_par = new AssertParallel; if (s_do->stmt_class() == DO_STMT) { if (scalar == 0) as_par->arg_list_guarded().ins_first( s_do->index().clone() ); else as_par->arg_list_guarded().ins_first( id(*scalar) ); } s_do->assertions().ins_first( as_par ); } } //_ Append a new shared scalar or array to list after verifying its correctness. //_ static void append_shared_data_objects(Expression* e_id, DistributeExpr* e_dist, ExpressionList* list) { if (e_dist) { /// ... e_dist is DISTRIBUTE_OP only with distributions /// ... and e_id must be a shared array id expression to /// ... be added to e_dist with its dimension. p_assert((e_id && e_id->op() == ID_OP), "Illegal shared array name"); e_dist->symbol(e_id->symbol()); /// ... Now, array name and dimension is added. p_assert( e_dist->is_well_defined(), "Distribution is not well defined" ); /// ... Distribution must match the symbol declaration. delete e_id; list->ins_last(e_dist); } else { /// ... e_id must be a shared scalar id expression p_assert((e_id && is_scalar_var(*e_id)), "Illegal shared scalar name"); list->ins_last(e_id); } } void parse_comment_or_directive(const String &dir, ProgramUnit &pgm, Statement *s_prev, Statement *s_next) { // zzerr = fbzzerr; /// ... Take over lexical error function /// ... -- removed for now -- s.a.w. if (dir.index_case( "CSRD$" ) == 0 || dir.index_case( "C$DIR" ) == 0 || dir.index_case( "C$DOACROSS" ) == 0 /// ... _ || dir.index_case( "CDIR$" ) == 0) { char *prepass = parser_prepass(dir); if (!prepass) { parse_error("Lexical error"); return; } /// ... Create the context ParserContext context(pgm, s_prev, s_next); /// ... Note that we send in 'dir' directly as the 'line' /// ... parameter, since it is used by comments, and we do /// ... not want the prepass to change anything inside a /// ... comment which is not a directive. ANTLRs(parser_comment_or_directive(context, dir), prepass); delete [] prepass; } else { AssertComment *a = new AssertComment; s_next->assertions().ins_last( a ); const char *p = dir; /// ... Skip past the start of comment character. p_assert( (*p == 'C' || *p == 'c' || *p == '@' || *p == '!' || *p == '*' || *p == '%' ), "Internal Error" ); p += 1; StringElem *s_elem = new StringElem( p ); a->string_arg_list_guarded().ins_last( s_elem ); } } //////////////////////////////////////////////////////////// void parse_error(const char *s) { cout << "*** PARSE ERROR: " << s << endl; } void parse_error(const String &s) { parse_error((const char *)s); } /// If assertion_ref != 0 and e != 0, then 'e' is inserted into /// assertion_ref's arg_list. Otherwise, 'e' is garbage /// collected (deleted) static void insert_or_delete(Assertion *assertion_ref, Expression *e) { if (! assertion_ref) delete e; else { if ( e ) assertion_ref->arg_list_guarded().ins_last( e ); } } void #ifdef __STDC__ parser_comment_or_directive( ParserContext &context, const char *line ) #else parser_comment_or_directive(context,line) ParserContext &context; const char *line ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { if ( (LA(1)==CSRD_TOKEN) ) { zzmatch(CSRD_TOKEN); zzCONSUME; parser_csrd_directive( context ); zzmode( START ); } else { if ( (LA(1)==CONVEX_TOKEN) ) { zzmatch(CONVEX_TOKEN); zzCONSUME; parser_convex_directive( context ); zzmode( START ); } else { if ( (LA(1)==SGI_TOKEN) ) { zzmatch(SGI_TOKEN); zzCONSUME; parser_sgi_directive( context ); zzmode( START ); } else { if ( (LA(1)==COMMENT_START) ) { zzmatch(COMMENT_START); zzCONSUME; parser_comment( context, line ); zzmode( START ); } else { if ( ( LA(1)==CRAY_TOKEN) ) { zzmatch(CRAY_TOKEN); zzCONSUME; parser_cray_directive( context ); zzmode( START ); } else {zzFAIL(1,zzerr1,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;} } } } } zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "Fortran comment or directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd1, 0x1); } } void #ifdef __STDC__ parser_comment( ParserContext &context, const char *line ) #else parser_comment(context,line) ParserContext &context; const char *line ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { zzmatch(1); /// ... We have a comment for sure, but the syntax of /// ... Fortran vs. modern token creation makes it /// ... difficult to grab the text of a comment line // using normal parsing/lexing techniques, /// ... so we will cheat and grab it from our /// ... parameter 'line' { AssertComment *a = new AssertComment; context.s_next.assertions().ins_last( a ); const char *p = line; /// ... Skip past the start of comment character. p_assert( (*p == 'C' || *p == 'c' || *p == '@' || *p == '!' || *p == '*' || *p == '%' ), "Internal Error" ); p += 1; StringElem *s_elem = new StringElem( p ); a->string_arg_list_guarded().ins_last( s_elem ); } zzCONSUME; zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "Fortran comment", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd1, 0x2); } } Expression * #ifdef __STDC__ parser_expression( Symtab &symtab ) #else parser_expression(symtab) Symtab &symtab ; #endif { Expression * _retv; zzRULE; zzBLOCK(zztasp1); zzMake0; { _retv = 0; _retv = parser_expr100( symtab ); zzEXIT(zztasp1); return _retv; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "Fortran expression", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd1, 0x4); return _retv; } } Expression * #ifdef __STDC__ parser_expr100( Symtab &symtab ) #else parser_expr100(symtab) Symtab &symtab ; #endif { Expression * _retv; zzRULE; zzBLOCK(zztasp1); zzMake0; { Expression *arg; OP_TYPE op; TreeBuilder *tree = new TreeBuilder; _retv = 0; arg = parser_expr120( symtab ); tree->left_arg(arg); { zzBLOCK(zztasp2); zzMake0; { while ( (LA(1)==29 || LA(1)==30) ) { { zzBLOCK(zztasp3); zzMake0; { if ( (LA(1)==29) ) { zzmatch(29); op = EQV_OP; zzCONSUME; } else { if ( (LA(1)==30) ) { zzmatch(30); op = NEQV_OP; zzCONSUME; } else {zzFAIL(1,zzerr2,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;} } zzEXIT(zztasp3); } } arg = parser_expr120( symtab ); tree->add_arg(op, ASSOCIATIVE_OP, arg); zzLOOP(zztasp2); } zzEXIT(zztasp2); } } _retv = tree->grab(); delete tree; zzEXIT(zztasp1); return _retv; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "Fortran .EQV./.NEQV. expression", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd1, 0x8); return _retv; } } Expression * #ifdef __STDC__ parser_expr120( Symtab &symtab ) #else parser_expr120(symtab) Symtab &symtab ; #endif { Expression * _retv; zzRULE; zzBLOCK(zztasp1); zzMake0; { Expression *arg; TreeBuilder *tree = new TreeBuilder; _retv = 0; arg = parser_expr130( symtab ); tree->left_arg(arg); { zzBLOCK(zztasp2); zzMake0; { while ( ( LA(1)==31) ) { zzmatch(31); zzCONSUME; arg = parser_expr130( symtab ); tree->add_arg(OR_OP, ASSOCIATIVE_OP, arg); zzLOOP(zztasp2); } zzEXIT(zztasp2); } } _retv = tree->grab(); delete tree; zzEXIT(zztasp1); return _retv; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "Fortran .OR. expression", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd1, 0x10); return _retv; } } Expression * #ifdef __STDC__ parser_expr130( Symtab &symtab ) #else parser_expr130(symtab) Symtab &symtab ; #endif { Expression * _retv; zzRULE; zzBLOCK(zztasp1); zzMake0; { Expression *arg; TreeBuilder *tree = new TreeBuilder; _retv = 0; arg = parser_expr140( symtab ); tree->left_arg(arg); { zzBLOCK(zztasp2); zzMake0; { while ( (LA(1)==32) ) { zzmatch(32); zzCONSUME; arg = parser_expr140( symtab ); tree->add_arg(AND_OP, ASSOCIATIVE_OP, arg); zzLOOP(zztasp2); } zzEXIT(zztasp2); } } _retv = tree->grab(); delete tree; zzEXIT(zztasp1); return _retv; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "Fortran .AND. expression", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd1, 0x20); return _retv; } } Expression * #ifdef __STDC__ parser_expr140( Symtab &symtab ) #else parser_expr140(symtab) Symtab &symtab ; #endif { Expression * _retv; zzRULE; zzBLOCK(zztasp1); zzMake0; { Expression *arg; _retv = 0; if ( (LA(1)==33) ) { { zzBLOCK(zztasp2); zzMake0; { zzmatch(33); zzCONSUME; arg = parser_expr140( symtab ); _retv = not(arg); zzEXIT(zztasp2); } } } else { if ( (LA(1)==F_NUM_CONST || LA(1)==APOST_CHAR_CST || LA(1)==QUOTE_CHAR_CST || LA(1)==41 || LA(1)==42 || LA(1)==46 || LA(1)==50 || LA(1)==51 || LA(1)==FORTRAN_ID) ) { _retv = parser_expr150( symtab ); } else {zzFAIL(1,zzerr3,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;} } zzEXIT(zztasp1); return _retv; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "Fortran .NOT. expression", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd1, 0x40); return _retv; } } Expression * #ifdef __STDC__ parser_expr150( Symtab &symtab ) #else parser_expr150(symtab) Symtab &symtab ; #endif { Expression * _retv; zzRULE; zzBLOCK(zztasp1); zzMake0; { Expression *arg; OP_TYPE op; Boolean rel_op_found = False; _retv = 0; _retv = parser_expr160( symtab ); { zzBLOCK(zztasp2); zzMake0; { while ( (LA(1)==34 || LA(1)==35 || LA(1)==36 || LA(1)==37 || LA(1)==38 || LA(1)==39) ) { { zzBLOCK(zztasp3); zzMake0; { if ( (LA(1)==34) ) { zzmatch(34); op = LT_OP; zzCONSUME; } else { if ( (LA(1)==35) ) { zzmatch(35); op = LE_OP; zzCONSUME; } else { if ( ( LA(1)==36) ) { zzmatch(36); op = EQ_OP; zzCONSUME; } else { if ( (LA(1)==37) ) { zzmatch(37); op = NE_OP; zzCONSUME; } else { if ( (LA(1)==38) ) { zzmatch(38); op = GT_OP; zzCONSUME; } else { if ( (LA(1)==39) ) { zzmatch(39); op = GE_OP; zzCONSUME; } else {zzFAIL(1,zzerr4,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;} } } } } } zzEXIT(zztasp3); } } arg = parser_expr160( symtab ); if (arg) { if (rel_op_found) { parse_error("Fortran relative operators " "(e.g. .EQ.) are not associative"); delete arg; /// ... Ignore invalid argument } else { _retv = new BinaryExpr(op, expr_type(op, _retv->type(), arg->type()), _retv, arg); rel_op_found = True; } } zzLOOP(zztasp2); } zzEXIT(zztasp2); } } zzEXIT(zztasp1); return _retv; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "Fortran relational expression", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd1, 0x80); return _retv; } } Expression * #ifdef __STDC__ parser_expr160( Symtab &symtab ) #else parser_expr160(symtab) Symtab &symtab ; #endif { Expression * _retv; zzRULE; zzBLOCK(zztasp1); zzMake0; { Expression *arg; TreeBuilder *tree = new TreeBuilder; _retv = 0; arg = parser_arithmetic_expr( symtab ); tree->left_arg(arg); { zzBLOCK(zztasp2); zzMake0; { while ( (LA(1)==40) ) { zzmatch(40); zzCONSUME; arg = parser_arithmetic_expr( symtab ); tree->add_arg(CONCAT_OP, ASSOCIATIVE_OP, arg); zzLOOP(zztasp2); } zzEXIT(zztasp2); } } _retv = tree->grab(); delete tree; zzEXIT(zztasp1); return _retv; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "Fortran concatentation (`/// ... ') expression", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd2, 0x1); return _retv; } } Expression * #ifdef __STDC__ parser_arithmetic_expr( Symtab &symtab ) #else parser_arithmetic_expr(symtab) Symtab &symtab ; #endif { Expression * _retv; zzRULE; zzBLOCK(zztasp1); zzMake0; { Expression *arg; OP_TYPE op; TreeBuilder *tree = new TreeBuilder; ASSOC_BOOL assoc; _retv = 0; if ( ( LA(1)==F_NUM_CONST || LA(1)==APOST_CHAR_CST || LA(1)==QUOTE_CHAR_CST || LA(1)==46 || LA(1)==50 || LA(1)==51 || LA(1)==FORTRAN_ID) ) { arg = parser_expr_term( symtab ); tree->left_arg(arg); { zzBLOCK(zztasp2); zzMake0; { while ( (LA(1)==41 || LA(1)==42) ) { { zzBLOCK(zztasp3); zzMake0; { if ( (LA(1)==41) ) { zzmatch(41); op = ADD_OP; assoc = ASSOCIATIVE_OP; zzCONSUME; } else { if ( ( LA(1)==42) ) { zzmatch(42); op = SUB_OP; assoc = NONASSOCIATIVE_OP; zzCONSUME; } else {zzFAIL(1,zzerr5,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;} } zzEXIT(zztasp3); } } arg = parser_expr_term( symtab ); tree->add_arg(op, assoc, arg); zzLOOP(zztasp2); } zzEXIT(zztasp2); } } _retv = tree->grab(); delete tree; } else { if ( (LA(1)==41) ) { zzmatch(41); zzCONSUME; arg = parser_expr_term( symtab ); _retv = unary_plus(arg); } else { if ( (LA(1)==42) ) { zzmatch(42); zzCONSUME; arg = parser_expr_term( symtab ); _retv = unary_minus(arg); } else {zzFAIL(1,zzerr6,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;} } } zzEXIT(zztasp1); return _retv; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "Fortran arithmetic expression", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd2, 0x2); return _retv; } } Expression * #ifdef __STDC__ parser_expr_term( Symtab &symtab ) #else parser_expr_term(symtab) Symtab &symtab ; #endif { Expression * _retv; zzRULE; zzBLOCK(zztasp1); zzMake0; { Expression *arg; OP_TYPE op; TreeBuilder *tree = new TreeBuilder; ASSOC_BOOL assoc; _retv = 0; arg = parser_expr_factor( symtab ); tree->left_arg(arg); { zzBLOCK(zztasp2); zzMake0; { while ( (LA(1)==43 || LA(1)==44) ) { { zzBLOCK(zztasp3); zzMake0; { if ( ( LA(1)==43) ) { zzmatch(43); op = MULT_OP; assoc = ASSOCIATIVE_OP; zzCONSUME; } else { if ( (LA(1)==44) ) { zzmatch(44); op = DIV_OP; assoc = NONASSOCIATIVE_OP; zzCONSUME; } else {zzFAIL(1,zzerr7,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;} } zzEXIT(zztasp3); } } arg = parser_expr_factor( symtab ); tree->add_arg(op, assoc, arg); zzLOOP(zztasp2); } zzEXIT(zztasp2); } } _retv = tree->grab(); delete tree; zzEXIT(zztasp1); return _retv; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "Fortran term", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd2, 0x4); return _retv; } } Expression * #ifdef __STDC__ parser_expr_factor( Symtab &symtab ) #else parser_expr_factor(symtab) Symtab &symtab ; #endif { Expression * _retv; zzRULE; zzBLOCK(zztasp1); zzMake0; { Expression *arg; TreeBuilder *tree = new TreeBuilder; _retv = 0; arg = parser_afi_expr( symtab ); tree->left_arg(arg); { zzBLOCK(zztasp2); zzMake0; { if ( (LA(1)==45) ) { zzmatch(45); zzCONSUME; arg = parser_expr_factor( symtab ); tree->add_arg(EXP_OP, NONASSOCIATIVE_OP, arg); } zzEXIT(zztasp2); } } _retv = tree->grab(); delete tree; zzEXIT(zztasp1); return _retv; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "Fortran factor", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd2, 0x8); return _retv; } } Expression * #ifdef __STDC__ parser_afi_expr( Symtab &symtab ) #else parser_afi_expr(symtab) Symtab &symtab ; #endif { Expression * _retv; zzRULE; zzBLOCK(zztasp1); zzMake0; { Expression *arg = 0; _retv = 0; _retv = parser_expr_primary( symtab ); { zzBLOCK(zztasp2); zzMake0; { if ( (LA(1)==46) ) { { zzBLOCK(zztasp3); zzMake0; { zzmatch(46); zzCONSUME; arg = parser_afi_args( symtab ); zzmatch(47); _retv = make_afi_node(_retv, arg); /// ... We can't tell yet if it's a function /// ... call or an array reference--leave the /// ... decision to run-time arg = 0; zzCONSUME; zzEXIT(zztasp3); } } } zzEXIT(zztasp2); } } zzEXIT(zztasp1); return _retv; fail: zzEXIT(zztasp1); if (arg) { delete arg; } zzsyn(zzMissText, zzBadTok, "Fortran array ref/func call/substring expression", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd2, 0x10); return _retv; } } Expression * #ifdef __STDC__ parser_expr_primary( Symtab &symtab ) #else parser_expr_primary(symtab) Symtab &symtab ; #endif { Expression * _retv; zzRULE; zzBLOCK(zztasp1); zzMake0; { Expression *arg1 = 0; _retv = 0; if ( (LA(1)==F_NUM_CONST || LA(1)==APOST_CHAR_CST || LA(1)==QUOTE_CHAR_CST || LA(1)==50 || LA(1)==51) ) { _retv = parser_fortran_constant(); } else { if ( (LA(1)==FORTRAN_ID) ) { _retv = parser_sym_ref( symtab ); } else { if ( ( LA(1)==46) ) { zzmatch(46); zzCONSUME; arg1 = parser_expression( symtab ); zzmatch(47); _retv = arg1; arg1 = 0; zzCONSUME; } else {zzFAIL(1,zzerr8,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;} } } zzEXIT(zztasp1); return _retv; fail: zzEXIT(zztasp1); if (arg1) delete arg1; zzsyn(zzMissText, zzBadTok, "Fortran expression term", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd2, 0x20); return _retv; } } Expression * #ifdef __STDC__ parser_afi_args( Symtab &symtab ) #else parser_afi_args(symtab) Symtab &symtab ; #endif { Expression * _retv; zzRULE; zzBLOCK(zztasp1); zzMake0; { _retv = 0; if ( (LA(1)==F_NUM_CONST || LA(1)==APOST_CHAR_CST || LA(1)==QUOTE_CHAR_CST || LA(1)==33 || LA(1)==41 || LA(1)==42 || LA(1)==46 || LA(1)==49 || LA(1)==50 || LA(1)==51 || LA(1)==FORTRAN_ID) ) { _retv = parser_comma_args_expr( symtab ); } else { if ( (LA(1)==47) ) { /// ... No expression found -- return EMPTY comma-expr _retv = comma(new ExpressionList); } else {zzFAIL(1,zzerr9,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;} } zzEXIT(zztasp1); return _retv; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "arguments to array reference or function/intrinsic call", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd2, 0x40); return _retv; } } Expression * #ifdef __STDC__ parser_comma_args_expr( Symtab &symtab ) #else parser_comma_args_expr(symtab) Symtab &symtab ; #endif { Expression * _retv; zzRULE; zzBLOCK(zztasp1); zzMake0; { Expression *arg; ExpressionList *list = new ExpressionList; arg = parser_triplet( symtab ); list->ins_last(arg); { zzBLOCK(zztasp2); zzMake0; { while ( (LA(1)==48) ) { zzmatch(48); zzCONSUME; arg = parser_triplet( symtab ); list->ins_last(arg); zzLOOP(zztasp2); } zzEXIT(zztasp2); } } _retv = comma(list); list = 0; zzEXIT(zztasp1); return _retv; fail: zzEXIT(zztasp1); if (list) { delete list; } zzsyn(zzMissText, zzBadTok, "comma-separated (triplet) expression list", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd2, 0x80); return _retv; } } Expression * #ifdef __STDC__ parser_triplet( Symtab &symtab ) #else parser_triplet(symtab) Symtab &symtab ; #endif { Expression * _retv; zzRULE; zzBLOCK(zztasp1); zzMake0; { _retv = parser_colon_expr( symtab ); zzEXIT(zztasp1); return _retv; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "triplet or argument expression", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd3, 0x1); return _retv; } } Expression * #ifdef __STDC__ parser_colon_expr( Symtab &symtab ) #else parser_colon_expr(symtab) Symtab &symtab ; #endif { Expression * _retv; zzRULE; zzBLOCK(zztasp1); zzMake0; { _retv = 0; Expression *exprs[3] = { 0, 0, 0 }; Boolean is_triplet = False; parser_colon_expr_aux( symtab, exprs, is_triplet ); if (!is_triplet) { /// ... Not a triplet p_assert(exprs[1] == 0 && exprs[2] == 0, "Internal Error"); _retv = exprs[0]; exprs[0] = 0; } else { /// ... Triplet /// ... If first two args not specified, use /// ... an OmegaExpr instead. If stride not /// ... specified, leave it out of the colon /// ... expression altogether _retv = ::colon( (exprs[0] ? exprs[0] : omega()), (exprs[1] ? exprs[1] : omega()), (exprs[2] ? exprs[2] : 0) ); exprs[0] = exprs[1] = exprs[2] = 0; } zzEXIT(zztasp1); return _retv; fail: zzEXIT(zztasp1); for (int j = 0; j < 3; ++j) if (exprs[j]) delete exprs[j]; zzsyn(zzMissText, zzBadTok, "colon-seperated expression list", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd3, 0x2); return _retv; } } void #ifdef __STDC__ parser_colon_expr_aux( Symtab &symtab, Expression *exprs[3], Boolean &is_triplet ) #else parser_colon_expr_aux(symtab,3,is_triplet) Symtab &symtab; Expression *exprs[3]; Boolean &is_triplet ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { if ( (LA(1)==F_NUM_CONST || LA(1)==APOST_CHAR_CST || LA(1)==QUOTE_CHAR_CST || LA(1)==33 || LA(1)==41 || LA(1)==42 || LA(1)==46 || LA(1)==50 || LA(1)==51 || LA(1)==FORTRAN_ID) ) { exprs[0] = parser_expression( symtab ); { zzBLOCK(zztasp2); zzMake0; { if ( (LA(1)==49) ) { zzmatch(49); is_triplet = True; zzCONSUME; { zzBLOCK(zztasp3); zzMake0; { if ( ( LA(1)==F_NUM_CONST || LA(1)==APOST_CHAR_CST || LA(1)==QUOTE_CHAR_CST || LA(1)==33 || LA(1)==41 || LA(1)==42 || LA(1)==46 || LA(1)==50 || LA(1)==51 || LA(1)==FORTRAN_ID) ) { exprs[1] = parser_expression( symtab ); } zzEXIT(zztasp3); } } { zzBLOCK(zztasp3); zzMake0; { if ( ( LA(1)==49) ) { zzmatch(49); zzCONSUME; exprs[2] = parser_expression( symtab ); } zzEXIT(zztasp3); } } } zzEXIT(zztasp2); } } } else { if ( (LA(1)==49) ) { zzmatch(49); is_triplet = True; zzCONSUME; { zzBLOCK(zztasp2); zzMake0; { if ( (LA(1)==F_NUM_CONST || LA(1)==APOST_CHAR_CST || LA(1)==QUOTE_CHAR_CST || LA(1)==33 || LA(1)==41 || LA(1)==42 || LA(1)==46 || LA(1)==50 || LA(1)==51 || LA(1)==FORTRAN_ID) ) { exprs[1] = parser_expression( symtab ); } zzEXIT(zztasp2); } } { zzBLOCK(zztasp2); zzMake0; { if ( (LA(1)==49) ) { zzmatch(49); zzCONSUME; exprs[2] = parser_expression( symtab ); } zzEXIT(zztasp2); } } } else {zzFAIL(1,zzerr10,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;} } zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "colon-separated expression list", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd3, 0x4); } } Expression * #ifdef __STDC__ parser_fortran_constant(void) #else parser_fortran_constant() #endif { Expression * _retv; zzRULE; zzBLOCK(zztasp1); zzMake0; { _retv = 0; if ( (LA(1)==50) ) { zzmatch(50); _retv = new LogicalConstExpr(".TRUE."); zzCONSUME; } else { if ( (LA(1)==51) ) { zzmatch(51); _retv = new LogicalConstExpr(".FALSE."); zzCONSUME; } else { if ( ( LA(1)==APOST_CHAR_CST) ) { zzmatch(APOST_CHAR_CST); _retv = new StringConstExpr(strip_outer_quotes(zzaArg(zztasp1,1 ).text)); zzCONSUME; } else { if ( (LA(1)==QUOTE_CHAR_CST) ) { zzmatch(QUOTE_CHAR_CST); _retv = constant(zzaArg(zztasp1,1 ).text); zzCONSUME; } else { if ( (LA(1)==F_NUM_CONST) ) { zzmatch(F_NUM_CONST); Type type = string_type(zzaArg(zztasp1,1 ).text, True); switch(type.data_type()) { case UNDEFINED_TYPE: { String msg = "Malformed Fortran numeric constant `"; msg += zzaArg(zztasp1,1 ).text; msg += "'"; parse_error(msg); _retv = constant(0); /// ... Dummy to return } break; case INTEGER_TYPE: _retv = constant(zzaArg(zztasp1,1 ).text); break; case REAL_TYPE: _retv = new RealConstExpr(REAL_TYPE, zzaArg(zztasp1,1 ).text); break; case DOUBLE_PRECISION_TYPE: _retv = new RealConstExpr(DOUBLE_PRECISION_TYPE, zzaArg(zztasp1,1 ).text); break; default: p_abort("Internal Error: Fortran numeric " "constant returned non-numeric type"); break; } zzCONSUME; } else {zzFAIL(1,zzerr11,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;} } } } } zzEXIT(zztasp1); return _retv; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "Fortran constant", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd3, 0x8); return _retv; } } Expression * #ifdef __STDC__ parser_sym_ref( Symtab &symtab ) #else parser_sym_ref(symtab) Symtab &symtab ; #endif { Expression * _retv; zzRULE; zzBLOCK(zztasp1); zzMake0; { zzmatch(FORTRAN_ID); { const char *name = zzaArg(zztasp1,1 ).text; Symbol *sym = symtab.find_ref(name); if (sym) _retv = id(*sym); else { _retv = constant(0); /// ... dummy return String msg = (String)"Undefined Fortran symbol `" + name + "'"; parse_error(msg); } } zzCONSUME; zzEXIT(zztasp1); return _retv; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "Fortran symbol reference", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd3, 0x10); return _retv; } } ExpressionList * #ifdef __STDC__ parser_expr_list_with_commas( Symtab &symtab ) #else parser_expr_list_with_commas(symtab) Symtab &symtab ; #endif { ExpressionList * _retv; zzRULE; zzBLOCK(zztasp1); zzMake0; { Expression *e = 0; _retv = new ExpressionList; e = parser_expression( symtab ); if (e) _retv->ins_last(e); { zzBLOCK(zztasp2); zzMake0; { while ( (LA(1)==48) ) { zzmatch(48); zzCONSUME; e = parser_expression( symtab ); if (e) _retv->ins_last(e); zzLOOP(zztasp2); } zzEXIT(zztasp2); } } zzEXIT(zztasp1); return _retv; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "Expression list", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd3, 0x20); return _retv; } } ExpressionList * #ifdef __STDC__ parser_lvalue_list_with_commas( Symtab &symtab ) #else parser_lvalue_list_with_commas(symtab) Symtab &symtab ; #endif { ExpressionList * _retv; zzRULE; zzBLOCK(zztasp1); zzMake0; { _retv = parser_expr_list_with_commas( symtab ); validate_expr_list_types(*_retv, "scalar variable or array reference", True, /// ... can_be_scalar_var True, /// ... can_be_array_elem True /// ... can_be_entire_array ); zzEXIT(zztasp1); return _retv; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "List of Variables/Array Elements", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd3, 0x40); return _retv; } } Symbol * #ifdef __STDC__ parser_scalar_var( ParserContext &context ) #else parser_scalar_var(context) ParserContext &context ; #endif { Symbol * _retv; zzRULE; zzBLOCK(zztasp1); zzMake0; { Expression *e = 0; _retv = 0; e = parser_expression( context.pgm.symtab() ); if (!is_scalar_var(*e)) { ostrstream s; s << "Expected scalar variable but found: " << *e << endl; char *str = s.str(); parse_error(str); delete [] str; delete e; } else { Symbol &sym = e->symbol(); delete e; return &sym; } zzEXIT(zztasp1); return _retv; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "scalar variable", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd3, 0x80); return _retv; } } void #ifdef __STDC__ parser_generic_private( ParserContext &context ) #else parser_generic_private(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { ExpressionList *lvalues = 0; Statement *s = 0; AssertPrivate *a = 0; zzmatch(53); a = 0; s = enclosing_scope( context.s_next ); if (s != 0) { /// ... Search for an existing PRIVATE assertion a = (AssertPrivate *) assertion_of_type( s->assertions(), AS_PRIVATE ); if (a == 0) { a = new AssertPrivate; s->assertions().ins_last( a ); } } else { parse_error("PRIVATE is not within a DO loop or " "BLOCK ENTRY scope"); } zzCONSUME; lvalues = parser_lvalue_list_with_commas( context.pgm.symtab() ); zzmatch(1); if (a != 0) list_absorb(a->arg_list_guarded(), lvalues); else delete lvalues; /// ... No assertion to stick these into zzCONSUME; zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "PRIVATE directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd4, 0x1); } } void #ifdef __STDC__ parser_generic_assert( ParserContext &context ) #else parser_generic_assert(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { ExpressionList *ex_list = 0; Statement *s = 0; AssertRelation *a = 0; zzmatch(54); a = 0; s = &context.s_next; if (s != 0) { /// ... Search for an existing RELATION assertion a = (AssertRelation *) assertion_of_type( s->assertions(), AS_RELATION ); if (a == 0) { a = new AssertRelation; s->assertions().ins_last( a ); } } zzCONSUME; ex_list = parser_expr_list_with_commas( context.pgm.symtab() ); zzmatch(1); if (a != 0) list_absorb(a->arg_list_guarded(), ex_list); else delete ex_list; /// ... No assertion to stick these into zzCONSUME; zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "ASSERT directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd4, 0x2); } } void #ifdef __STDC__ parser_generic_safe_condition( ParserContext &context ) #else parser_generic_safe_condition(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { ExpressionList *ex_list = 0; Statement *s = 0; AssertSafeCondition *a = 0; zzmatch(55); a = 0; s = &context.s_next; if (s != 0) { /// ... Search for an existing SAFE_CONDITION assertion a = (AssertSafeCondition *) assertion_of_type( s->assertions(), AS_SAFE_CONDITION ); if (a == 0) { a = new AssertSafeCondition; s->assertions().ins_last( a ); } } zzCONSUME; ex_list = parser_expr_list_with_commas( context.pgm.symtab() ); zzmatch(1); if (a != 0) list_absorb(a->arg_list_guarded(), ex_list); else delete ex_list; /// ... No assertion to stick these into zzCONSUME; zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "SAFE_CONDITION directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd4, 0x4); } } void #ifdef __STDC__ parser_generic_begin_parallel( ParserContext &context ) #else parser_generic_begin_parallel(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { Symbol *scalar = 0; AssertPrologue *as_pro = 0; AssertParallel *as_par = 0; Statement *s = 0; Statement *s_do = 0; zzmatch(56); zzCONSUME; zzmatch(46); zzCONSUME; scalar = parser_scalar_var( context ); zzmatch(47); zzCONSUME; zzmatch(1); as_pro = new AssertPrologue; as_pro->arg_list_guarded().ins_last( id(*scalar) ); context.s_next.assertions().ins_last( as_pro ); /// ... Find the appropriate DO statement for (s = &context.s_next; s != 0; s = s->next_ref()) { if (s->stmt_class() == DO_STMT) { if (&s->index().symbol() == scalar) { s_do = s; break; } s = s->follow_ref(); p_assert( s->stmt_class() == ENDDO_STMT, "not a DO loop" ); } } if (s_do != 0) { as_par = (AssertParallel *) assertion_of_type(s_do->assertions(), AS_PARALLEL); if (as_par == 0) { as_par = new AssertParallel; s_do->assertions().ins_first( as_par ); as_par->arg_list_guarded().ins_first( id(*scalar) ); } as_par->assertion_list().ins_last( *as_pro ); as_pro->assertion_list().ins_last( *as_par ); } else { parse_error("BEGIN PARALLEL: Could not find specified " "DO loop"); } zzCONSUME; zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "BEGIN PARALLEL directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd4, 0x8); } } void #ifdef __STDC__ parser_generic_end_parallel( ParserContext &context ) #else parser_generic_end_parallel(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { Symbol *scalar = 0; AssertEpilogue *as_epi = 0; AssertParallel *as_par = 0; Statement *s = 0; Statement *s_do = 0; zzmatch(56); zzCONSUME; zzmatch(46); zzCONSUME; scalar = parser_scalar_var( context ); zzmatch(47); zzCONSUME; zzmatch(1); as_epi = new AssertEpilogue; as_epi->arg_list_guarded().ins_last( id(*scalar) ); context.s_next.prev_ref()->assertions().ins_last(as_epi); /// ... Find appropriate DO for (s = context.s_next.prev_ref(); s != 0; s = s->prev_ref()) { if (s->stmt_class() == ENDDO_STMT) { s = s->follow_ref(); if (s->stmt_class() == DO_STMT) { if (&s->index().symbol() == scalar) { s_do = s; break; } } } } if (s_do != 0) { as_par = (AssertParallel *) assertion_of_type(s_do->assertions(), AS_PARALLEL); if (as_par == 0) { as_par = new AssertParallel; s_do->assertions().ins_first( as_par ); as_par->arg_list_guarded().ins_first( id(*scalar) ); } as_par->assertion_list().ins_last( *as_epi ); as_epi->assertion_list().ins_last( *as_par ); } else { parse_error("END PARALLEL: Could not find specified " "DO loop"); } zzCONSUME; zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "END PARALLEL directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd4, 0x10); } } void #ifdef __STDC__ parser_generic_begin_block( ParserContext &context ) #else parser_generic_begin_block(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { Statement *s = 0; Statement *prev_stmt = 0; zzmatch(57); zzCONSUME; zzmatch(1); s = new BlockEntryStmt( context.pgm.stmts().new_tag() ); prev_stmt = context.s_next.prev_ref(); if (prev_stmt->stmt_class() == IMPLIED_GOTO_STMT) { prev_stmt = prev_stmt->prev_ref(); }; /// ... WARNING: this is a private: member access. /// ... Make sure you know what you are doing. Directive::_ins_after(context.pgm.stmts(), s, prev_stmt, "BLOCK_ENTRY" ); zzCONSUME; zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "BEGIN BLOCK directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd4, 0x20); } } void #ifdef __STDC__ parser_generic_instrument( ParserContext &context ) #else parser_generic_instrument(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { Statement *s = 0; AssertInstrument *a = 0; IntConstExpr *arg = 0; { zzBLOCK(zztasp2); zzMake0; { if ( (LA(1)==58) ) { zzmatch(58); arg = new IntConstExpr(1); zzCONSUME; } else { if ( ( LA(1)==59) ) { zzmatch(59); arg = new IntConstExpr(2); zzCONSUME; } else { if ( (LA(1)==60) ) { zzmatch(60); zzCONSUME; } else {zzFAIL(1,zzerr12,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;} } } zzEXIT(zztasp2); } } zzmatch(1); s = &context.s_next; a = new AssertInstrument; if(arg) a->arg_list_guarded().ins_last(arg); s->assertions().ins_last( a ); zzCONSUME; zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "INSTRUMENT directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd4, 0x40); } } void #ifdef __STDC__ parser_generic_rtshadow( ParserContext &context ) #else parser_generic_rtshadow(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { ExpressionList *lvalues = 0; Statement *s = 0; AssertRTShadow *a = 0; zzmatch(61); a = new AssertRTShadow; context.s_next.assertions().ins_last( a ); zzCONSUME; { zzBLOCK(zztasp2); zzMake0; { if ( (LA(1)==F_NUM_CONST || LA(1)==APOST_CHAR_CST || LA(1)==QUOTE_CHAR_CST || LA(1)==33 || LA(1)==41 || LA(1)==42 || LA(1)==46 || LA(1)==50 || LA(1)==51 || LA(1)==FORTRAN_ID) ) { lvalues = parser_lvalue_list_with_commas( context.pgm.symtab() ); } zzEXIT(zztasp2); } } zzmatch(1); if (a != 0) list_absorb(a->arg_list_guarded(), lvalues); else delete lvalues; /// ... No assertion to stick these into zzCONSUME; zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "RTSHADOW directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd4, 0x80); } } void #ifdef __STDC__ parser_generic_depio( ParserContext &context ) #else parser_generic_depio(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { Statement *s = 0; AssertDepIO *a = 0; zzmatch(62); zzCONSUME; zzmatch(1); s = &context.s_next; a = new AssertDepIO; s->assertions().ins_last( a ); zzCONSUME; zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "DEPIO directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd5, 0x1); } } void #ifdef __STDC__ parser_generic_inline( ParserContext &context ) #else parser_generic_inline(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { Statement *s = 0; AssertInline *a = 0; zzmatch(63); zzCONSUME; zzmatch(1); s = &context.s_next; a = new AssertInline; s->assertions().ins_last( a ); zzCONSUME; zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "INLINE directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd5, 0x2); } } void #ifdef __STDC__ parser_generic_recursive_inline( ParserContext &context ) #else parser_generic_recursive_inline(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { Statement *s = 0; AssertRecursiveInline *a = 0; zzmatch(64); zzCONSUME; zzmatch(1); s = &context.s_next; a = new AssertRecursiveInline; s->assertions().ins_last( a ); zzCONSUME; zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "RECURSIVEINLINE directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd5, 0x4); } } void #ifdef __STDC__ parser_generic_preamble( ParserContext &context ) #else parser_generic_preamble(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { Statement *s = 0; AssertPreamble *a = 0; zzmatch(65); zzCONSUME; zzmatch(1); s = &context.s_next; a = new AssertPreamble; s->assertions().ins_last( a ); zzCONSUME; zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "PREAMBLE directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd5, 0x8); } } void #ifdef __STDC__ parser_generic_postamble( ParserContext &context ) #else parser_generic_postamble(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { Statement *s = 0; AssertPostamble *a = 0; zzmatch(66); zzCONSUME; zzmatch(1); s = &context.s_next; a = new AssertPostamble; s->assertions().ins_last( a ); zzCONSUME; zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "POSTAMBLE directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd5, 0x10); } } void #ifdef __STDC__ parser_generic_noinline( ParserContext &context ) #else parser_generic_noinline(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { Statement *s = 0; AssertNoInline *a = 0; zzmatch(67); zzCONSUME; zzmatch(1); s = &context.s_next; a = new AssertNoInline; s->assertions().ins_last( a ); zzCONSUME; zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "NOINLINE directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd5, 0x20); } } void #ifdef __STDC__ parser_generic_noputget( ParserContext &context ) #else parser_generic_noputget(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { Statement *s = 0; AssertNoPutGet *a = 0; zzmatch(68); zzCONSUME; zzmatch(1); s = &context.s_next; a = new AssertNoPutGet; s->assertions().ins_last( a ); zzCONSUME; zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "NOPUTGET directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd5, 0x40); } } void #ifdef __STDC__ parser_generic_runtimetest( ParserContext &context ) #else parser_generic_runtimetest(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { Statement *s = 0; AssertRunTimeTest *a = 0; zzmatch(69); zzCONSUME; zzmatch(1); s = &context.s_next; a = new AssertRunTimeTest; s->assertions().ins_last( a ); zzCONSUME; zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "RUNTIMETEST directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd5, 0x80); } } void #ifdef __STDC__ parser_generic_end_block( ParserContext &context ) #else parser_generic_end_block(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { Statement *s = 0; BlockEntryStmt *s_begin_block = 0; BlockExitStmt *s_end_block = 0; zzmatch(57); zzCONSUME; zzmatch(1); s_end_block = new BlockExitStmt( context.pgm.stmts().new_tag() ); s = context.s_next.prev_ref(); if (s->stmt_class() == IMPLIED_GOTO_STMT) s = s->prev_ref(); /// ... WARNING: this is a private: member access. /// ... Make sure you know what you are doing. Directive::_ins_after(context.pgm.stmts(), s_end_block, s, "BLOCK_EXIT" ); /// ... Patch up the follow links for (s = s_end_block->prev_ref(); s != 0; s=s->prev_ref()) { if (s->stmt_class() == BLOCK_EXIT_STMT) s = s->follow_ref(); else if (s->stmt_class() == BLOCK_ENTRY_STMT) { s_begin_block = (BlockEntryStmt *) s; break; } } if (s_begin_block != 0) { Directive::_set_follow_fields(*s_begin_block, *s_end_block); } else { parse_error("END BLOCK: Could not find matching " "BEGIN BLOCK"); } zzCONSUME; zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "END BLOCK directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd6, 0x1); } } void #ifdef __STDC__ parser_generic_last_value( ParserContext &context ) #else parser_generic_last_value(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { Statement *s = 0; Statement *s_do = 0; ExpressionList *lvalues = 0; zzmatch(70); zzCONSUME; lvalues = parser_lvalue_list_with_commas( context.pgm.symtab() ); zzmatch(1); s_do = enclosing_scope( context.s_next ); if (s_do != 0) { AssertLastValue *a = (AssertLastValue *) assertion_of_type(s_do->assertions(), AS_LASTVALUE); if (a == 0) { a = new AssertLastValue; s_do->assertions().ins_last( a ); } list_absorb(a->arg_list_guarded(), lvalues); } else { parse_error("LASTVALUE does not follow a DO loop"); delete lvalues; } zzCONSUME; zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "LAST VALUE directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd6, 0x2); } } void #ifdef __STDC__ parser_csrd_dynlast_value( ParserContext &context ) #else parser_csrd_dynlast_value(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { Statement *s = 0; Statement *s_do = 0; ExpressionList *lvalues = 0; zzmatch(71); zzCONSUME; lvalues = parser_lvalue_list_with_commas( context.pgm.symtab() ); zzmatch(1); s_do = enclosing_scope( context.s_next ); if (s_do != 0) { AssertDynLastValue *a = (AssertDynLastValue *) assertion_of_type(s_do->assertions(), AS_DYNLASTVALUE); if (a == 0) { a = new AssertDynLastValue; s_do->assertions().ins_last( a ); } list_absorb(a->arg_list_guarded(), lvalues); } else { parse_error("DYNLASTVALUE does not follow a DO loop"); delete lvalues; } zzCONSUME; zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "DYNAMIC LAST VALUE directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd6, 0x4); } } void #ifdef __STDC__ parser_generic_first_value( ParserContext &context ) #else parser_generic_first_value(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { Statement *s = 0; Statement *s_do = 0; ExpressionList *lvalues = 0; zzmatch(72); zzCONSUME; lvalues = parser_lvalue_list_with_commas( context.pgm.symtab() ); zzmatch(1); s_do = enclosing_scope( context.s_next ); if (s_do != 0) { AssertFirstValue *a = (AssertFirstValue *) assertion_of_type(s_do->assertions(), AS_FIRSTVALUE); if (a == 0) { a = new AssertFirstValue; s_do->assertions().ins_last( a ); } list_absorb(a->arg_list_guarded(), lvalues); } else { parse_error("FIRSTVALUE does not follow a DO loop"); delete lvalues; } zzCONSUME; zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "FIRST VALUE directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd6, 0x8); } } void #ifdef __STDC__ parser_generic_forward( ParserContext &context ) #else parser_generic_forward(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { ExpressionList *elist = 0; AssertForward *a; zzmatch(73); zzCONSUME; elist = parser_expr_list_with_commas( context.pgm.symtab() ); zzmatch(1); a = new AssertForward; context.s_next.assertions().ins_last( a ); list_absorb(a->arg_list_guarded(), elist); zzCONSUME; zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "FORWARD directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd6, 0x10); } } void #ifdef __STDC__ parser_csrd_range_written( ParserContext &context ) #else parser_csrd_range_written(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { Statement *s = 0; Statement *s_do = 0; ExpressionList *lvalues = 0; zzmatch(74); zzCONSUME; lvalues = parser_lvalue_list_with_commas( context.pgm.symtab() ); zzmatch(1); s_do = enclosing_scope( context.s_next ); if (s_do != 0) { AssertRangeWritten *a = (AssertRangeWritten *) assertion_of_type(s_do->assertions(), AS_RANGEWRITTEN); if (a == 0) { a = new AssertRangeWritten; s_do->assertions().ins_last( a ); } list_absorb(a->arg_list_guarded(), lvalues); } else { parse_error("RANGEWRITTEN does not follow a DO loop"); delete lvalues; } zzCONSUME; zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "RANGE WRITTEN directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd6, 0x20); } } void #ifdef __STDC__ parser_generic_parallel( ParserContext &context ) #else parser_generic_parallel(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { Symbol *scalar = 0; zzmatch(56); zzCONSUME; { zzBLOCK(zztasp2); zzMake0; { while ( (LA(1)==46) ) { zzmatch(46); zzCONSUME; scalar = parser_scalar_var( context ); zzmatch(47); zzCONSUME; zzLOOP(zztasp2); } zzEXIT(zztasp2); } } zzmatch(1); force_parallel(context, scalar, "PARALLEL"); zzCONSUME; zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "PARALLEL directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd6, 0x40); } } void #ifdef __STDC__ parser_generic_serial( ParserContext &context ) #else parser_generic_serial(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { Statement *s = 0; Symbol *scalar = 0; zzmatch(75); zzCONSUME; { zzBLOCK(zztasp2); zzMake0; { while ( (LA(1)==46) ) { zzmatch(46); zzCONSUME; scalar = parser_scalar_var( context ); zzmatch(47); zzCONSUME; zzLOOP(zztasp2); } zzEXIT(zztasp2); } } zzmatch(1); s = &context.s_next; if (s != 0) { AssertSerial *a = (AssertSerial *) assertion_of_type( s->assertions(), AS_SERIAL); if (a == 0) { a = new AssertSerial; s->assertions().ins_last( a ); } } zzCONSUME; zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "SERIAL directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd6, 0x80); } } void #ifdef __STDC__ parser_generic_critical( ParserContext &context ) #else parser_generic_critical(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { Statement *s = 0; Symbol *scalar = 0; zzmatch(76); zzCONSUME; { zzBLOCK(zztasp2); zzMake0; { while ( (LA(1)==46) ) { zzmatch(46); zzCONSUME; scalar = parser_scalar_var( context ); zzmatch(47); zzCONSUME; zzLOOP(zztasp2); } zzEXIT(zztasp2); } } zzmatch(1); s = &context.s_next; if (s != 0) { AssertCritical *a = (AssertCritical *) assertion_of_type(s->assertions(), AS_CRITICAL); if (a == 0) { a = new AssertCritical; s->assertions().ins_last( a ); } } zzCONSUME; zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "CRITICAL directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd7, 0x1); } } void #ifdef __STDC__ parser_generic_reduction( ParserContext &context ) #else parser_generic_reduction(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { ExpressionList *lvalues = 0; Statement *s_do = 0; zzmatch(77); zzCONSUME; lvalues = parser_lvalue_list_with_commas( context.pgm.symtab() ); zzmatch(1); s_do = enclosing_scope( context.s_next ); if (s_do != 0) { AssertReduction *a = (AssertReduction *) assertion_of_type(s_do->assertions(), AS_REDUCTION); if (a == 0) { a = new AssertReduction; s_do->assertions().ins_last( a ); } list_absorb(a->arg_list_guarded(), lvalues); } else { parse_error("REDUCTION is not within a DO loop"); delete lvalues; } zzCONSUME; zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "REDUCTION directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd7, 0x2); } } void #ifdef __STDC__ parser_generic_shared( ParserContext &context ) #else parser_generic_shared(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { ExpressionList *lvalues = 0; Statement *s = 0; AssertShared *a = 0; zzmatch(78); a = 0; s = enclosing_scope( context.s_next ); if (s != 0) { /// ... Search for an existing SHARED assertion a = (AssertShared *) assertion_of_type( s->assertions(), AS_SHARED ); if (a == 0) { a = new AssertShared; s->assertions().ins_last( a ); } } else { parse_error("SHARED is not within a DO loop or " "BLOCK ENTRY scope"); } zzCONSUME; lvalues = parser_lvalue_list_with_commas( context.pgm.symtab() ); zzmatch(1); if (a != 0) list_absorb(a->arg_list_guarded(), lvalues); else delete lvalues; /// ... No assertion to stick these into zzCONSUME; zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "SHARED directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd7, 0x4); } } void #ifdef __STDC__ parser_csrd_directive( ParserContext &context ) #else parser_csrd_directive(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { { zzBLOCK(zztasp2); zzMake0; { if ( ( LA(1)==53) ) { parser_csrd_private( context ); } else { if ( (LA(1)==54) ) { parser_csrd_assert( context ); } else { if ( (LA(1)==55) ) { parser_csrd_safe_condition( context ); } else { if ( (LA(1)==75) ) { parser_csrd_serial( context ); } else { if ( (LA(1)==76) ) { parser_csrd_critical( context ); } else { if ( ( LA(1)==90) ) { parser_csrd_begin( context ); } else { if ( (LA(1)==91) ) { parser_csrd_end( context ); } else { if ( (LA(1)==70) ) { parser_csrd_last_value( context ); } else { if ( (LA(1)==72) ) { parser_csrd_first_value( context ); } else { if ( (LA(1)==73) ) { parser_csrd_forward( context ); } else { if ( ( LA(1)==71) ) { parser_csrd_dynlast_value( context ); } else { if ( (LA(1)==74) ) { parser_csrd_range_written( context ); } else { if ( (LA(1)==56) ) { parser_csrd_parallel( context ); } else { if ( (LA(1)==77) ) { parser_csrd_reduction( context ); } else { if ( (LA(1)==81) ) { parser_csrd_looplabel( context ); } else { if ( ( LA(1)==82) ) { parser_csrd_schedule( context ); } else { if ( (LA(1)==78) ) { parser_csrd_shared( context ); } else { if ( (LA(1)==84) ) { parser_csrd_induction( context ); } else { if ( (LA(1)==85) ) { parser_csrd_parcondition( context ); } else { if ( (LA(1)==86) ) { parser_csrd_nomod( context ); } else { if ( ( LA(1)==87) ) { parser_csrd_maymod( context ); } else { if ( (LA(1)==83) ) { parser_csrd_privaterefs( context ); } else { if ( (LA(1)==88) ) { parser_csrd_readonlyrefs( context ); } else { if ( (LA(1)==89) ) { parser_csrd_sharedrefs( context ); } else { if ( (LA(1)==65) ) { parser_csrd_preamble( context ); } else { if ( ( LA(1)==66) ) { parser_csrd_postamble( context ); } else { if ( (LA(1)==58 || LA(1)==59 || LA(1)==60) ) { parser_csrd_instrument( context ); } else { if ( (LA(1)==61) ) { parser_csrd_rtshadow( context ); } else { if ( ( LA(1)==63) ) { parser_csrd_inline( context ); } else { if ( (LA(1)==64) ) { parser_csrd_recursive_inline( context ); } else { if ( (LA(1)==68) ) { parser_csrd_noputget( context ); } else { if ( (LA(1)==67) ) { parser_csrd_noinline( context ); } else { if ( (LA(1)==69) ) { parser_csrd_runtimetest( context ); } else { if ( ( LA(1)==79) ) { parser_csrd_no_dependence( context ); } else { if ( (LA(1)==80) ) { parser_csrd_sideeffectfree( context ); } else {zzFAIL(1,zzerr13,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;} } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } zzEXIT(zztasp2); } } zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "CSRD directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd7, 0x8); } } void #ifdef __STDC__ parser_csrd_no_dependence( ParserContext &context ) #else parser_csrd_no_dependence(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { ExpressionList *lvalues = 0; Statement *s = 0; AssertNoDependence *a = 0; zzmatch(79); a = 0; s = enclosing_scope( context.s_next ); if (s != 0) { /// ... Search for an existing NO_DEPENDENCE assertion a = (AssertNoDependence *) assertion_of_type( s->assertions(), AS_NODEPENDENCE ); if (a == 0) { a = new AssertNoDependence; s->assertions().ins_last( a ); } } else { parse_error("NO_DEPENDENCE is not within a DO loop or " "BLOCK ENTRY scope"); } zzCONSUME; zzmatch(46); zzCONSUME; lvalues = parser_lvalue_list_with_commas( context.pgm.symtab() ); zzmatch(47); zzCONSUME; zzmatch(1); if (a != 0) list_absorb(a->arg_list_guarded(), lvalues); else delete lvalues; /// ... No assertion to stick these into zzCONSUME; zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "CSRD NO_DEPENDENCE directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd7, 0x10); } } void #ifdef __STDC__ parser_csrd_sideeffectfree( ParserContext &context ) #else parser_csrd_sideeffectfree(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { ExpressionList *lvalues = 0; Statement *s = 0; AssertSideEffectFree *a = 0; zzmatch(80); a = 0; s = &context.s_next; /// ... Search for an existing SIDE_EFFECT_FREE assertion a = (AssertSideEffectFree *) assertion_of_type( s->assertions(), AS_SIDE_EFFECT_FREE ); if (a == 0) { a = new AssertSideEffectFree; s->assertions().ins_last( a ); } zzCONSUME; zzmatch(46); zzCONSUME; lvalues = parser_expr_list_with_commas( context.pgm.symtab() ); zzmatch(47); zzCONSUME; zzmatch(1); if (a != 0) list_absorb(a->arg_list_guarded(), lvalues); else delete lvalues; /// ... No assertion to stick these into zzCONSUME; zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "CSRD SIDE_EFFECT_FREE directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd7, 0x20); } } void #ifdef __STDC__ parser_csrd_preamble( ParserContext &context ) #else parser_csrd_preamble(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { parser_generic_preamble( context ); zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "CSRD PREAMBLE directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd7, 0x40); } } void #ifdef __STDC__ parser_csrd_postamble( ParserContext &context ) #else parser_csrd_postamble(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { parser_generic_postamble( context ); zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "CSRD POSTAMBLE directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd7, 0x80); } } void #ifdef __STDC__ parser_csrd_instrument( ParserContext &context ) #else parser_csrd_instrument(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { parser_generic_instrument( context ); zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "CSRD INSTRUMENT directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd8, 0x1); } } void #ifdef __STDC__ parser_csrd_rtshadow( ParserContext &context ) #else parser_csrd_rtshadow(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { parser_generic_rtshadow( context ); zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "CSRD RTSHADOW directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd8, 0x2); } } void #ifdef __STDC__ parser_csrd_depio( ParserContext &context ) #else parser_csrd_depio(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { parser_generic_depio( context ); zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "CSRD DEP_IO directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd8, 0x4); } } void #ifdef __STDC__ parser_csrd_inline( ParserContext &context ) #else parser_csrd_inline(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { parser_generic_inline( context ); zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "CSRD INLINE directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd8, 0x8); } } void #ifdef __STDC__ parser_csrd_recursive_inline( ParserContext &context ) #else parser_csrd_recursive_inline(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { parser_generic_recursive_inline( context ); zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "CSRD RECURSIVEINLINE directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd8, 0x10); } } void #ifdef __STDC__ parser_csrd_noputget( ParserContext &context ) #else parser_csrd_noputget(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { parser_generic_noputget( context ); zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "CSRD NOPUTGET directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd8, 0x20); } } void #ifdef __STDC__ parser_csrd_noinline( ParserContext &context ) #else parser_csrd_noinline(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { parser_generic_noinline( context ); zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "CSRD NOINLINE directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd8, 0x40); } } void #ifdef __STDC__ parser_csrd_runtimetest( ParserContext &context ) #else parser_csrd_runtimetest(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { parser_generic_runtimetest( context ); zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "CSRD RUN_TIME_TEST directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd8, 0x80); } } void #ifdef __STDC__ parser_csrd_private( ParserContext &context ) #else parser_csrd_private(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { parser_generic_private( context ); zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "CSRD PRIVATE directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd9, 0x1); } } void #ifdef __STDC__ parser_csrd_assert( ParserContext &context ) #else parser_csrd_assert(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { parser_generic_assert( context ); zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "CSRD ASSERT directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd9, 0x2); } } void #ifdef __STDC__ parser_csrd_safe_condition( ParserContext &context ) #else parser_csrd_safe_condition(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { parser_generic_safe_condition( context ); zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "CSRD SAFE_CONDITION directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd9, 0x4); } } void #ifdef __STDC__ parser_csrd_critical( ParserContext &context ) #else parser_csrd_critical(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { parser_generic_critical( context ); zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "CSRD CRITICAL directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd9, 0x8); } } void #ifdef __STDC__ parser_csrd_serial( ParserContext &context ) #else parser_csrd_serial(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { parser_generic_serial( context ); zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "CSRD SERIAL directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd9, 0x10); } } void #ifdef __STDC__ parser_csrd_looplabel( ParserContext &context ) #else parser_csrd_looplabel(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { AssertLoopLabel *a = 0; Expression *e = 0; String name = ""; zzmatch(81); zzCONSUME; e = parser_fortran_constant(); zzmatch(1); a = new AssertLoopLabel; a->string_arg_list_guarded().ins_last(new StringElem (e->str_data())); p_assert(context.s_next.stmt_class() == DO_STMT, "Statement after a LOOPLABEL directive should be a DO statement"); context.s_next.assertions().ins_last(a); zzCONSUME; zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "CSRD LOOPLABEL directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd9, 0x20); } } void #ifdef __STDC__ parser_csrd_schedule( ParserContext &context ) #else parser_csrd_schedule(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { AssertSchedule *a = 0; Expression *e = 0; String name = ""; zzmatch(82); zzCONSUME; e = parser_fortran_constant(); zzmatch(1); a = new AssertSchedule; /// ... Strip the quotes off the name (substr function) name = String(e->str_data(), 1, e->str_data().len()-2); a->string_arg_list_guarded().ins_last(new StringElem (name)); p_assert(context.s_next.stmt_class() == DO_STMT, "Statement after a SCHEDULE directive should be a DO statement"); context.s_next.assertions().ins_last(a); zzCONSUME; zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "CSRD SCHEDULE directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd9, 0x40); } } void #ifdef __STDC__ parser_csrd_privaterefs( ParserContext &context ) #else parser_csrd_privaterefs(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { ExpressionList *lvalues = 0; Statement *s = 0; AssertPrivateRefs *a = 0; zzmatch(83); a = 0; s = enclosing_scope( context.s_next ); if (s != 0) { a = new AssertPrivateRefs; s->assertions().ins_last( a ); } else { parse_error("PRIVATE_REFS is not within a DO loop or " "BLOCK ENTRY scope"); } zzCONSUME; { zzBLOCK(zztasp2); zzMake0; { if ( (LA(1)==46) ) { lvalues = parser_list_paren_comma_exprs( context.pgm.symtab() ); } zzEXIT(zztasp2); } } zzmatch(1); if (a != 0) list_absorb(a->arg_list_guarded(), lvalues); else delete lvalues; /// ... No assertion to stick these into zzCONSUME; zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "PRIVATE_REFS directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd9, 0x80); } } void #ifdef __STDC__ parser_csrd_induction( ParserContext &context ) #else parser_csrd_induction(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { Expression *comma_ex = 0; AssertInduction *a = 0; zzmatch(84); a = new AssertInduction; context.s_prev.assertions().ins_last( a ); zzCONSUME; { zzBLOCK(zztasp2); zzMake0; { if ( (LA(1)==F_NUM_CONST || LA(1)==APOST_CHAR_CST || LA(1)==QUOTE_CHAR_CST || LA(1)==33 || LA(1)==41 || LA(1)==42 || LA(1)==46 || LA(1)==50 || LA(1)==51 || LA(1)==FORTRAN_ID) ) { comma_ex = parser_comma_expr( context.pgm.symtab() ); } zzEXIT(zztasp2); } } zzmatch(1); if (a != 0) a->arg_list_guarded().ins_last(comma_ex); else delete comma_ex; /// ... No assertion to stick these into zzCONSUME; zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "INDUCTION directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd10, 0x1); } } void #ifdef __STDC__ parser_csrd_parcondition( ParserContext &context ) #else parser_csrd_parcondition(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { Expression *expr = 0; AssertParallelCondition *a = 0; zzmatch(85); a = new AssertParallelCondition; context.s_next.assertions().ins_last( a ); zzCONSUME; { zzBLOCK(zztasp2); zzMake0; { if ( (LA(1)==F_NUM_CONST || LA(1)==APOST_CHAR_CST || LA(1)==QUOTE_CHAR_CST || LA(1)==33 || LA(1)==41 || LA(1)==42 || LA(1)==46 || LA(1)==50 || LA(1)==51 || LA(1)==FORTRAN_ID) ) { expr = parser_expression( context.pgm.symtab() ); } zzEXIT(zztasp2); } } zzmatch(1); if (a != 0) a->arg_list_guarded().ins_last(expr); else delete expr; /// ... No assertion to stick these into zzCONSUME; zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "PARALLEL CONDITION directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd10, 0x2); } } void #ifdef __STDC__ parser_csrd_nomod( ParserContext &context ) #else parser_csrd_nomod(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { ExpressionList *lvalues = 0; Statement *s = 0; AssertNoMod *a = 0; zzmatch(86); a = new AssertNoMod; context.s_next.assertions().ins_last( a ); zzCONSUME; { zzBLOCK(zztasp2); zzMake0; { if ( (LA(1)==F_NUM_CONST || LA(1)==APOST_CHAR_CST || LA(1)==QUOTE_CHAR_CST || LA(1)==33 || LA(1)==41 || LA(1)==42 || LA(1)==46 || LA(1)==50 || LA(1)==51 || LA(1)==FORTRAN_ID) ) { lvalues = parser_lvalue_list_with_commas( context.pgm.symtab() ); } zzEXIT(zztasp2); } } zzmatch(1); if (a != 0) list_absorb(a->arg_list_guarded(), lvalues); else delete lvalues; /// ... No assertion to stick these into zzCONSUME; zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "NOMOD directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd10, 0x4); } } void #ifdef __STDC__ parser_csrd_maymod( ParserContext &context ) #else parser_csrd_maymod(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { ExpressionList *lvalues = 0; Statement *s = 0; AssertMayMod *a = 0; zzmatch(87); a = new AssertMayMod; context.s_next.assertions().ins_last( a ); zzCONSUME; { zzBLOCK(zztasp2); zzMake0; { if ( (LA(1)==F_NUM_CONST || LA(1)==APOST_CHAR_CST || LA(1)==QUOTE_CHAR_CST || LA(1)==33 || LA(1)==41 || LA(1)==42 || LA(1)==46 || LA(1)==50 || LA(1)==51 || LA(1)==FORTRAN_ID) ) { lvalues = parser_lvalue_list_with_commas( context.pgm.symtab() ); } zzEXIT(zztasp2); } } zzmatch(1); if (a != 0) list_absorb(a->arg_list_guarded(), lvalues); else delete lvalues; /// ... No assertion to stick these into zzCONSUME; zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "MAYMOD directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd10, 0x8); } } ExpressionList * #ifdef __STDC__ parser_list_paren_comma_exprs( Symtab &symtab ) #else parser_list_paren_comma_exprs(symtab) Symtab &symtab ; #endif { ExpressionList * _retv; zzRULE; zzBLOCK(zztasp1); zzMake0; { Expression *e = 0; _retv = new ExpressionList; { zzBLOCK(zztasp2); zzMake0; { e = parser_paren_comma_expr( symtab ); _retv->ins_last(e); { zzBLOCK(zztasp3); zzMake0; { while ( (LA(1)==48) ) { zzmatch(48); zzCONSUME; e = parser_paren_comma_expr( symtab ); _retv->ins_last(e); zzLOOP(zztasp3); } zzEXIT(zztasp3); } } zzEXIT(zztasp2); } } zzEXIT(zztasp1); return _retv; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "list of parenthesized comma expressions", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd10, 0x10); return _retv; } } Expression * #ifdef __STDC__ parser_paren_comma_expr( Symtab &symtab ) #else parser_paren_comma_expr(symtab) Symtab &symtab ; #endif { Expression * _retv; zzRULE; zzBLOCK(zztasp1); zzMake0; { Expression *e2 = 0; { zzBLOCK(zztasp2); zzMake0; { zzmatch(46); zzCONSUME; e2 = parser_comma_expr( symtab ); zzmatch(47); zzCONSUME; zzEXIT(zztasp2); } } if (e2) _retv = paren(e2); zzEXIT(zztasp1); return _retv; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "parenthesized comma-list", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd10, 0x20); return _retv; } } Expression * #ifdef __STDC__ parser_comma_expr( Symtab &symtab ) #else parser_comma_expr(symtab) Symtab &symtab ; #endif { Expression * _retv; zzRULE; zzBLOCK(zztasp1); zzMake0; { ExpressionList *list = new ExpressionList; Expression *e2; { zzBLOCK(zztasp2); zzMake0; { e2 = parser_expression( symtab ); list->ins_last(e2); { zzBLOCK(zztasp3); zzMake0; { while ( (LA(1)==48) ) { zzmatch(48); zzCONSUME; e2 = parser_expression( symtab ); list->ins_last(e2); zzLOOP(zztasp3); } zzEXIT(zztasp3); } } zzEXIT(zztasp2); } } _retv = comma(list); list = 0; zzEXIT(zztasp1); return _retv; fail: zzEXIT(zztasp1); if (list) { delete list; } zzsyn(zzMissText, zzBadTok, "Comma expression", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd10, 0x40); return _retv; } } void #ifdef __STDC__ parser_csrd_readonlyrefs( ParserContext &context ) #else parser_csrd_readonlyrefs(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { ExpressionList *lvalues = 0; Statement *s = 0; AssertReadOnlyRefs *a = 0; zzmatch(88); a = 0; s = enclosing_scope( context.s_next ); if (s != 0) { a = new AssertReadOnlyRefs; s->assertions().ins_last( a ); } else { parse_error("READ_ONLY_REFS is not within a DO loop or " "BLOCK ENTRY scope"); } zzCONSUME; { zzBLOCK(zztasp2); zzMake0; { if ( ( LA(1)==46) ) { lvalues = parser_list_paren_comma_exprs( context.pgm.symtab() ); } zzEXIT(zztasp2); } } zzmatch(1); if (a != 0) list_absorb(a->arg_list_guarded(), lvalues); else delete lvalues; /// ... No assertion to stick these into zzCONSUME; zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "READONLY_REFS directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd10, 0x80); } } void #ifdef __STDC__ parser_csrd_sharedrefs( ParserContext &context ) #else parser_csrd_sharedrefs(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { ExpressionList *lvalues = 0; Statement *s = 0; AssertSharedRefs *a = 0; zzmatch(89); a = 0; s = enclosing_scope( context.s_next ); if (s != 0) { a = new AssertSharedRefs; s->assertions().ins_last( a ); } else { parse_error("SHARED_REFS is not within a DO loop or " "BLOCK ENTRY scope"); } zzCONSUME; { zzBLOCK(zztasp2); zzMake0; { if ( (LA(1)==46) ) { lvalues = parser_list_paren_comma_exprs( context.pgm.symtab() ); } zzEXIT(zztasp2); } } zzmatch(1); if (a != 0) list_absorb(a->arg_list_guarded(), lvalues); else delete lvalues; /// ... No assertion to stick these into zzCONSUME; zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "SHARED_REFS directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd11, 0x1); } } void #ifdef __STDC__ parser_csrd_begin( ParserContext &context ) #else parser_csrd_begin(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { zzmatch(90); zzCONSUME; { zzBLOCK(zztasp2); zzMake0; { if ( (LA(1)==57) ) { parser_csrd_begin_block( context ); } else { if ( (LA(1)==56) ) { parser_csrd_begin_parallel( context ); } else {zzFAIL(1,zzerr14,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;} } zzEXIT(zztasp2); } } zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "CSRD BEGIN directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd11, 0x2); } } void #ifdef __STDC__ parser_csrd_end( ParserContext &context ) #else parser_csrd_end(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { zzmatch(91); zzCONSUME; { zzBLOCK(zztasp2); zzMake0; { if ( (LA(1)==57) ) { parser_csrd_end_block( context ); } else { if ( ( LA(1)==56) ) { parser_csrd_end_parallel( context ); } else {zzFAIL(1,zzerr15,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;} } zzEXIT(zztasp2); } } zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "CSRD END directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd11, 0x4); } } void #ifdef __STDC__ parser_csrd_begin_parallel( ParserContext &context ) #else parser_csrd_begin_parallel(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { parser_generic_begin_parallel( context ); zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "CSRD BEGIN PARALLEL directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd11, 0x8); } } void #ifdef __STDC__ parser_csrd_end_parallel( ParserContext &context ) #else parser_csrd_end_parallel(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { parser_generic_end_parallel( context ); zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "CSRD END PARALLEL directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd11, 0x10); } } void #ifdef __STDC__ parser_csrd_begin_block( ParserContext &context ) #else parser_csrd_begin_block(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { parser_generic_begin_block( context ); zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "CSRD BEGIN BLOCK directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd11, 0x20); } } void #ifdef __STDC__ parser_csrd_end_block( ParserContext &context ) #else parser_csrd_end_block(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { parser_generic_end_block( context ); zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "CSRD END BLOCK directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd11, 0x40); } } void #ifdef __STDC__ parser_csrd_last_value( ParserContext &context ) #else parser_csrd_last_value(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { parser_generic_last_value( context ); zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "CSRD LAST VALUE directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd11, 0x80); } } void #ifdef __STDC__ parser_csrd_first_value( ParserContext &context ) #else parser_csrd_first_value(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { parser_generic_first_value( context ); zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "CSRD FIRST VALUE directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd12, 0x1); } } void #ifdef __STDC__ parser_csrd_forward( ParserContext &context ) #else parser_csrd_forward(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { parser_generic_forward( context ); zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "CSRD FORWARD directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd12, 0x2); } } void #ifdef __STDC__ parser_csrd_parallel( ParserContext &context ) #else parser_csrd_parallel(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { parser_generic_parallel( context ); zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd12, 0x4); } } void #ifdef __STDC__ parser_csrd_reduction( ParserContext &context ) #else parser_csrd_reduction(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { parser_generic_reduction( context ); zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd12, 0x8); } } void #ifdef __STDC__ parser_csrd_shared( ParserContext &context ) #else parser_csrd_shared(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { parser_generic_shared( context ); zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd12, 0x10); } } void #ifdef __STDC__ parser_convex_directive( ParserContext &context ) #else parser_convex_directive(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { { zzBLOCK(zztasp2); zzMake0; { if ( (LA(1)==92) ) { parser_convex_private( context ); } else { if ( (LA(1)==90) ) { parser_convex_begin( context ); } else { if ( (LA(1)==91) ) { parser_convex_end( context ); } else { if ( (LA(1)==70) ) { parser_convex_last_value( context ); } else { if ( ( LA(1)==93) ) { parser_convex_parallel( context ); } else { if ( (LA(1)==77) ) { parser_convex_reduction( context ); } else {zzFAIL(1,zzerr16,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;} } } } } } zzEXIT(zztasp2); } } zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "Convex directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd12, 0x20); } } void #ifdef __STDC__ parser_convex_private( ParserContext &context ) #else parser_convex_private(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { ExpressionList *lvalues = 0; Statement *s = 0; AssertPrivate *a = 0; zzmatch(92); a = 0; if (context.s_next.stmt_class() == DO_STMT) s = &context.s_next; if (s == 0) parse_error("DO_PRIVATE is not before a DO loop"); else { /// ... Search for an existing PRIVATE assertion a = (AssertPrivate *) assertion_of_type( s->assertions(), AS_PRIVATE ); if (a == 0) { a = new AssertPrivate; s->assertions().ins_last( a ); } } zzCONSUME; { zzBLOCK(zztasp2); zzMake0; { if ( (LA(1)==46) ) { zzmatch(46); zzCONSUME; lvalues = parser_lvalue_list_with_commas( context.pgm.symtab() ); zzmatch(47); zzCONSUME; } zzEXIT(zztasp2); } } zzmatch(1); if (a != 0) list_absorb(a->arg_list_guarded(), lvalues); else delete lvalues; /// ... No assertion to stick these into zzCONSUME; zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "Convex PRIVATE directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd12, 0x40); } } void #ifdef __STDC__ parser_convex_begin( ParserContext &context ) #else parser_convex_begin(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { zzmatch(90); zzCONSUME; { zzBLOCK(zztasp2); zzMake0; { if ( (LA(1)==57) ) { parser_convex_begin_block( context ); } else { if ( (LA(1)==56) ) { parser_convex_begin_parallel( context ); } else {zzFAIL(1,zzerr17,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;} } zzEXIT(zztasp2); } } zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "Convex BEGIN directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd12, 0x80); } } void #ifdef __STDC__ parser_convex_end( ParserContext &context ) #else parser_convex_end(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { zzmatch(91); zzCONSUME; { zzBLOCK(zztasp2); zzMake0; { if ( ( LA(1)==57) ) { parser_convex_end_block( context ); } else { if ( (LA(1)==56) ) { parser_convex_end_parallel( context ); } else {zzFAIL(1,zzerr18,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;} } zzEXIT(zztasp2); } } zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "Convex END directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd13, 0x1); } } void #ifdef __STDC__ parser_convex_begin_parallel( ParserContext &context ) #else parser_convex_begin_parallel(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { parser_generic_begin_parallel( context ); zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "Convex BEGIN PARALLEL directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd13, 0x2); } } void #ifdef __STDC__ parser_convex_end_parallel( ParserContext &context ) #else parser_convex_end_parallel(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { parser_generic_end_parallel( context ); zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "Convex END PARALLEL directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd13, 0x4); } } void #ifdef __STDC__ parser_convex_begin_block( ParserContext &context ) #else parser_convex_begin_block(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { parser_generic_begin_block( context ); zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "Convex BEGIN BLOCK directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd13, 0x8); } } void #ifdef __STDC__ parser_convex_end_block( ParserContext &context ) #else parser_convex_end_block(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { parser_generic_end_block( context ); zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "Convex END BLOCK directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd13, 0x10); } } void #ifdef __STDC__ parser_convex_last_value( ParserContext &context ) #else parser_convex_last_value(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { parser_generic_last_value( context ); zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "Convex LAST VALUE directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd13, 0x20); } } void #ifdef __STDC__ parser_convex_parallel( ParserContext &context ) #else parser_convex_parallel(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { zzmatch(93); zzCONSUME; zzmatch(1); force_parallel(context, 0, "FORCE_PARALLEL"); zzCONSUME; zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "Convex FORCE_PARALLEL directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd13, 0x40); } } void #ifdef __STDC__ parser_convex_reduction( ParserContext &context ) #else parser_convex_reduction(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { parser_generic_reduction( context ); zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "Convex REDUCTION directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd13, 0x80); } } void #ifdef __STDC__ parser_sgi_directive( ParserContext &context ) #else parser_sgi_directive(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { parser_sgi_doacross( context ); zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "SGI directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd14, 0x1); } } void #ifdef __STDC__ parser_sgi_doacross( ParserContext &context ) #else parser_sgi_doacross(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { ExpressionList *pri_values = 0; ExpressionList *red_values = 0; ExpressionList *shr_values = 0; ExpressionList *las_values = 0; Expression *if_clause = 0; Statement *s = 0; if (context.s_next.stmt_class() == DO_STMT) s = &context.s_next; { zzBLOCK(zztasp2); zzMake0; { while ( 1 ) { if ( (LA(1)==48) ) { { zzBLOCK(zztasp3); zzMake0; { zzmatch(48); zzCONSUME; zzEXIT(zztasp3); } } } else { if ( (LA(1)==94) ) { { zzBLOCK(zztasp3); zzMake0; { zzmatch(94); zzCONSUME; zzmatch(46); zzCONSUME; las_values = parser_lvalue_list_with_commas( context.pgm.symtab() ); zzmatch(47); zzCONSUME; zzEXIT(zztasp3); } } } else { if ( (LA(1)==95) ) { { zzBLOCK(zztasp3); zzMake0; { zzmatch(95); zzCONSUME; zzmatch(46); zzCONSUME; pri_values = parser_lvalue_list_with_commas( context.pgm.symtab() ); zzmatch(47); zzCONSUME; zzEXIT(zztasp3); } } } else { if ( ( LA(1)==96) ) { { zzBLOCK(zztasp3); zzMake0; { zzmatch(96); zzCONSUME; zzmatch(46); zzCONSUME; shr_values = parser_lvalue_list_with_commas( context.pgm.symtab() ); zzmatch(47); zzCONSUME; zzEXIT(zztasp3); } } } else { if ( (LA(1)==97) ) { { zzBLOCK(zztasp3); zzMake0; { zzmatch(97); zzCONSUME; zzmatch(46); zzCONSUME; if_clause = parser_expression( context.pgm.symtab() ); zzmatch(47); zzCONSUME; zzEXIT(zztasp3); } } } else { if ( (LA(1)==77) ) { { zzBLOCK(zztasp3); zzMake0; { zzmatch(77); zzCONSUME; zzmatch(46); zzCONSUME; red_values = parser_lvalue_list_with_commas( context.pgm.symtab() ); zzmatch(47); zzCONSUME; zzEXIT(zztasp3); } } } else break; } } } } } zzLOOP(zztasp2); } zzEXIT(zztasp2); } } zzmatch(1); if (s == 0) parse_error("C$DOACROSS is not before a DO loop"); else { AssertParallel *a_par = (AssertParallel *) assertion_of_type(s->assertions(), AS_PARALLEL); if (a_par == 0) { a_par = new AssertParallel; a_par->arg_list_guarded().ins_first( s->index().clone() ); s->assertions().ins_last( a_par ); } AssertPrivate *a_pri = (AssertPrivate *) assertion_of_type(s->assertions(), AS_PRIVATE); if (a_pri == 0 && (pri_values != 0 || las_values != 0)) { a_pri = new AssertPrivate; s->assertions().ins_last( a_pri ); } AssertShared *a_shr = (AssertShared *) assertion_of_type(s->assertions(), AS_SHARED); if (a_shr == 0 && (shr_values != 0)) { a_shr = new AssertShared; s->assertions().ins_last( a_shr ); } AssertReduction *a_red = (AssertReduction *) assertion_of_type(s->assertions(), AS_REDUCTION); if (a_red == 0 && (red_values != 0)) { a_red = new AssertReduction; s->assertions().ins_last( a_red ); } AssertParallelCondition *a_parcon = (AssertParallelCondition *) assertion_of_type(s->assertions(), AS_PARCONDITION); if (a_parcon == 0 && (if_clause != 0)) { a_parcon = new AssertParallelCondition; s->assertions().ins_last( a_parcon ); } AssertLastValue *a_las = (AssertLastValue *) assertion_of_type(s->assertions(), AS_LASTVALUE); if (a_las == 0 && (las_values != 0)) { a_las = new AssertLastValue; s->assertions().ins_last( a_las ); } if (las_values != 0) { list_absorb(a_pri->arg_list_guarded(), (ExpressionList *)las_values->listable_clone()); list_absorb(a_las->arg_list_guarded(), las_values); } if (red_values != 0) list_absorb(a_red->arg_list_guarded(), red_values); if (if_clause != 0) a_parcon->arg_list_guarded().ins_last(if_clause); if (shr_values != 0) list_absorb(a_shr->arg_list_guarded(), shr_values); if (pri_values != 0) list_absorb(a_pri->arg_list_guarded(), pri_values); } zzCONSUME; zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "SGI DOACROSS directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd14, 0x2); } } void #ifdef __STDC__ parser_cray_directive( ParserContext &context ) #else parser_cray_directive(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { if ( (LA(1)==78) ) { parser_cray_shared( context ); } else { if ( (LA(1)==98) ) { parser_cray_private( context ); } else {zzFAIL(1,zzerr19,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;} } zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "CRAY directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd14, 0x4); } } void #ifdef __STDC__ parser_distr_expression( int dim, DistributeExpr *e ) #else parser_distr_expression(dim,e) int dim; DistributeExpr *e ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { Expression *ew = 0; Expression *eb = 0; int block = 0; { zzBLOCK(zztasp2); zzMake0; { if ( ( LA(1)==F_NUM_CONST) ) { zzmatch(F_NUM_CONST); ew = constant(zzaArg(zztasp2,1 ).text); /// ... Must be a integer if (ew->type().data_type() != INTEGER_TYPE) { delete ew; p_abort("Distribution must be a integer"); } zzCONSUME; } zzEXIT(zztasp2); } } zzmatch(49); zzCONSUME; { zzBLOCK(zztasp2); zzMake0; { if ( (LA(1)==57) ) { zzmatch(57); block = 1; zzCONSUME; { zzBLOCK(zztasp3); zzMake0; { if ( (LA(1)==46) ) { zzmatch(46); zzCONSUME; zzmatch(F_NUM_CONST); zzCONSUME; zzmatch(47); eb = constant(zzaArg(zztasp3,2 ).text); /// ... Must be a integer if (eb->type().data_type() != INTEGER_TYPE) { delete eb; p_abort("Distribution must be a integer"); } zzCONSUME; } zzEXIT(zztasp3); } } } zzEXIT(zztasp2); } } if (block) if (eb) { if (ew) { e->set_distribute(dim, CYCLIC_DISTR, ew->value(), eb->value()); delete ew; } else e->set_distribute(dim, CYCLIC_DISTR, 1, eb->value()); delete eb; } else if (ew) { e->set_distribute(dim, BLOCK_DISTR, ew->value()); delete ew; } else e->set_distribute(dim, BLOCK_DISTR, 1); else if (ew) { delete ew; p_abort("Degenerate Distribution can't have weight"); } else e->set_distribute(dim, DEGEN_DISTR); zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "Each Distribution Expression", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd14, 0x8); } } DistributeExpr * #ifdef __STDC__ parser_distr_expression_list(void) #else parser_distr_expression_list() #endif { DistributeExpr * _retv; zzRULE; zzBLOCK(zztasp1); zzMake0; { int dim = 1; _retv = new DistributeExpr; parser_distr_expression( dim, _retv ); dim++; { zzBLOCK(zztasp2); zzMake0; { while ( (LA(1)==48) ) { zzmatch(48); zzCONSUME; parser_distr_expression( dim, _retv ); dim++; zzLOOP(zztasp2); } zzEXIT(zztasp2); } } zzEXIT(zztasp1); return _retv; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "Distribution Expression List", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd14, 0x10); return _retv; } } ExpressionList * #ifdef __STDC__ parser_cray_shared_expr_list( Symtab &symtab ) #else parser_cray_shared_expr_list(symtab) Symtab &symtab ; #endif { ExpressionList * _retv; zzRULE; zzBLOCK(zztasp1); zzMake0; { Expression *e_id = 0; DistributeExpr *e_dist = 0; _retv = new ExpressionList; e_id = parser_sym_ref( symtab ); { zzBLOCK(zztasp2); zzMake0; { if ( (LA(1)==46) ) { zzmatch(46); zzCONSUME; e_dist = parser_distr_expression_list(); zzmatch(47); zzCONSUME; } zzEXIT(zztasp2); } } append_shared_data_objects(e_id, e_dist, _retv); { zzBLOCK(zztasp2); zzMake0; { while ( ( LA(1)==48) ) { zzmatch(48); e_id = 0; e_dist = 0; zzCONSUME; e_id = parser_sym_ref( symtab ); { zzBLOCK(zztasp3); zzMake0; { if ( (LA(1)==46) ) { zzmatch(46); zzCONSUME; e_dist = parser_distr_expression_list(); zzmatch(47); zzCONSUME; } zzEXIT(zztasp3); } } append_shared_data_objects(e_id, e_dist, _retv); zzLOOP(zztasp2); } zzEXIT(zztasp2); } } zzEXIT(zztasp1); return _retv; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "Cray Shared object Expression list", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd14, 0x20); return _retv; } } void #ifdef __STDC__ parser_cray_shared( ParserContext &context ) #else parser_cray_shared(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { ExpressionList *list = 0; Statement *s = 0; AssertShared *a = 0; zzmatch(78); s = &context.pgm.stmts().first(); a = (AssertShared *) assertion_of_type( s->assertions(), AS_SHARED ); if (a == 0) { a = new AssertShared; s->assertions().ins_last( a ); } zzCONSUME; list = parser_cray_shared_expr_list( context.pgm.symtab() ); zzmatch(1); list_absorb(a->arg_list_guarded(), list); zzCONSUME; zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "CRAY SHARED directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd14, 0x40); } } ExpressionList * #ifdef __STDC__ parser_cray_private_expr_list( Symtab &symtab ) #else parser_cray_private_expr_list(symtab) Symtab &symtab ; #endif { ExpressionList * _retv; zzRULE; zzBLOCK(zztasp1); zzMake0; { Expression *e_id = 0; _retv = new ExpressionList; e_id = parser_sym_ref( symtab ); /// ... e_id must be a private scalar id expression /// ... p_assert((e_id && is_scalar_var(*e_id)), /// ... "Illegal private scalar name"); p_assert((e_id && e_id->op() == ID_OP), "Illegal cray private symbol declaration"); _retv->ins_last(e_id); { zzBLOCK(zztasp2); zzMake0; { while ( (LA(1)==48) ) { zzmatch(48); e_id = 0; zzCONSUME; e_id = parser_sym_ref( symtab ); p_assert((e_id && e_id->op() == ID_OP), "Illegal cray private symbol declaration"); /// ... p_assert((e_id && is_scalar_var(*e_id)), /// ... "Illegal private scalar name"); _retv->ins_last(e_id); zzLOOP(zztasp2); } zzEXIT(zztasp2); } } zzEXIT(zztasp1); return _retv; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "Cray Private object Expression list", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd14, 0x80); return _retv; } } void #ifdef __STDC__ parser_cray_private( ParserContext &context ) #else parser_cray_private(context) ParserContext &context ; #endif { zzRULE; zzBLOCK(zztasp1); zzMake0; { ExpressionList *list = 0; Statement *s = 0; AssertPrivate*a = 0; zzmatch(98); s = &context.pgm.stmts().first(); a = (AssertPrivate *) assertion_of_type( s->assertions(), AS_PRIVATE ); if (a == 0) { a = new AssertPrivate; s->assertions().ins_last( a ); } zzCONSUME; list = parser_cray_private_expr_list( context.pgm.symtab() ); zzmatch(1); list_absorb(a->arg_list_guarded(), list); zzCONSUME; zzEXIT(zztasp1); return; fail: zzEXIT(zztasp1); zzsyn(zzMissText, zzBadTok, "CRAY PE_PRIVATE directive", zzMissSet, zzMissTok, zzErrk, zzBadText); zzresynch(setwd15, 0x1); } }

© 1995-2005 University of Illinois, Urbana-Champaign. All rights reserved.  Fri Mar 25 23:06:01 2005