/* A Bison parser, made by GNU Bison 3.0.4. */ /* Bison implementation for Yacc-like parsers in C Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ /* As a special exception, you may create a larger work that contains part or all of the Bison parser skeleton and distribute that work under terms of your choice, so long as that work isn't itself a parser generator using the skeleton or a modified version thereof as a parser skeleton. Alternatively, if you modify or redistribute the parser skeleton itself, you may (at your option) remove this special exception, which will cause the skeleton and the resulting Bison output files to be licensed under the GNU General Public License without this special exception. This special exception was added by the Free Software Foundation in version 2.2 of Bison. */ /* C LALR(1) parser skeleton written by Richard Stallman, by simplifying the original so-called "semantic" parser. */ /* All symbols defined below should begin with yy or YY, to avoid infringing on user name space. This should be done even for local variables, as they might otherwise be expanded by user macros. There are some unavoidable exceptions within include files to define necessary library symbols; they are noted "INFRINGES ON USER NAME SPACE" below. */ /* Identify Bison output. */ #define YYBISON 1 /* Bison version. */ #define YYBISON_VERSION "3.0.4" /* Skeleton name. */ #define YYSKELETON_NAME "yacc.c" /* Pure parsers. */ #define YYPURE 0 /* Push parsers. */ #define YYPUSH 0 /* Pull parsers. */ #define YYPULL 1 /* Copy the first part of user declarations. */ #line 358 "gram1.y" /* yacc.c:339 */ #include #include "inc.h" #include "extern.h" #include "defines.h" #include "fdvm.h" #include "fm.h" /* We may use builtin alloca */ #include "compatible.h" #ifdef _NEEDALLOCAH_ # include #endif #define EXTEND_NODE 2 /* move the definition to h/ files. */ extern PTR_BFND global_bfnd, pred_bfnd; extern PTR_SYMB star_symb; extern PTR_SYMB global_list; extern PTR_TYPE global_bool; extern PTR_TYPE global_int; extern PTR_TYPE global_float; extern PTR_TYPE global_double; extern PTR_TYPE global_char; extern PTR_TYPE global_string; extern PTR_TYPE global_string_2; extern PTR_TYPE global_complex; extern PTR_TYPE global_dcomplex; extern PTR_TYPE global_gate; extern PTR_TYPE global_event; extern PTR_TYPE global_sequence; extern PTR_TYPE global_default; extern PTR_LABEL thislabel; extern PTR_CMNT comments, cur_comment; extern PTR_BFND last_bfnd; extern PTR_TYPE impltype[]; extern int nioctl; extern int maxdim; extern long yystno; /* statement label */ extern char stmtbuf[]; /* input buffer */ extern char *commentbuf; /* comments buffer from scanner */ extern PTR_BLOB head_blob; extern PTR_BLOB cur_blob; extern PTR_TYPE vartype; /* variable type */ extern int end_group; extern char saveall; extern int privateall; extern int needkwd; extern int implkwd; extern int opt_kwd_hedr; /* added for FORTRAN 90 */ extern PTR_LLND first_unresolved_call; extern PTR_LLND last_unresolved_call; extern int data_stat; extern char yyquote; extern int warn_all; extern int statement_kind; /* kind of statement: 1 - HPF-DVM-directive, 0 - Fortran statement*/ int extend_flag = 0; static int do_name_err; static int ndim; /* number of dimension */ /*!!! hpf */ static int explicit_shape; /* 1 if shape specification is explicit */ /* static int varleng;*/ /* variable size */ static int lastwasbranch = NO; /* set if last stmt was a branch stmt */ static int thiswasbranch = NO; /* set if this stmt is a branch stmt */ static PTR_SYMB type_var = SMNULL; static PTR_LLND stat_alloc = LLNULL; /* set if ALLOCATE/DEALLOCATE stmt has STAT-clause*/ /* static int subscripts_status = 0; */ static int type_options,type_opt; /* The various options used to declare a name - RECURSIVE, POINTER, OPTIONAL etc. */ static PTR_BFND module_scope; static int position = IN_OUTSIDE; static int attr_ndim; /* number of dimensions in DIMENSION (array_spec) attribute declaration */ static PTR_LLND attr_dims; /* low level representation of array_spec in DIMENSION (array_spec) attribute declarartion. */ static int in_vec = NO; /* set if processing array constructor */ #line 147 "gram1.tab.c" /* yacc.c:339 */ # ifndef YY_NULLPTR # if defined __cplusplus && 201103L <= __cplusplus # define YY_NULLPTR nullptr # else # define YY_NULLPTR 0 # endif # endif /* Enabling verbose error messages. */ #ifdef YYERROR_VERBOSE # undef YYERROR_VERBOSE # define YYERROR_VERBOSE 1 #else # define YYERROR_VERBOSE 0 #endif /* In a future release of Bison, this section will be replaced by #include "gram1.tab.h". */ #ifndef YY_YY_GRAM1_TAB_H_INCLUDED # define YY_YY_GRAM1_TAB_H_INCLUDED /* Debug traces. */ #ifndef YYDEBUG # define YYDEBUG 0 #endif #if YYDEBUG extern int yydebug; #endif /* Token type. */ #ifndef YYTOKENTYPE # define YYTOKENTYPE enum yytokentype { PERCENT = 1, AMPERSAND = 2, ASTER = 3, CLUSTER = 4, COLON = 5, COMMA = 6, DASTER = 7, DEFINED_OPERATOR = 8, DOT = 9, DQUOTE = 10, GLOBAL_A = 11, LEFTAB = 12, LEFTPAR = 13, MINUS = 14, PLUS = 15, POINT_TO = 16, QUOTE = 17, RIGHTAB = 18, RIGHTPAR = 19, AND = 20, DSLASH = 21, EQV = 22, EQ = 23, EQUAL = 24, FFALSE = 25, GE = 26, GT = 27, LE = 28, LT = 29, NE = 30, NEQV = 31, NOT = 32, OR = 33, TTRUE = 34, SLASH = 35, XOR = 36, REFERENCE = 37, AT = 38, ACROSS = 39, ALIGN_WITH = 40, ALIGN = 41, ALLOCATABLE = 42, ALLOCATE = 43, ARITHIF = 44, ASSIGNMENT = 45, ASSIGN = 46, ASSIGNGOTO = 47, ASYNCHRONOUS = 48, ASYNCID = 49, ASYNCWAIT = 50, BACKSPACE = 51, BAD_CCONST = 52, BAD_SYMBOL = 53, BARRIER = 54, BLOCKDATA = 55, BLOCK = 56, BOZ_CONSTANT = 57, BYTE = 58, CALL = 59, CASE = 60, CHARACTER = 61, CHAR_CONSTANT = 62, CHECK = 63, CLOSE = 64, COMMON = 65, COMPLEX = 66, COMPGOTO = 67, CONSISTENT_GROUP = 68, CONSISTENT_SPEC = 69, CONSISTENT_START = 70, CONSISTENT_WAIT = 71, CONSISTENT = 72, CONSTRUCT_ID = 73, CONTAINS = 74, CONTINUE = 75, CORNER = 76, CYCLE = 77, DATA = 78, DEALLOCATE = 79, HPF_TEMPLATE = 80, DEBUG = 81, DEFAULT_CASE = 82, DEFINE = 83, DERIVED = 84, DIMENSION = 85, DISTRIBUTE = 86, DOWHILE = 87, DOUBLEPRECISION = 88, DOUBLECOMPLEX = 89, DP_CONSTANT = 90, DVM_POINTER = 91, DYNAMIC = 92, ELEMENTAL = 93, ELSE = 94, ELSEIF = 95, ELSEWHERE = 96, ENDASYNCHRONOUS = 97, ENDDEBUG = 98, ENDINTERVAL = 99, ENDUNIT = 100, ENDDO = 101, ENDFILE = 102, ENDFORALL = 103, ENDIF = 104, ENDINTERFACE = 105, ENDMODULE = 106, ENDON = 107, ENDSELECT = 108, ENDTASK_REGION = 109, ENDTYPE = 110, ENDWHERE = 111, ENTRY = 112, EXIT = 113, EOLN = 114, EQUIVALENCE = 115, ERROR = 116, EXTERNAL = 117, F90 = 118, FIND = 119, FORALL = 120, FORMAT = 121, FUNCTION = 122, GATE = 123, GEN_BLOCK = 124, HEAP = 125, HIGH = 126, IDENTIFIER = 127, IMPLICIT = 128, IMPLICITNONE = 129, INCLUDE_TO = 130, INCLUDE = 131, INDEPENDENT = 132, INDIRECT_ACCESS = 133, INDIRECT_GROUP = 134, INDIRECT = 135, INHERIT = 136, INQUIRE = 137, INTERFACEASSIGNMENT = 138, INTERFACEOPERATOR = 139, INTERFACE = 140, INTRINSIC = 141, INTEGER = 142, INTENT = 143, INTERVAL = 144, INOUT = 145, IN = 146, INT_CONSTANT = 147, LABEL = 148, LABEL_DECLARE = 149, LET = 150, LOCALIZE = 151, LOGICAL = 152, LOGICALIF = 153, LOOP = 154, LOW = 155, MAXLOC = 156, MAX = 157, MAP = 158, MINLOC = 159, MIN = 160, MODULE_PROCEDURE = 161, MODULE = 162, MULT_BLOCK = 163, NAMEEQ = 164, NAMELIST = 165, NEW_VALUE = 166, NEW = 167, NULLIFY = 168, OCTAL_CONSTANT = 169, ONLY = 170, ON = 171, ON_DIR = 172, ONTO = 173, OPEN = 174, OPERATOR = 175, OPTIONAL = 176, OTHERWISE = 177, OUT = 178, OWN = 179, PARALLEL = 180, PARAMETER = 181, PAUSE = 182, PLAINDO = 183, PLAINGOTO = 184, POINTER = 185, POINTERLET = 186, PREFETCH = 187, PRINT = 188, PRIVATE = 189, PRODUCT = 190, PROGRAM = 191, PUBLIC = 192, PURE = 193, RANGE = 194, READ = 195, REALIGN_WITH = 196, REALIGN = 197, REAL = 198, REAL_CONSTANT = 199, RECURSIVE = 200, REDISTRIBUTE_NEW = 201, REDISTRIBUTE = 202, REDUCTION_GROUP = 203, REDUCTION_START = 204, REDUCTION_WAIT = 205, REDUCTION = 206, REMOTE_ACCESS_SPEC = 207, REMOTE_ACCESS = 208, REMOTE_GROUP = 209, RESET = 210, RESULT = 211, RETURN = 212, REWIND = 213, SAVE = 214, SECTION = 215, SELECT = 216, SEQUENCE = 217, SHADOW_ADD = 218, SHADOW_COMPUTE = 219, SHADOW_GROUP = 220, SHADOW_RENEW = 221, SHADOW_START_SPEC = 222, SHADOW_START = 223, SHADOW_WAIT_SPEC = 224, SHADOW_WAIT = 225, SHADOW = 226, STAGE = 227, STATIC = 228, STAT = 229, STOP = 230, SUBROUTINE = 231, SUM = 232, SYNC = 233, TARGET = 234, TASK = 235, TASK_REGION = 236, THEN = 237, TO = 238, TRACEON = 239, TRACEOFF = 240, TRUNC = 241, TYPE = 242, TYPE_DECL = 243, UNDER = 244, UNKNOWN = 245, USE = 246, VIRTUAL = 247, VARIABLE = 248, WAIT = 249, WHERE = 250, WHERE_ASSIGN = 251, WHILE = 252, WITH = 253, WRITE = 254, COMMENT = 255, WGT_BLOCK = 256, HPF_PROCESSORS = 257, IOSTAT = 258, ERR = 259, END = 260, OMPDVM_ATOMIC = 261, OMPDVM_BARRIER = 262, OMPDVM_COPYIN = 263, OMPDVM_COPYPRIVATE = 264, OMPDVM_CRITICAL = 265, OMPDVM_ONETHREAD = 266, OMPDVM_DO = 267, OMPDVM_DYNAMIC = 268, OMPDVM_ENDCRITICAL = 269, OMPDVM_ENDDO = 270, OMPDVM_ENDMASTER = 271, OMPDVM_ENDORDERED = 272, OMPDVM_ENDPARALLEL = 273, OMPDVM_ENDPARALLELDO = 274, OMPDVM_ENDPARALLELSECTIONS = 275, OMPDVM_ENDPARALLELWORKSHARE = 276, OMPDVM_ENDSECTIONS = 277, OMPDVM_ENDSINGLE = 278, OMPDVM_ENDWORKSHARE = 279, OMPDVM_FIRSTPRIVATE = 280, OMPDVM_FLUSH = 281, OMPDVM_GUIDED = 282, OMPDVM_LASTPRIVATE = 283, OMPDVM_MASTER = 284, OMPDVM_NOWAIT = 285, OMPDVM_NONE = 286, OMPDVM_NUM_THREADS = 287, OMPDVM_ORDERED = 288, OMPDVM_PARALLEL = 289, OMPDVM_PARALLELDO = 290, OMPDVM_PARALLELSECTIONS = 291, OMPDVM_PARALLELWORKSHARE = 292, OMPDVM_RUNTIME = 293, OMPDVM_SECTION = 294, OMPDVM_SECTIONS = 295, OMPDVM_SCHEDULE = 296, OMPDVM_SHARED = 297, OMPDVM_SINGLE = 298, OMPDVM_THREADPRIVATE = 299, OMPDVM_WORKSHARE = 300, OMPDVM_NODES = 301, OMPDVM_IF = 302, IAND = 303, IEOR = 304, IOR = 305, ACC_REGION = 306, ACC_END_REGION = 307, ACC_CHECKSECTION = 308, ACC_END_CHECKSECTION = 309, ACC_GET_ACTUAL = 310, ACC_ACTUAL = 311, ACC_TARGETS = 312, ACC_ASYNC = 313, ACC_HOST = 314, ACC_CUDA = 315, ACC_LOCAL = 316, ACC_INLOCAL = 317, ACC_CUDA_BLOCK = 318, ACC_ROUTINE = 319, ACC_TIE = 320, ACC_DECLARE = 321, BY = 322, IO_MODE = 323, CP_CREATE = 324, CP_LOAD = 325, CP_SAVE = 326, CP_WAIT = 327, FILES = 328, VARLIST = 329, STATUS = 330, EXITINTERVAL = 331, TEMPLATE_CREATE = 332, TEMPLATE_DELETE = 333, SPF_ANALYSIS = 334, SPF_PARALLEL = 335, SPF_TRANSFORM = 336, SPF_NOINLINE = 337, SPF_PARALLEL_REG = 338, SPF_END_PARALLEL_REG = 339, SPF_EXPAND = 340, SPF_FISSION = 341, SPF_SHRINK = 342, SPF_CHECKPOINT = 343, SPF_EXCEPT = 344, SPF_FILES_COUNT = 345, SPF_INTERVAL = 346, SPF_TIME = 347, SPF_ITER = 348, SPF_FLEXIBLE = 349, SPF_APPLY_REGION = 350, SPF_APPLY_FRAGMENT = 351, SPF_CODE_COVERAGE = 352, SPF_UNROLL = 353, SPF_MERGE = 354, SPF_COVER = 355, SPF_PROCESS_PRIVATE = 356, BINARY_OP = 359, UNARY_OP = 360 }; #endif /* Value type. */ #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED union YYSTYPE { #line 439 "gram1.y" /* yacc.c:355 */ int token; char charv; char *charp; PTR_BFND bf_node; PTR_LLND ll_node; PTR_SYMB symbol; PTR_TYPE data_type; PTR_HASH hash_entry; PTR_LABEL label; #line 560 "gram1.tab.c" /* yacc.c:355 */ }; typedef union YYSTYPE YYSTYPE; # define YYSTYPE_IS_TRIVIAL 1 # define YYSTYPE_IS_DECLARED 1 #endif extern YYSTYPE yylval; int yyparse (void); #endif /* !YY_YY_GRAM1_TAB_H_INCLUDED */ /* Copy the second part of user declarations. */ #line 649 "gram1.y" /* yacc.c:358 */ void add_scope_level(); void delete_beyond_scope_level(); PTR_HASH look_up_sym(); PTR_HASH just_look_up_sym(); PTR_HASH just_look_up_sym_in_scope(); PTR_HASH look_up_op(); PTR_SYMB make_constant(); PTR_SYMB make_scalar(); PTR_SYMB make_array(); PTR_SYMB make_pointer(); PTR_SYMB make_function(); PTR_SYMB make_external(); PTR_SYMB make_intrinsic(); PTR_SYMB make_procedure(); PTR_SYMB make_process(); PTR_SYMB make_program(); PTR_SYMB make_module(); PTR_SYMB make_common(); PTR_SYMB make_parallel_region(); PTR_SYMB make_derived_type(); PTR_SYMB make_local_entity(); PTR_SYMB make_global_entity(); PTR_TYPE make_type_node(); PTR_TYPE lookup_type(), make_type(); void process_type(); void process_interface(); void bind(); void late_bind_if_needed(); PTR_SYMB component(); PTR_SYMB lookup_type_symbol(); PTR_SYMB resolve_overloading(); PTR_BFND cur_scope(); PTR_BFND subroutine_call(); PTR_BFND process_call(); PTR_LLND deal_with_options(); PTR_LLND intrinsic_op_node(); PTR_LLND defined_op_node(); int is_substring_ref(); int is_array_section_ref(); PTR_LLND dim_expr(); PTR_BFND exit_stat(); PTR_BFND make_do(); PTR_BFND make_pardo(); PTR_BFND make_enddoall(); PTR_TYPE install_array(); PTR_SYMB install_entry(); void install_param_list(); PTR_LLND construct_entry_list(); void copy_sym_data(); PTR_LLND check_and_install(); PTR_HASH look_up(); PTR_BFND get_bfnd(); PTR_BLOB make_blob(); PTR_LABEL make_label(); PTR_LABEL make_label_node(); int is_interface_stat(); PTR_LLND make_llnd (); PTR_LLND make_llnd_label (); PTR_TYPE make_sa_type(); PTR_SYMB procedure_call(); PTR_BFND proc_list(); PTR_SYMB set_id_list(); PTR_LLND set_ll_list(); PTR_LLND add_to_lowLevelList(), add_to_lowList(); PTR_BFND set_stat_list() ; PTR_BLOB follow_blob(); PTR_SYMB proc_decl_init(); PTR_CMNT make_comment(); PTR_HASH correct_symtab(); char *copyn(); char *convic(); char *StringConcatenation(); int atoi(); PTR_BFND make_logif(); PTR_BFND make_if(); PTR_BFND make_forall(); void startproc(); void match_parameters(); void make_else(); void make_elseif(); void make_endif(); void make_elsewhere(); void make_elsewhere_mask(); void make_endwhere(); void make_endforall(); void make_endselect(); void make_extend(); void make_endextend(); void make_section(); void make_section_extend(); void doinclude(); void endproc(); void err(); void execerr(); void flline(); void warn(); void warn1(); void newprog(); void set_type(); void dclerr(); void enddcl(); void install_const(); void setimpl(); void copy_module_scope(); void delete_symbol(); void replace_symbol_in_expr(); long convci(); void set_expr_type(); void errstr(); void yyerror(); void set_blobs(); void make_loop(); void startioctl(); void endioctl(); void redefine_func_arg_type(); int isResultVar(); int yylex(); /* used by FORTRAN M */ PTR_BFND make_processdo(); PTR_BFND make_processes(); PTR_BFND make_endprocesses(); PTR_BFND make_endparallel();/*OMP*/ PTR_BFND make_parallel();/*OMP*/ PTR_BFND make_endsingle();/*OMP*/ PTR_BFND make_single();/*OMP*/ PTR_BFND make_endmaster();/*OMP*/ PTR_BFND make_master();/*OMP*/ PTR_BFND make_endordered();/*OMP*/ PTR_BFND make_ordered();/*OMP*/ PTR_BFND make_endcritical();/*OMP*/ PTR_BFND make_critical();/*OMP*/ PTR_BFND make_endsections();/*OMP*/ PTR_BFND make_sections();/*OMP*/ PTR_BFND make_ompsection();/*OMP*/ PTR_BFND make_endparallelsections();/*OMP*/ PTR_BFND make_parallelsections();/*OMP*/ PTR_BFND make_endworkshare();/*OMP*/ PTR_BFND make_workshare();/*OMP*/ PTR_BFND make_endparallelworkshare();/*OMP*/ PTR_BFND make_parallelworkshare();/*OMP*/ #line 722 "gram1.tab.c" /* yacc.c:358 */ #ifdef short # undef short #endif #ifdef YYTYPE_UINT8 typedef YYTYPE_UINT8 yytype_uint8; #else typedef unsigned char yytype_uint8; #endif #ifdef YYTYPE_INT8 typedef YYTYPE_INT8 yytype_int8; #else typedef signed char yytype_int8; #endif #ifdef YYTYPE_UINT16 typedef YYTYPE_UINT16 yytype_uint16; #else typedef unsigned short int yytype_uint16; #endif #ifdef YYTYPE_INT16 typedef YYTYPE_INT16 yytype_int16; #else typedef short int yytype_int16; #endif #ifndef YYSIZE_T # ifdef __SIZE_TYPE__ # define YYSIZE_T __SIZE_TYPE__ # elif defined size_t # define YYSIZE_T size_t # elif ! defined YYSIZE_T # include /* INFRINGES ON USER NAME SPACE */ # define YYSIZE_T size_t # else # define YYSIZE_T unsigned int # endif #endif #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) #ifndef YY_ # if defined YYENABLE_NLS && YYENABLE_NLS # if ENABLE_NLS # include /* INFRINGES ON USER NAME SPACE */ # define YY_(Msgid) dgettext ("bison-runtime", Msgid) # endif # endif # ifndef YY_ # define YY_(Msgid) Msgid # endif #endif #ifndef YY_ATTRIBUTE # if (defined __GNUC__ \ && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \ || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C # define YY_ATTRIBUTE(Spec) __attribute__(Spec) # else # define YY_ATTRIBUTE(Spec) /* empty */ # endif #endif #ifndef YY_ATTRIBUTE_PURE # define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__)) #endif #ifndef YY_ATTRIBUTE_UNUSED # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__)) #endif #if !defined _Noreturn \ && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112) # if defined _MSC_VER && 1200 <= _MSC_VER # define _Noreturn __declspec (noreturn) # else # define _Noreturn YY_ATTRIBUTE ((__noreturn__)) # endif #endif /* Suppress unused-variable warnings by "using" E. */ #if ! defined lint || defined __GNUC__ # define YYUSE(E) ((void) (E)) #else # define YYUSE(E) /* empty */ #endif #if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__ /* Suppress an incorrect diagnostic about yylval being uninitialized. */ # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ _Pragma ("GCC diagnostic push") \ _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\ _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") # define YY_IGNORE_MAYBE_UNINITIALIZED_END \ _Pragma ("GCC diagnostic pop") #else # define YY_INITIAL_VALUE(Value) Value #endif #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN # define YY_IGNORE_MAYBE_UNINITIALIZED_END #endif #ifndef YY_INITIAL_VALUE # define YY_INITIAL_VALUE(Value) /* Nothing. */ #endif #if ! defined yyoverflow || YYERROR_VERBOSE /* The parser invokes alloca or malloc; define the necessary symbols. */ # ifdef YYSTACK_USE_ALLOCA # if YYSTACK_USE_ALLOCA # ifdef __GNUC__ # define YYSTACK_ALLOC __builtin_alloca # elif defined __BUILTIN_VA_ARG_INCR # include /* INFRINGES ON USER NAME SPACE */ # elif defined _AIX # define YYSTACK_ALLOC __alloca # elif defined _MSC_VER # include /* INFRINGES ON USER NAME SPACE */ # define alloca _alloca # else # define YYSTACK_ALLOC alloca # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS # include /* INFRINGES ON USER NAME SPACE */ /* Use EXIT_SUCCESS as a witness for stdlib.h. */ # ifndef EXIT_SUCCESS # define EXIT_SUCCESS 0 # endif # endif # endif # endif # endif # ifdef YYSTACK_ALLOC /* Pacify GCC's 'empty if-body' warning. */ # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) # ifndef YYSTACK_ALLOC_MAXIMUM /* The OS might guarantee only one guard page at the bottom of the stack, and a page size can be as small as 4096 bytes. So we cannot safely invoke alloca (N) if N exceeds 4096. Use a slightly smaller number to allow for a few compiler-allocated temporary stack slots. */ # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ # endif # else # define YYSTACK_ALLOC YYMALLOC # define YYSTACK_FREE YYFREE # ifndef YYSTACK_ALLOC_MAXIMUM # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM # endif # if (defined __cplusplus && ! defined EXIT_SUCCESS \ && ! ((defined YYMALLOC || defined malloc) \ && (defined YYFREE || defined free))) # include /* INFRINGES ON USER NAME SPACE */ # ifndef EXIT_SUCCESS # define EXIT_SUCCESS 0 # endif # endif # ifndef YYMALLOC # define YYMALLOC malloc # if ! defined malloc && ! defined EXIT_SUCCESS void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ # endif # endif # ifndef YYFREE # define YYFREE free # if ! defined free && ! defined EXIT_SUCCESS void free (void *); /* INFRINGES ON USER NAME SPACE */ # endif # endif # endif #endif /* ! defined yyoverflow || YYERROR_VERBOSE */ #if (! defined yyoverflow \ && (! defined __cplusplus \ || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) /* A type that is properly aligned for any stack member. */ union yyalloc { yytype_int16 yyss_alloc; YYSTYPE yyvs_alloc; }; /* The size of the maximum gap between one aligned stack and the next. */ # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) /* The size of an array large to enough to hold all stacks, each with N elements. */ # define YYSTACK_BYTES(N) \ ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ + YYSTACK_GAP_MAXIMUM) # define YYCOPY_NEEDED 1 /* Relocate STACK from its old location to the new one. The local variables YYSIZE and YYSTACKSIZE give the old and new number of elements in the stack, and YYPTR gives the new location of the stack. Advance YYPTR to a properly aligned location for the next stack. */ # define YYSTACK_RELOCATE(Stack_alloc, Stack) \ do \ { \ YYSIZE_T yynewbytes; \ YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ Stack = &yyptr->Stack_alloc; \ yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ yyptr += yynewbytes / sizeof (*yyptr); \ } \ while (0) #endif #if defined YYCOPY_NEEDED && YYCOPY_NEEDED /* Copy COUNT objects from SRC to DST. The source and destination do not overlap. */ # ifndef YYCOPY # if defined __GNUC__ && 1 < __GNUC__ # define YYCOPY(Dst, Src, Count) \ __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src))) # else # define YYCOPY(Dst, Src, Count) \ do \ { \ YYSIZE_T yyi; \ for (yyi = 0; yyi < (Count); yyi++) \ (Dst)[yyi] = (Src)[yyi]; \ } \ while (0) # endif # endif #endif /* !YYCOPY_NEEDED */ /* YYFINAL -- State number of the termination state. */ #define YYFINAL 2 /* YYLAST -- Last index in YYTABLE. */ #define YYLAST 5948 /* YYNTOKENS -- Number of terminals. */ #define YYNTOKENS 361 /* YYNNTS -- Number of nonterminals. */ #define YYNNTS 547 /* YYNRULES -- Number of rules. */ #define YYNRULES 1312 /* YYNSTATES -- Number of states. */ #define YYNSTATES 2613 /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned by yylex, with out-of-bounds checking. */ #define YYUNDEFTOK 2 #define YYMAXUTOK 360 #define YYTRANSLATE(YYX) \ ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM as returned by yylex, without out-of-bounds checking. */ static const yytype_uint16 yytranslate[] = { 0, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 1, 2, 359, 360 }; #if YYDEBUG /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ static const yytype_uint16 yyrline[] = { 0, 796, 796, 797, 801, 803, 817, 848, 857, 863, 883, 892, 908, 920, 930, 937, 943, 948, 953, 977, 1004, 1018, 1020, 1022, 1026, 1043, 1057, 1081, 1097, 1111, 1129, 1131, 1138, 1142, 1143, 1150, 1151, 1159, 1160, 1162, 1166, 1167, 1171, 1175, 1181, 1191, 1195, 1200, 1207, 1208, 1209, 1210, 1211, 1212, 1213, 1214, 1215, 1216, 1217, 1218, 1219, 1220, 1221, 1226, 1231, 1238, 1240, 1241, 1242, 1243, 1244, 1245, 1246, 1247, 1248, 1249, 1250, 1251, 1254, 1258, 1266, 1274, 1283, 1291, 1295, 1297, 1301, 1303, 1305, 1307, 1309, 1311, 1313, 1315, 1317, 1319, 1321, 1323, 1325, 1327, 1329, 1331, 1333, 1335, 1340, 1349, 1359, 1367, 1377, 1398, 1418, 1419, 1421, 1425, 1427, 1431, 1435, 1437, 1441, 1447, 1451, 1453, 1457, 1461, 1465, 1469, 1473, 1479, 1483, 1487, 1493, 1498, 1505, 1516, 1529, 1540, 1553, 1563, 1576, 1581, 1588, 1591, 1596, 1601, 1608, 1611, 1621, 1635, 1638, 1657, 1684, 1686, 1698, 1706, 1707, 1708, 1709, 1710, 1711, 1712, 1717, 1718, 1722, 1724, 1731, 1736, 1737, 1739, 1741, 1754, 1760, 1766, 1775, 1784, 1797, 1798, 1801, 1805, 1820, 1835, 1853, 1874, 1894, 1916, 1933, 1951, 1958, 1965, 1972, 1985, 1992, 1999, 2010, 2014, 2016, 2021, 2039, 2050, 2062, 2074, 2088, 2094, 2101, 2107, 2113, 2121, 2128, 2144, 2147, 2156, 2158, 2162, 2166, 2186, 2190, 2192, 2196, 2197, 2200, 2202, 2204, 2206, 2208, 2211, 2214, 2218, 2224, 2228, 2232, 2234, 2239, 2240, 2244, 2248, 2250, 2254, 2256, 2258, 2263, 2267, 2269, 2271, 2274, 2276, 2277, 2278, 2279, 2280, 2281, 2282, 2283, 2286, 2287, 2293, 2296, 2297, 2299, 2303, 2304, 2307, 2308, 2310, 2314, 2315, 2316, 2317, 2319, 2322, 2323, 2332, 2334, 2341, 2348, 2355, 2364, 2366, 2368, 2372, 2374, 2378, 2387, 2394, 2401, 2403, 2407, 2411, 2417, 2419, 2424, 2428, 2432, 2439, 2446, 2456, 2458, 2462, 2474, 2477, 2486, 2499, 2505, 2511, 2517, 2525, 2535, 2537, 2541, 2543, 2576, 2578, 2582, 2621, 2622, 2626, 2626, 2631, 2635, 2643, 2652, 2661, 2671, 2677, 2680, 2682, 2686, 2694, 2709, 2716, 2718, 2722, 2738, 2738, 2742, 2744, 2756, 2758, 2762, 2768, 2780, 2792, 2809, 2838, 2839, 2847, 2848, 2852, 2854, 2856, 2867, 2871, 2877, 2879, 2883, 2885, 2887, 2891, 2893, 2897, 2899, 2901, 2903, 2905, 2907, 2909, 2911, 2913, 2915, 2917, 2919, 2921, 2923, 2925, 2927, 2929, 2931, 2933, 2935, 2937, 2939, 2941, 2945, 2946, 2957, 3031, 3043, 3045, 3049, 3180, 3230, 3274, 3316, 3374, 3376, 3378, 3417, 3460, 3471, 3472, 3476, 3481, 3482, 3486, 3488, 3494, 3496, 3502, 3515, 3521, 3528, 3534, 3542, 3550, 3566, 3576, 3589, 3596, 3598, 3621, 3623, 3625, 3627, 3629, 3631, 3633, 3635, 3639, 3639, 3639, 3653, 3655, 3678, 3680, 3682, 3698, 3700, 3702, 3716, 3719, 3721, 3729, 3731, 3733, 3735, 3789, 3809, 3824, 3833, 3836, 3886, 3892, 3897, 3915, 3917, 3919, 3921, 3923, 3926, 3932, 3934, 3936, 3939, 3941, 3943, 3970, 3979, 3988, 3989, 3991, 3996, 4003, 4011, 4013, 4017, 4020, 4022, 4026, 4032, 4034, 4036, 4038, 4042, 4044, 4053, 4054, 4061, 4062, 4066, 4070, 4091, 4094, 4098, 4100, 4107, 4112, 4113, 4124, 4136, 4159, 4184, 4185, 4192, 4194, 4196, 4198, 4200, 4204, 4281, 4293, 4300, 4302, 4303, 4305, 4314, 4321, 4328, 4336, 4341, 4346, 4349, 4352, 4355, 4358, 4361, 4365, 4383, 4388, 4407, 4426, 4430, 4431, 4434, 4438, 4443, 4450, 4452, 4454, 4458, 4459, 4470, 4485, 4489, 4496, 4499, 4509, 4522, 4535, 4538, 4540, 4543, 4546, 4550, 4559, 4562, 4566, 4568, 4574, 4578, 4580, 4582, 4589, 4593, 4595, 4599, 4601, 4605, 4624, 4640, 4649, 4658, 4660, 4664, 4690, 4705, 4720, 4737, 4745, 4754, 4762, 4767, 4772, 4794, 4810, 4812, 4816, 4818, 4825, 4827, 4829, 4833, 4835, 4837, 4839, 4841, 4843, 4847, 4850, 4853, 4859, 4865, 4874, 4878, 4885, 4887, 4891, 4893, 4895, 4900, 4905, 4910, 4915, 4924, 4929, 4935, 4936, 4951, 4952, 4953, 4954, 4955, 4956, 4957, 4958, 4959, 4960, 4961, 4962, 4963, 4964, 4965, 4966, 4967, 4968, 4969, 4972, 4973, 4974, 4975, 4976, 4977, 4978, 4979, 4980, 4981, 4982, 4983, 4984, 4985, 4986, 4987, 4988, 4989, 4990, 4991, 4992, 4993, 4994, 4995, 4996, 4997, 4998, 4999, 5000, 5001, 5002, 5003, 5004, 5005, 5006, 5007, 5008, 5009, 5010, 5011, 5012, 5013, 5014, 5015, 5019, 5021, 5032, 5053, 5057, 5059, 5063, 5076, 5080, 5082, 5086, 5097, 5108, 5112, 5114, 5118, 5120, 5122, 5137, 5149, 5169, 5189, 5211, 5217, 5226, 5234, 5240, 5248, 5255, 5261, 5270, 5274, 5280, 5288, 5302, 5316, 5321, 5337, 5352, 5380, 5382, 5386, 5388, 5392, 5421, 5444, 5465, 5466, 5470, 5491, 5493, 5497, 5505, 5509, 5514, 5516, 5518, 5520, 5526, 5528, 5532, 5542, 5546, 5548, 5553, 5555, 5559, 5563, 5569, 5579, 5581, 5585, 5587, 5589, 5596, 5614, 5615, 5619, 5621, 5625, 5632, 5642, 5671, 5686, 5693, 5711, 5713, 5717, 5731, 5757, 5770, 5786, 5788, 5791, 5793, 5799, 5803, 5831, 5833, 5837, 5845, 5851, 5854, 5912, 5976, 5978, 5981, 5985, 5989, 5993, 6010, 6022, 6026, 6030, 6040, 6045, 6050, 6057, 6066, 6066, 6077, 6088, 6090, 6094, 6105, 6109, 6111, 6115, 6126, 6130, 6132, 6136, 6148, 6150, 6157, 6159, 6163, 6179, 6187, 6198, 6200, 6204, 6207, 6212, 6222, 6224, 6228, 6230, 6239, 6240, 6244, 6246, 6251, 6252, 6253, 6254, 6255, 6256, 6257, 6258, 6259, 6260, 6261, 6264, 6269, 6273, 6277, 6281, 6294, 6298, 6302, 6306, 6309, 6311, 6313, 6317, 6319, 6323, 6327, 6329, 6333, 6338, 6342, 6346, 6348, 6352, 6361, 6364, 6370, 6377, 6380, 6382, 6386, 6388, 6392, 6404, 6406, 6410, 6414, 6416, 6420, 6422, 6424, 6426, 6428, 6430, 6432, 6436, 6440, 6444, 6448, 6452, 6459, 6465, 6470, 6473, 6476, 6489, 6491, 6495, 6497, 6502, 6508, 6514, 6520, 6526, 6532, 6538, 6544, 6550, 6559, 6565, 6582, 6584, 6592, 6600, 6602, 6606, 6610, 6612, 6616, 6618, 6626, 6630, 6642, 6645, 6663, 6665, 6669, 6671, 6675, 6677, 6681, 6685, 6689, 6698, 6702, 6706, 6711, 6715, 6727, 6729, 6733, 6738, 6742, 6744, 6748, 6750, 6754, 6759, 6766, 6789, 6791, 6793, 6795, 6797, 6801, 6812, 6816, 6831, 6838, 6845, 6846, 6850, 6854, 6862, 6866, 6870, 6878, 6883, 6897, 6899, 6903, 6905, 6914, 6916, 6918, 6920, 6956, 6960, 6964, 6968, 6972, 6984, 6986, 6990, 6993, 6995, 6999, 7004, 7011, 7014, 7022, 7026, 7031, 7033, 7040, 7045, 7049, 7053, 7057, 7061, 7065, 7068, 7070, 7074, 7076, 7078, 7082, 7086, 7098, 7100, 7104, 7106, 7110, 7113, 7116, 7120, 7126, 7138, 7140, 7144, 7146, 7150, 7158, 7170, 7171, 7173, 7177, 7181, 7183, 7191, 7195, 7198, 7200, 7204, 7208, 7210, 7211, 7212, 7213, 7214, 7215, 7216, 7217, 7218, 7219, 7220, 7221, 7222, 7223, 7224, 7225, 7226, 7227, 7228, 7229, 7230, 7231, 7232, 7233, 7234, 7235, 7238, 7244, 7250, 7256, 7262, 7266, 7272, 7273, 7274, 7275, 7276, 7277, 7278, 7279, 7280, 7283, 7288, 7293, 7299, 7305, 7311, 7316, 7322, 7328, 7334, 7341, 7347, 7353, 7360, 7364, 7366, 7372, 7379, 7385, 7391, 7397, 7403, 7409, 7415, 7421, 7427, 7433, 7439, 7445, 7455, 7460, 7466, 7470, 7476, 7477, 7478, 7479, 7482, 7490, 7496, 7502, 7507, 7513, 7520, 7526, 7530, 7536, 7537, 7538, 7539, 7540, 7541, 7544, 7553, 7557, 7563, 7570, 7577, 7584, 7593, 7599, 7605, 7609, 7615, 7616, 7619, 7625, 7631, 7635, 7642, 7643, 7646, 7652, 7658, 7663, 7671, 7677, 7682, 7689, 7693, 7699, 7700, 7701, 7702, 7703, 7704, 7705, 7706, 7707, 7708, 7709, 7713, 7718, 7723, 7730, 7735, 7741, 7747, 7752, 7757, 7762, 7766, 7771, 7776, 7780, 7785, 7789, 7795, 7800, 7806, 7811, 7817, 7827, 7831, 7835, 7839, 7845, 7848, 7852, 7853, 7855, 7856, 7857, 7858, 7859, 7860, 7863, 7867, 7871, 7873, 7875, 7879, 7881, 7883, 7887, 7889, 7893, 7895, 7899, 7902, 7905, 7910, 7912, 7914, 7916, 7918, 7922, 7926, 7931, 7935, 7937, 7941, 7943, 7947, 7951, 7955, 7960, 7962, 7966, 7976, 7981, 7982, 7986, 7988, 7992, 7994, 7997, 7998, 7999, 8000, 8001, 8002, 8005, 8009, 8013, 8017, 8019, 8021, 8025, 8027, 8031, 8036, 8037, 8042, 8043, 8047, 8051, 8053, 8057, 8058, 8059, 8060, 8061, 8064, 8068, 8072, 8076, 8080, 8083, 8085, 8089, 8093, 8095, 8099, 8100, 8101, 8104, 8108, 8112, 8116, 8118, 8122, 8124, 8126, 8128, 8131, 8133, 8135, 8137, 8141, 8148, 8152, 8154, 8158, 8162, 8164, 8168, 8170, 8172, 8174, 8176, 8180, 8182, 8186, 8188, 8192, 8194, 8199 }; #endif #if YYDEBUG || YYERROR_VERBOSE || 0 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. First, the terminals, then, starting at YYNTOKENS, nonterminals. */ static const char *const yytname[] = { "$end", "error", "$undefined", "PERCENT", "AMPERSAND", "ASTER", "CLUSTER", "COLON", "COMMA", "DASTER", "DEFINED_OPERATOR", "DOT", "DQUOTE", "GLOBAL_A", "LEFTAB", "LEFTPAR", "MINUS", "PLUS", "POINT_TO", "QUOTE", "RIGHTAB", "RIGHTPAR", "AND", "DSLASH", "EQV", "EQ", "EQUAL", "FFALSE", "GE", "GT", "LE", "LT", "NE", "NEQV", "NOT", "OR", "TTRUE", "SLASH", "XOR", "REFERENCE", "AT", "ACROSS", "ALIGN_WITH", "ALIGN", "ALLOCATABLE", "ALLOCATE", "ARITHIF", "ASSIGNMENT", "ASSIGN", "ASSIGNGOTO", "ASYNCHRONOUS", "ASYNCID", "ASYNCWAIT", "BACKSPACE", "BAD_CCONST", "BAD_SYMBOL", "BARRIER", "BLOCKDATA", "BLOCK", "BOZ_CONSTANT", "BYTE", "CALL", "CASE", "CHARACTER", "CHAR_CONSTANT", "CHECK", "CLOSE", "COMMON", "COMPLEX", "COMPGOTO", "CONSISTENT_GROUP", "CONSISTENT_SPEC", "CONSISTENT_START", "CONSISTENT_WAIT", "CONSISTENT", "CONSTRUCT_ID", "CONTAINS", "CONTINUE", "CORNER", "CYCLE", "DATA", "DEALLOCATE", "HPF_TEMPLATE", "DEBUG", "DEFAULT_CASE", "DEFINE", "DERIVED", "DIMENSION", "DISTRIBUTE", "DOWHILE", "DOUBLEPRECISION", "DOUBLECOMPLEX", "DP_CONSTANT", "DVM_POINTER", "DYNAMIC", "ELEMENTAL", "ELSE", "ELSEIF", "ELSEWHERE", "ENDASYNCHRONOUS", "ENDDEBUG", "ENDINTERVAL", "ENDUNIT", "ENDDO", "ENDFILE", "ENDFORALL", "ENDIF", "ENDINTERFACE", "ENDMODULE", "ENDON", "ENDSELECT", "ENDTASK_REGION", "ENDTYPE", "ENDWHERE", "ENTRY", "EXIT", "EOLN", "EQUIVALENCE", "ERROR", "EXTERNAL", "F90", "FIND", "FORALL", "FORMAT", "FUNCTION", "GATE", "GEN_BLOCK", "HEAP", "HIGH", "IDENTIFIER", "IMPLICIT", "IMPLICITNONE", "INCLUDE_TO", "INCLUDE", "INDEPENDENT", "INDIRECT_ACCESS", "INDIRECT_GROUP", "INDIRECT", "INHERIT", "INQUIRE", "INTERFACEASSIGNMENT", "INTERFACEOPERATOR", "INTERFACE", "INTRINSIC", "INTEGER", "INTENT", "INTERVAL", "INOUT", "IN", "INT_CONSTANT", "LABEL", "LABEL_DECLARE", "LET", "LOCALIZE", "LOGICAL", "LOGICALIF", "LOOP", "LOW", "MAXLOC", "MAX", "MAP", "MINLOC", "MIN", "MODULE_PROCEDURE", "MODULE", "MULT_BLOCK", "NAMEEQ", "NAMELIST", "NEW_VALUE", "NEW", "NULLIFY", "OCTAL_CONSTANT", "ONLY", "ON", "ON_DIR", "ONTO", "OPEN", "OPERATOR", "OPTIONAL", "OTHERWISE", "OUT", "OWN", "PARALLEL", "PARAMETER", "PAUSE", "PLAINDO", "PLAINGOTO", "POINTER", "POINTERLET", "PREFETCH", "PRINT", "PRIVATE", "PRODUCT", "PROGRAM", "PUBLIC", "PURE", "RANGE", "READ", "REALIGN_WITH", "REALIGN", "REAL", "REAL_CONSTANT", "RECURSIVE", "REDISTRIBUTE_NEW", "REDISTRIBUTE", "REDUCTION_GROUP", "REDUCTION_START", "REDUCTION_WAIT", "REDUCTION", "REMOTE_ACCESS_SPEC", "REMOTE_ACCESS", "REMOTE_GROUP", "RESET", "RESULT", "RETURN", "REWIND", "SAVE", "SECTION", "SELECT", "SEQUENCE", "SHADOW_ADD", "SHADOW_COMPUTE", "SHADOW_GROUP", "SHADOW_RENEW", "SHADOW_START_SPEC", "SHADOW_START", "SHADOW_WAIT_SPEC", "SHADOW_WAIT", "SHADOW", "STAGE", "STATIC", "STAT", "STOP", "SUBROUTINE", "SUM", "SYNC", "TARGET", "TASK", "TASK_REGION", "THEN", "TO", "TRACEON", "TRACEOFF", "TRUNC", "TYPE", "TYPE_DECL", "UNDER", "UNKNOWN", "USE", "VIRTUAL", "VARIABLE", "WAIT", "WHERE", "WHERE_ASSIGN", "WHILE", "WITH", "WRITE", "COMMENT", "WGT_BLOCK", "HPF_PROCESSORS", "IOSTAT", "ERR", "END", "OMPDVM_ATOMIC", "OMPDVM_BARRIER", "OMPDVM_COPYIN", "OMPDVM_COPYPRIVATE", "OMPDVM_CRITICAL", "OMPDVM_ONETHREAD", "OMPDVM_DO", "OMPDVM_DYNAMIC", "OMPDVM_ENDCRITICAL", "OMPDVM_ENDDO", "OMPDVM_ENDMASTER", "OMPDVM_ENDORDERED", "OMPDVM_ENDPARALLEL", "OMPDVM_ENDPARALLELDO", "OMPDVM_ENDPARALLELSECTIONS", "OMPDVM_ENDPARALLELWORKSHARE", "OMPDVM_ENDSECTIONS", "OMPDVM_ENDSINGLE", "OMPDVM_ENDWORKSHARE", "OMPDVM_FIRSTPRIVATE", "OMPDVM_FLUSH", "OMPDVM_GUIDED", "OMPDVM_LASTPRIVATE", "OMPDVM_MASTER", "OMPDVM_NOWAIT", "OMPDVM_NONE", "OMPDVM_NUM_THREADS", "OMPDVM_ORDERED", "OMPDVM_PARALLEL", "OMPDVM_PARALLELDO", "OMPDVM_PARALLELSECTIONS", "OMPDVM_PARALLELWORKSHARE", "OMPDVM_RUNTIME", "OMPDVM_SECTION", "OMPDVM_SECTIONS", "OMPDVM_SCHEDULE", "OMPDVM_SHARED", "OMPDVM_SINGLE", "OMPDVM_THREADPRIVATE", "OMPDVM_WORKSHARE", "OMPDVM_NODES", "OMPDVM_IF", "IAND", "IEOR", "IOR", "ACC_REGION", "ACC_END_REGION", "ACC_CHECKSECTION", "ACC_END_CHECKSECTION", "ACC_GET_ACTUAL", "ACC_ACTUAL", "ACC_TARGETS", "ACC_ASYNC", "ACC_HOST", "ACC_CUDA", "ACC_LOCAL", "ACC_INLOCAL", "ACC_CUDA_BLOCK", "ACC_ROUTINE", "ACC_TIE", "ACC_DECLARE", "BY", "IO_MODE", "CP_CREATE", "CP_LOAD", "CP_SAVE", "CP_WAIT", "FILES", "VARLIST", "STATUS", "EXITINTERVAL", "TEMPLATE_CREATE", "TEMPLATE_DELETE", "SPF_ANALYSIS", "SPF_PARALLEL", "SPF_TRANSFORM", "SPF_NOINLINE", "SPF_PARALLEL_REG", "SPF_END_PARALLEL_REG", "SPF_EXPAND", "SPF_FISSION", "SPF_SHRINK", "SPF_CHECKPOINT", "SPF_EXCEPT", "SPF_FILES_COUNT", "SPF_INTERVAL", "SPF_TIME", "SPF_ITER", "SPF_FLEXIBLE", "SPF_APPLY_REGION", "SPF_APPLY_FRAGMENT", "SPF_CODE_COVERAGE", "SPF_UNROLL", "SPF_MERGE", "SPF_COVER", "SPF_PROCESS_PRIVATE", "BINARY_OP", "UNARY_OP", "$accept", "program", "stat", "thislabel", "entry", "new_prog", "proc_attr", "procname", "funcname", "typedfunc", "opt_result_clause", "name", "progname", "blokname", "arglist", "args", "arg", "filename", "needkeyword", "keywordoff", "keyword_if_colon_follow", "spec", "interface", "defined_op", "operator", "intrinsic_op", "type_dcl", "end_type", "dcl", "options", "attr_spec_list", "attr_spec", "intent_spec", "access_spec", "intent", "optional", "static", "private", "private_attr", "sequence", "public", "public_attr", "type", "opt_key_hedr", "attrib", "att_type", "typespec", "typename", "lengspec", "proper_lengspec", "selector", "clause", "end_ioctl", "initial_value", "dimension", "allocatable", "pointer", "target", "common", "namelist", "namelist_group", "comblock", "var", "external", "intrinsic", "equivalence", "equivset", "equivlist", "equi_object", "data", "data1", "data_in", "in_data", "datapair", "datalvals", "datarvals", "datalval", "data_null", "d_name", "dataname", "datasubs", "datarange", "iconexprlist", "opticonexpr", "dataimplieddo", "dlist", "dataelt", "datarval", "datavalue", "BOZ_const", "int_const", "unsignedint", "real_const", "unsignedreal", "complex_const_data", "complex_part", "iconexpr", "iconterm", "iconfactor", "iconprimary", "savelist", "saveitem", "use_name_list", "use_key_word", "no_use_key_word", "use_name", "paramlist", "paramitem", "module_proc_stmt", "proc_name_list", "use_stat", "module_name", "only_list", "only_name", "rename_list", "rename_name", "dims", "dimlist", "$@1", "dim", "ubound", "labellist", "label", "implicit", "implist", "impitem", "imptype", "$@2", "type_implicit", "letgroups", "letgroup", "letter", "inside", "in_dcl", "opt_double_colon", "funarglist", "funarg", "funargs", "subscript_list", "expr", "uexpr", "addop", "ident", "lhs", "array_ele_substring_func_ref", "structure_component", "array_element", "asubstring", "opt_substring", "substring", "opt_expr", "simple_const", "numeric_bool_const", "integer_constant", "string_constant", "complex_const", "kind", "triplet", "vec", "$@3", "$@4", "allocate_object", "allocation_list", "allocate_object_list", "stat_spec", "pointer_name_list", "exec", "do_while", "opt_while", "plain_do", "case", "case_selector", "case_value_range", "case_value_range_list", "opt_construct_name", "opt_unit_name", "construct_name", "construct_name_colon", "logif", "forall", "forall_list", "forall_expr", "opt_forall_cond", "do_var", "dospec", "dotarget", "whereable", "iffable", "let", "goto", "opt_comma", "call", "callarglist", "callarg", "stop", "end_spec", "intonlyon", "intonlyoff", "io", "iofmove", "fmkwd", "iofctl", "ctlkwd", "inquire", "infmt", "ioctl", "ctllist", "ioclause", "nameeq", "read", "write", "print", "inlist", "inelt", "outlist", "out2", "other", "in_ioctl", "start_ioctl", "fexpr", "unpar_fexpr", "cmnt", "dvm_specification", "dvm_exec", "dvm_template", "template_obj", "dvm_dynamic", "dyn_array_name_list", "dyn_array_name", "dvm_inherit", "dummy_array_name_list", "dummy_array_name", "dvm_shadow", "shadow_attr_stuff", "sh_width_list", "sh_width", "sh_array_name", "dvm_processors", "dvm_indirect_group", "indirect_group_name", "dvm_remote_group", "remote_group_name", "dvm_reduction_group", "reduction_group_name", "dvm_consistent_group", "consistent_group_name", "opt_onto", "dvm_distribute", "dvm_redistribute", "dist_name_list", "distributee", "dist_name", "pointer_ar_elem", "processors_name", "opt_dist_format_clause", "dist_format_clause", "dist_format_list", "opt_key_word", "dist_format", "array_name", "derived_spec", "derived_elem_list", "derived_elem", "target_spec", "derived_target", "derived_subscript_list", "derived_subscript", "dummy_ident", "opt_plus_shadow", "plus_shadow", "shadow_id", "shadow_width", "dvm_align", "dvm_realign", "realignee_list", "alignee", "realignee", "align_directive_stuff", "align_base", "align_subscript_list", "align_subscript", "align_base_name", "dim_ident_list", "dim_ident", "dvm_combined_dir", "dvm_attribute_list", "dvm_attribute", "dvm_pointer", "dimension_list", "$@5", "pointer_var_list", "pointer_var", "dvm_heap", "heap_array_name_list", "heap_array_name", "dvm_consistent", "consistent_array_name_list", "consistent_array_name", "dvm_asyncid", "async_id_list", "async_id", "dvm_new_value", "dvm_parallel_on", "ident_list", "opt_on", "distribute_cycles", "par_subscript_list", "par_subscript", "opt_spec", "spec_list", "par_spec", "remote_access_spec", "consistent_spec", "consistent_group", "new_spec", "private_spec", "cuda_block_spec", "sizelist", "variable_list", "tie_spec", "tied_array_list", "indirect_access_spec", "stage_spec", "across_spec", "in_out_across", "opt_keyword_in_out", "opt_in_out", "dependent_array_list", "dependent_array", "dependence_list", "dependence", "section_spec_list", "section_spec", "ar_section", "low_section", "high_section", "section", "reduction_spec", "opt_key_word_r", "no_opt_key_word_r", "reduction_group", "reduction_list", "reduction", "reduction_op", "loc_op", "shadow_spec", "shadow_group_name", "shadow_list", "shadow", "opt_corner", "array_ident", "array_ident_list", "dvm_shadow_start", "dvm_shadow_wait", "dvm_shadow_group", "dvm_reduction_start", "dvm_reduction_wait", "dvm_consistent_start", "dvm_consistent_wait", "dvm_remote_access", "group_name", "remote_data_list", "remote_data", "remote_index_list", "remote_index", "dvm_task", "task_array", "dvm_task_region", "task_name", "dvm_end_task_region", "task", "dvm_on", "opt_private_spec", "dvm_end_on", "dvm_map", "dvm_prefetch", "dvm_reset", "dvm_indirect_access", "indirect_list", "indirect_reference", "hpf_independent", "hpf_reduction_spec", "dvm_asynchronous", "dvm_endasynchronous", "dvm_asyncwait", "async_ident", "async", "dvm_f90", "dvm_debug_dir", "debparamlist", "debparam", "fragment_number", "dvm_enddebug_dir", "dvm_interval_dir", "interval_number", "dvm_exit_interval_dir", "dvm_endinterval_dir", "dvm_traceon_dir", "dvm_traceoff_dir", "dvm_barrier_dir", "dvm_check", "dvm_io_mode_dir", "mode_list", "mode_spec", "dvm_shadow_add", "template_ref", "shadow_axis_list", "shadow_axis", "opt_include_to", "dvm_localize", "localize_target", "target_subscript_list", "target_subscript", "aster_expr", "dvm_cp_create", "opt_mode", "dvm_cp_load", "dvm_cp_save", "dvm_cp_wait", "dvm_template_create", "template_list", "dvm_template_delete", "omp_specification_directive", "omp_execution_directive", "ompdvm_onethread", "omp_parallel_end_directive", "omp_parallel_begin_directive", "parallel_clause_list", "parallel_clause", "omp_variable_list_in_par", "ompprivate_clause", "ompfirstprivate_clause", "omplastprivate_clause", "ompcopyin_clause", "ompshared_clause", "ompdefault_clause", "def_expr", "ompif_clause", "ompnumthreads_clause", "ompreduction_clause", "ompreduction", "ompreduction_vars", "ompreduction_op", "omp_sections_begin_directive", "sections_clause_list", "sections_clause", "omp_sections_end_directive", "omp_section_directive", "omp_do_begin_directive", "omp_do_end_directive", "do_clause_list", "do_clause", "ompordered_clause", "ompschedule_clause", "ompschedule_op", "omp_single_begin_directive", "single_clause_list", "single_clause", "omp_single_end_directive", "end_single_clause_list", "end_single_clause", "ompcopyprivate_clause", "ompnowait_clause", "omp_workshare_begin_directive", "omp_workshare_end_directive", "omp_parallel_do_begin_directive", "paralleldo_clause_list", "paralleldo_clause", "omp_parallel_do_end_directive", "omp_parallel_sections_begin_directive", "omp_parallel_sections_end_directive", "omp_parallel_workshare_begin_directive", "omp_parallel_workshare_end_directive", "omp_threadprivate_directive", "omp_master_begin_directive", "omp_master_end_directive", "omp_ordered_begin_directive", "omp_ordered_end_directive", "omp_barrier_directive", "omp_atomic_directive", "omp_flush_directive", "omp_critical_begin_directive", "omp_critical_end_directive", "omp_common_var", "omp_variable_list", "op_slash_1", "op_slash_0", "acc_specification", "acc_directive", "acc_region", "acc_checksection", "acc_get_actual", "acc_actual", "opt_clause", "acc_clause_list", "acc_clause", "data_clause", "targets_clause", "async_clause", "acc_var_list", "computer_list", "computer", "acc_end_region", "acc_end_checksection", "acc_declare", "acc_declare_list", "declare_var", "acc_routine", "opt_routine_clauses", "routine_clause_list", "routine_clause", "spf_directive", "spf_analysis", "spf_parallel", "spf_transform", "spf_parallel_reg", "characteristic_list", "characteristic", "opt_clause_apply_fragment", "opt_clause_apply_region", "spf_end_parallel_reg", "analysis_spec_list", "analysis_spec", "analysis_reduction_spec", "analysis_private_spec", "analysis_process_private_spec", "analysis_cover_spec", "analysis_parameter_spec", "spf_parameter_list", "spf_parameter", "parallel_spec_list", "parallel_spec", "parallel_shadow_spec", "parallel_across_spec", "parallel_remote_access_spec", "transform_spec_list", "transform_spec", "unroll_list", "region_name", "array_element_list", "spf_checkpoint", "checkpoint_spec_list", "checkpoint_spec", "spf_type_list", "spf_type", "interval_spec", "in_unit", YY_NULLPTR }; #endif # ifdef YYPRINT /* YYTOKNUM[NUM] -- (External) token number corresponding to the (internal) symbol number NUM (which must be that of a token). */ static const yytype_uint16 yytoknum[] = { 0, 357, 358, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 359, 360 }; # endif #define YYPACT_NINF -2221 #define yypact_value_is_default(Yystate) \ (!!((Yystate) == (-2221))) #define YYTABLE_NINF -1192 #define yytable_value_is_error(Yytable_value) \ (!!((Yytable_value) == (-1192))) /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing STATE-NUM. */ static const yytype_int16 yypact[] = { -2221, 112, -2221, -2221, -2221, -2221, 31, 5201, -2221, -2221, -2221, 162, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, 251, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, 64, -2221, -2221, 635, 200, -2221, -2221, -2221, 64, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, 204, 204, -2221, -2221, -2221, -2221, -2221, 204, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, 168, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, 204, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, 263, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, 372, 424, -2221, -2221, -2221, -2221, -2221, 64, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, 64, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, 236, 1028, 505, 236, -2221, -2221, -2221, 543, 553, 564, 637, -2221, -2221, -2221, 605, 669, 204, -2221, -2221, 683, 686, 726, 782, 603, 198, 805, 816, 827, -2221, 153, -2221, -2221, -2221, 236, -2221, -2221, -2221, 591, 45, 2068, 2354, -2221, -2221, 3071, -2221, 828, -2221, -2221, 1774, -2221, 863, -2221, -2221, 858, 863, 880, -2221, -2221, 884, -2221, -2221, -2221, 902, 910, 917, 920, 927, -2221, -2221, -2221, -2221, 934, 708, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, 956, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, 159, 204, 981, 1091, 1105, 923, 204, 204, 164, 204, -2221, 204, 204, 1113, -2221, 567, 1130, 204, 204, 204, 204, -2221, -2221, 204, -2221, 1134, 204, 982, 204, 993, -2221, -2221, -2221, 204, -2221, 1136, 204, -2221, 204, 1154, 304, -2221, 982, -2221, 204, 204, 204, 204, -2221, -2221, -2221, -2221, -2221, 204, -2221, 204, 204, 505, 204, 1158, 981, 204, 1169, -2221, 204, 204, -2221, -2221, -2221, 1146, 1194, 204, 204, -2221, 1206, 1210, 204, 981, 1212, 3071, -2221, 1215, 1217, 204, -2221, 1228, 204, 1140, -2221, 1227, 204, 981, 1239, 1241, -2221, 923, 981, 204, 204, 1782, 63, 204, 83, -2221, -2221, 309, -2221, 466, 204, 204, 204, 1244, 204, 204, 3071, 110, -2221, -2221, 1248, 204, 204, 204, 204, 204, 2589, 204, -2221, 981, 204, 981, 204, 204, -2221, -2221, 204, -2221, 981, 204, 1250, 1253, -2221, 204, -2221, -2221, 1255, -2221, -2221, 1324, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, 1328, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, 204, -2221, -2221, 1331, 1361, 1272, 981, 1366, 3071, 3071, 3071, 3071, 3071, 1382, 1388, 1431, 1448, 1462, 204, -2221, 1466, -2221, -2221, -2221, -2221, 1177, 165, -2221, -2221, 204, 204, 204, 204, 1325, -2221, -2221, 1355, 204, 204, -2221, 636, 204, 204, 204, 204, 204, 290, 204, 1140, 204, 204, 1158, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, 1095, -2221, -2221, -2221, -2221, -2221, -2221, 3071, 3071, 3071, -2221, 3071, -2221, -2221, -2221, -2221, -2221, -2221, 3071, 3280, -2221, 103, 1452, -2221, 1467, -2221, 1237, 1240, 1473, -2221, -2221, 1474, 3071, -2221, -2221, 1511, -2221, -2221, 1475, 1550, 1452, -2221, -2221, 903, -8, -2221, 1511, -2221, -2221, -2221, 1491, 473, 93, 3087, 3087, 204, 204, 204, 204, 204, 204, 204, 1493, -2221, 204, -2221, -2221, -2221, 527, -2221, -2221, 1489, 204, -2221, 3071, -2221, 1268, 801, -2221, 1490, -2221, -2221, 1492, 1501, -2221, -2221, -2221, -2221, -2221, 2679, 204, 1495, -2221, 204, 1492, 204, -2221, 923, -2221, -2221, -2221, -2221, -2221, -2221, 1504, -2221, -2221, -2221, -2221, -2221, 1492, -2221, -2221, 1498, -2221, -2221, 700, 1224, 204, 737, 166, -2221, 1499, 1340, 3071, 1368, -2221, 1515, -2221, -2221, 3071, 3071, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, 204, -2221, 204, 1510, 658, 204, 505, -2221, -2221, 1521, -2221, 1522, -2221, 1516, 751, -2221, 1525, -2221, 204, -2221, -2221, -2221, 1527, -2221, 863, 1517, 3442, -2221, 204, -2221, 5910, -2221, 204, 3071, -2221, 1526, -2221, 204, -2221, 204, 204, 204, 1452, 958, 204, 204, 204, 1368, -2221, 204, 215, -2221, -2221, -2221, 1550, 903, -2221, -2221, -2221, -2221, -2221, -2221, 159, -2221, 1489, 1529, 1499, -2221, -2221, -2221, -2221, -2221, -2221, 204, -2221, -2221, -2221, 5910, -2221, 567, 1480, 204, -2221, 1530, -2221, -2221, -2221, -2221, 1531, 3521, 744, -2221, -2221, 263, 204, 505, -2221, 204, 1492, -2221, 1536, 1528, -2221, 204, -2221, 1543, 3071, 3071, -2221, 1492, 204, 123, 204, 1266, 1266, 149, 1266, -2221, 1539, 179, 180, 184, 190, 205, 212, -2221, 1492, 515, -2221, 1553, -2221, 183, 210, -2221, -2221, 1272, -2221, 204, -2221, 3654, 5910, 3754, 3794, 1554, 5910, 204, 204, -2221, -2221, -2221, -2221, 1560, -2221, 204, 204, -2221, -2221, -2221, -2221, 790, -2221, -2221, 1345, 1492, -2221, -2221, -2221, -2221, 1150, 204, -2221, -2221, -2221, -2221, -2221, -2221, -2221, 1492, -2221, -2221, -2221, -2221, 1561, -2221, 1561, -2221, -2221, -2221, -2221, 651, -2221, 480, -2221, 1555, -2221, -2221, 3828, 1564, 1567, 1567, 2164, -2221, 3071, 3071, 3071, 3071, 3071, 3071, 3071, 3071, 3071, 3071, 3071, 3071, 3071, 3071, 3071, 3071, 3071, 3071, 3071, -2221, 1509, 1408, 1563, 454, 525, 3071, -2221, -2221, -2221, 802, 1442, -2221, -2221, -2221, -2221, 831, -2221, 1373, 922, 3071, 1572, 1550, 1550, 1550, 1550, 1550, -2221, 1116, -2221, 473, 473, 1452, 1574, -2221, 3087, 5910, 91, 120, -2221, 1577, 1579, -2221, -2221, 1492, -2221, -2221, -2221, -2221, 1492, -2221, 416, -2221, 159, -2221, -2221, -2221, 204, 3869, 204, 1573, 3071, 1523, -2221, -2221, 204, -2221, 3071, 3908, -2221, 868, -2221, -2221, 1552, -2221, -2221, 876, -2221, 204, -2221, 204, -2221, -2221, 1224, -2221, -2221, -2221, -2221, -2221, 3942, 1492, -2221, -2221, -2221, 1580, 1581, 1583, 1584, 1585, 1586, -2221, 1340, -2221, 204, -2221, 4031, -2221, -2221, 204, 4065, 4099, -2221, 1587, 882, 1596, 1473, -2221, -2221, 204, -2221, 1602, -2221, 1566, -2221, 204, -2221, 1483, 90, -2221, -2221, -13, -2221, -2221, 1606, -2221, 1594, 1612, 885, -2221, 204, 3087, 1599, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, 1600, -2221, -2221, 430, 1603, 1604, 4136, 2695, -16, -2221, 1588, -2221, -2221, 890, -2221, -2221, -2221, -2221, -2221, 909, 1597, 925, -2221, -2221, -2221, 3071, -2221, 1162, -2221, -2221, -2221, 939, -2221, 1620, -2221, 1340, 1617, 1626, 954, -2221, -2221, -2221, 1630, -2221, 1619, 1629, 1632, 204, 3071, 3071, 2589, -2221, -2221, -2221, -2221, -2221, -2221, -2221, 1637, 1638, -2221, 308, -2221, -2221, 4190, 4221, -2221, 1645, -2221, 214, 1646, -2221, -2221, -2221, -2221, 220, -2221, -2221, -2221, 221, -2221, 389, 453, 481, -2221, 483, -2221, 506, -2221, 1644, 1653, 1654, 1655, -2221, 1657, 1658, -2221, -2221, -2221, -2221, -2221, -2221, 1452, 1670, 1659, -2221, 1661, -40, -2221, -2221, 1676, -2221, -4, 957, -2221, -2221, -2221, -2221, 3071, 436, 590, -2221, 959, 960, -56, 963, -2221, -2221, -2221, -2221, -2221, -2221, 95, 964, -2221, -2221, -2221, -2221, 514, 988, -2221, -2221, 435, 995, -2221, -2221, 505, 204, 186, -2221, 1671, -2221, 1680, -2221, 1492, -2221, -2221, -2221, 1672, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, 1032, -2221, -2221, -2221, 204, 1492, 150, 1601, -2221, -2221, 204, 204, -2221, 1267, 480, -2221, 1673, -2221, 1627, 3071, 3087, -2221, 3071, 1567, 1567, 611, 611, 2164, 985, 2300, 2643, 5910, 2643, 2643, 2643, 2643, 2643, 2300, 2134, 1567, 2134, 2900, 1563, -2221, -2221, 1669, 1684, 2548, -2221, -2221, -2221, -2221, -2221, 1687, -2221, -2221, 923, 5910, -2221, 3071, -2221, -2221, -2221, -2221, 5910, 87, 5910, 1572, 1572, 1125, 1572, 612, -2221, 1574, 1688, 473, 4269, 1689, 1690, 1692, 3087, 3087, 3087, -2221, -2221, 204, 1686, -2221, -2221, 1698, 1499, -2221, 263, -2221, -2221, -2221, -2221, 1447, -2221, 997, 923, -2221, 923, 1015, 1696, 1017, -2221, 5910, 3071, 2679, -2221, 1020, -2221, 923, 1561, -2221, 738, 846, -2221, 1027, 1538, 1041, -2221, 1790, -2221, 166, -2221, 1699, 204, 204, 3071, 204, -2221, -2221, 1492, -2221, -2221, -2221, 1456, 204, 3071, 204, -2221, 204, -2221, 1452, 3071, 1695, 2695, -2221, -2221, -2221, -2221, 1052, -2221, 1702, -2221, 1704, 1705, 1706, 1497, 3071, 204, 204, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, 981, 204, -2221, 2746, 3406, 1703, 204, 204, -2221, 204, -2221, 1532, 204, -2221, 3071, 204, -2221, 1561, 5910, -2221, 1717, 398, 1717, -2221, 204, 1340, 1719, 2778, 204, 204, -2221, 567, 3071, 812, 3071, 1056, -2221, 1712, 1067, 5910, -2221, 53, -2221, -2221, -2221, -2221, -2221, 981, 55, -2221, 204, -2221, 546, -2221, -2221, 51, -2221, 137, 597, -2221, 659, -2221, 598, -2221, -18, -2221, 204, 204, 204, -2221, 204, 204, 515, -2221, 204, -2221, -2221, 1713, -2221, 204, -2221, -2221, -2221, -2221, -2221, 1398, 1417, 1401, 5910, -2221, 1563, 204, -2221, -2221, 1723, 1727, 1730, 1731, 1733, -2221, -2221, 1737, 1738, 1740, -2221, -2221, -2221, 1741, 1747, 1748, 1749, -2221, -2221, -2221, 839, 1750, 1751, 1754, 1757, 1759, -2221, -2221, -2221, -2221, -2221, 204, 761, -2221, -2221, 1760, -2221, 1770, -2221, -2221, 1680, -2221, -2221, -2221, -2221, 5910, 2061, -2221, -2221, -2221, 508, 380, 380, 1488, 1535, -2221, -2221, 1540, 1546, 1548, 664, 204, -2221, -2221, -2221, -2221, 1777, -2221, -2221, -2221, 1673, -2221, 1795, -2221, 696, 1796, -2221, 1799, 4304, -2221, 1764, 1794, 1473, -2221, -2221, 4365, -2221, 3071, 3071, 1442, -2221, 5910, 1511, 473, -2221, 122, 3087, 3087, 3087, 125, -2221, 129, -2221, 155, -2221, 1492, 204, -2221, -2221, 1811, 1081, -2221, 1814, -2221, 5910, -2221, -2221, -2221, 3071, -2221, -2221, 3071, -2221, -2221, -2221, -2221, 5910, -2221, 1538, 3071, 1801, -2221, 1804, 1807, 4622, 1826, -2221, 130, 204, -2221, 1090, -2221, -2221, 1809, 5910, -2221, -2221, 4365, -2221, 1483, -2221, 1483, 204, 204, 204, 1101, 1115, -2221, 204, 1822, 1818, 3071, 4668, 3055, -2221, -2221, -2221, 1492, 1452, -2221, 1825, -2221, 1668, 1834, 5910, -2221, 204, -2221, 1828, 1829, -2221, -2221, 1592, 1841, -2221, -2221, 1843, -2221, 5910, 1119, -2221, 1127, -2221, -2221, 4699, -2221, -2221, 1139, -2221, -2221, 5910, 1830, 204, -2221, -2221, -2221, 1837, 1838, 1648, 1784, 204, 204, 1839, 1850, -2221, 699, -2221, 1844, -2221, -2221, -2221, 1845, -2221, -2221, -2221, -2221, -2221, -2221, -2221, 546, -2221, -2221, -2221, -2221, 51, 204, -2221, -2221, 1142, 1846, -2221, 1847, -2221, 1848, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, 597, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, 659, -2221, -2221, -2221, -2221, -2221, 598, -2221, -2221, -2221, -18, 1849, 1851, 1855, 886, 1149, -2221, 1856, 1857, 1452, 204, -2221, -2221, 1852, -2221, 1853, 1563, 1863, -2221, 204, 204, -2221, 1715, 204, -2221, 204, 204, 204, -2221, 204, 204, 204, 3071, -2221, 1866, 1870, -2221, 204, 204, 3071, -2221, -2221, 1871, 3071, 3071, -2221, -2221, 1873, -2221, 1726, 761, 2427, -2221, 1166, -2221, 5910, -2221, -2221, -2221, 1887, -2221, -2221, -2221, -2221, 454, 454, 454, 454, 454, 1267, -2221, 1881, 1893, 1884, 1267, 1796, -2221, 480, 696, 459, 459, -2221, -2221, -2221, 1167, 1858, 608, 235, -2221, 1892, 696, -2221, 3071, -2221, 1882, -2221, 1473, -2221, 2548, 5910, 1885, -2221, -2221, 903, 1879, 1886, 1168, 1889, 1891, 1894, -2221, -2221, -2221, 1899, 82, 923, -2221, 204, 981, 5910, 82, 5910, 1538, 3071, 1895, 4734, 1172, -2221, -2221, -2221, -2221, -2221, 3071, -2221, 1903, -2221, -2221, -2221, -2221, -2221, 1187, 1193, 1199, -2221, -2221, -2221, 992, -2221, 5910, 3071, 3071, 4769, -2221, 204, 204, -2221, -2221, 1834, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, 1902, 398, 1904, 3442, -2221, 204, 204, 204, 2778, -2221, -2221, -2221, 812, -2221, -2221, -2221, 1943, 204, -2221, -2221, 1839, 1900, -2221, -2221, 204, 204, 3071, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, 137, -2221, -2221, -2221, 3071, -2221, 3071, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, 1202, 204, 204, 1908, 851, 1906, 1203, -2221, 1205, 634, 1225, 1912, 1254, 1258, 1265, 1277, 1279, 1284, -2221, 1288, 4800, 1913, -2221, -2221, -114, 1289, -2221, 1298, 1299, 4836, 895, 1917, -2221, 5910, 5910, 1300, 1928, -2221, -2221, -2221, 1915, 4877, -2221, -2221, -2221, 508, -2221, -2221, -2221, -2221, -2221, -2221, 1267, -2221, 204, -2221, -2221, 1922, 1914, -2221, 843, 235, 235, 696, -2221, 696, 459, 459, 459, 459, 459, 1273, 4908, -2221, -2221, -2221, -2221, 3071, -2221, -2221, -2221, -2221, 1647, -2221, 204, 1930, 1501, 204, -2221, 204, -2221, 4969, -2221, 3071, 3071, -2221, 5004, 1693, 3071, -2221, -2221, -2221, -2221, 1303, -2221, -2221, 5910, 5910, 3071, 1309, 1926, -2221, 935, -2221, 3071, -2221, 1923, 1931, -2221, -2221, 1936, 1935, -2221, -2221, -2221, -2221, -2221, 1823, 1933, 1314, 1954, 1956, 1315, 1057, 204, -2221, -2221, 5910, 899, 1944, 21, -2221, -2221, 1927, -2221, -2221, 330, 5040, 5071, -2221, -2221, -2221, -2221, -2221, -2221, 1317, 1945, 1079, 3071, 204, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, 1952, 1953, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, 204, -2221, 3071, -2221, 1615, 1319, -2221, 1321, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, 3071, 1964, 1965, -2221, -2221, -2221, 1601, 1955, -2221, 1563, -2221, 696, -2221, 1273, 1957, 235, 235, -2221, -2221, -2221, -2221, 5140, -2221, 4365, -2221, 1363, -2221, -2221, 923, 1670, -2221, 1538, 5910, -2221, 1718, -2221, 1967, 5196, 992, -2221, 5910, -2221, 2462, 1969, 1971, 1973, 1974, 1978, 204, 204, 1979, 1980, 1981, 5535, -2221, -2221, -2221, 3071, 204, 204, -2221, -2221, 1983, 204, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, 1992, -2221, -2221, -2221, -2221, -2221, 1364, -2221, -2221, -2221, -2221, 1982, -2221, -2221, 1994, -2221, 5910, -2221, 204, 204, 634, -2221, 5566, -2221, -2221, 1998, 2000, -2221, 5597, -2221, 1993, -2221, -2221, 1988, 1383, 1273, -2221, 3071, 1647, -2221, -2221, 3071, 204, 3071, -2221, -2221, -2221, 5910, 1391, -2221, -2221, 1969, 204, 204, 204, 204, -2221, -2221, 3071, 3071, 204, 3071, 1393, -2221, -2221, 2002, -2221, 1394, 2004, 1397, 204, 3071, -2221, -2221, -2221, -2221, 239, 2006, -2221, 3071, -2221, -2221, -2221, -2221, -2221, -2221, 204, 1991, -2221, -2221, 5628, -2221, 5910, -2221, -2221, 2001, 5659, 2462, -2221, 394, -2221, 2008, 1403, 2010, 1409, 2003, 1411, 5690, 5721, 1999, -2221, 1412, 5752, -2221, 204, 1947, -2221, -2221, -2221, -2221, 1670, -2221, 5783, 1697, -2221, 3071, 5910, 1675, 1674, -2221, 2014, -2221, -2221, 3071, 1744, -2221, -2221, 2016, 2022, 204, 204, -2221, 204, -2221, 2589, -2221, -2221, 3071, -2221, 204, -2221, 3071, -2221, 2011, 1413, 1414, -2221, 2018, 5814, 1121, 2023, 2024, 204, 5910, 204, 5910, 1415, -2221, -2221, -2221, -2221, 1418, -2221, 2026, 1419, 1420, 1421, 5845, -2221, 5910, -2221, -2221, -2221, 3071, -2221, -2221, -2221, -2221, -2221, 2020, 1744, -2221, 204, -2221, 3071, -2221, -2221, 2042, 3071, 1423, 1440, 1445, 3071, 2047, -2221, -2221, -2221, 5879, 1459, -2221, -2221, 5910, 2035, -2221, -2221, -2221, 3071, 3071, 3071, 2050, -2221, -2221, -2221, 5910, -2221, -2221, -38, 486, 1463, -2221, 2060, 2063, -2221, -2221, -2221, 2053, 2053, 2053, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, 550, 2066, -2221, 1951, -2221, 1464, -2221, -2221, -2221 }; /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. Performed when YYTABLE does not specify something else to do. Zero means the default is an error. */ static const yytype_uint16 yydefact[] = { 2, 0, 1, 10, 11, 9, 0, 0, 3, 151, 150, 790, 340, 538, 538, 538, 538, 538, 340, 538, 556, 538, 20, 538, 538, 159, 538, 561, 340, 155, 538, 340, 538, 538, 340, 486, 538, 538, 538, 339, 538, 783, 538, 538, 341, 792, 538, 156, 157, 786, 45, 538, 538, 538, 538, 538, 538, 538, 538, 558, 538, 538, 484, 484, 538, 538, 538, 340, 538, 0, 538, 340, 340, 538, 538, 339, 20, 340, 340, 326, 0, 538, 538, 340, 340, 538, 340, 340, 340, 340, 153, 340, 538, 212, 538, 158, 538, 538, 0, 20, 340, 538, 538, 538, 560, 340, 538, 340, 536, 538, 538, 340, 538, 538, 538, 340, 20, 340, 45, 538, 538, 154, 45, 538, 340, 538, 538, 538, 340, 538, 538, 557, 340, 538, 340, 538, 538, 538, 538, 538, 538, 340, 340, 537, 20, 340, 340, 538, 538, 538, 0, 340, 8, 340, 538, 538, 538, 784, 538, 538, 538, 538, 538, 538, 538, 538, 538, 538, 538, 538, 538, 538, 538, 538, 538, 538, 538, 538, 538, 538, 538, 538, 538, 538, 340, 538, 785, 538, 1228, 538, 1229, 538, 538, 340, 340, 538, 538, 538, 538, 538, 538, 538, 538, 1312, 1312, 1312, 1312, 1312, 1312, 612, 0, 37, 612, 74, 48, 49, 50, 66, 67, 77, 69, 70, 68, 110, 59, 0, 147, 152, 52, 71, 72, 73, 51, 60, 55, 56, 57, 61, 208, 76, 75, 58, 612, 446, 441, 454, 0, 0, 0, 457, 440, 439, 0, 509, 512, 538, 510, 0, 538, 0, 538, 546, 0, 0, 553, 53, 460, 614, 617, 623, 619, 618, 624, 625, 626, 627, 616, 633, 615, 634, 620, 0, 781, 621, 628, 630, 629, 661, 635, 637, 638, 636, 639, 640, 641, 642, 643, 622, 644, 645, 647, 648, 646, 650, 651, 649, 675, 662, 663, 664, 665, 652, 653, 654, 656, 655, 657, 658, 659, 660, 666, 667, 668, 669, 670, 671, 672, 673, 674, 632, 676, 631, 1035, 1034, 1036, 1037, 1038, 1039, 1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049, 1050, 1033, 1051, 1052, 1053, 1054, 1055, 1056, 1057, 1058, 1059, 54, 461, 1195, 1197, 1199, 1200, 1196, 1198, 1193, 1194, 462, 1241, 1242, 1243, 1244, 1245, 1246, 0, 0, 341, 0, 0, 0, 0, 0, 0, 0, 997, 35, 0, 0, 599, 0, 0, 0, 0, 0, 0, 455, 508, 482, 211, 0, 0, 0, 482, 0, 313, 340, 728, 0, 728, 539, 0, 23, 482, 0, 482, 977, 0, 994, 484, 482, 482, 482, 32, 485, 82, 445, 960, 482, 954, 106, 482, 37, 482, 0, 341, 0, 0, 64, 0, 0, 330, 44, 7, 971, 0, 0, 0, 600, 0, 0, 78, 341, 0, 991, 523, 0, 0, 0, 297, 296, 0, 0, 814, 0, 0, 341, 0, 0, 539, 0, 341, 0, 0, 0, 341, 33, 341, 22, 600, 0, 21, 0, 0, 0, 0, 0, 0, 0, 399, 341, 45, 141, 0, 0, 0, 0, 0, 0, 0, 0, 788, 341, 0, 341, 0, 0, 995, 996, 0, 340, 341, 0, 0, 0, 600, 0, 1179, 1178, 1183, 1060, 728, 1185, 728, 1175, 1177, 1061, 1166, 1169, 1172, 728, 728, 728, 1181, 1174, 1176, 728, 728, 728, 728, 1114, 728, 728, 1191, 1148, 0, 45, 1202, 1205, 1208, 1235, 341, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1260, 0, 613, 4, 20, 20, 0, 0, 45, 5, 0, 0, 0, 0, 0, 45, 20, 0, 0, 0, 148, 165, 0, 0, 0, 0, 529, 0, 529, 0, 0, 0, 0, 529, 223, 6, 487, 538, 538, 447, 442, 0, 458, 449, 448, 456, 83, 173, 0, 0, 0, 407, 0, 406, 411, 409, 410, 408, 382, 0, 0, 352, 383, 355, 385, 384, 356, 401, 403, 396, 354, 357, 599, 399, 543, 544, 0, 381, 380, 32, 0, 603, 604, 541, 0, 601, 600, 0, 545, 600, 565, 548, 547, 601, 551, 0, 0, 0, 0, 0, 0, 0, 0, 0, 45, 0, 777, 778, 776, 0, 774, 764, 0, 0, 436, 0, 324, 0, 525, 979, 980, 976, 45, 311, 809, 811, 978, 36, 13, 599, 0, 482, 0, 193, 0, 311, 0, 185, 0, 710, 708, 844, 932, 933, 808, 805, 806, 483, 517, 223, 436, 311, 677, 988, 983, 471, 342, 0, 0, 0, 0, 0, 720, 723, 712, 0, 498, 683, 680, 681, 452, 0, 0, 501, 989, 443, 444, 459, 453, 472, 107, 500, 45, 518, 0, 200, 0, 383, 0, 0, 37, 25, 804, 801, 802, 325, 327, 0, 0, 45, 972, 973, 0, 701, 699, 687, 684, 685, 0, 0, 0, 79, 0, 45, 992, 990, 0, 0, 953, 0, 45, 0, 19, 0, 0, 0, 0, 958, 0, 0, 0, 498, 524, 0, 0, 936, 963, 600, 0, 600, 601, 140, 34, 12, 144, 577, 0, 765, 0, 0, 0, 728, 707, 705, 893, 930, 931, 0, 704, 702, 964, 400, 515, 0, 0, 0, 914, 0, 926, 925, 928, 927, 0, 692, 0, 690, 695, 0, 0, 37, 24, 0, 311, 945, 948, 0, 45, 0, 303, 299, 0, 0, 578, 311, 0, 528, 0, 1118, 1113, 528, 1150, 1180, 0, 528, 528, 528, 528, 528, 528, 1173, 311, 46, 1201, 1210, 1211, 0, 0, 45, 1234, 1236, 1237, 0, 45, 0, 1025, 1026, 0, 993, 350, 0, 0, 45, 45, 45, 1295, 1250, 45, 0, 0, 20, 43, 38, 42, 0, 40, 17, 46, 311, 133, 135, 137, 111, 0, 0, 20, 340, 149, 539, 599, 166, 147, 311, 180, 182, 184, 188, 528, 191, 528, 197, 199, 201, 210, 0, 214, 0, 45, 0, 450, 425, 0, 352, 365, 364, 377, 363, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 599, 0, 0, 599, 0, 0, 399, 405, 397, 513, 0, 0, 516, 571, 572, 576, 0, 568, 0, 570, 0, 609, 0, 0, 0, 0, 0, 555, 570, 559, 0, 0, 583, 549, 581, 0, 0, 352, 354, 552, 587, 586, 554, 678, 311, 700, 703, 706, 709, 311, 340, 0, 946, 0, 45, 759, 179, 0, 0, 0, 0, 0, 0, 313, 813, 0, 530, 0, 476, 480, 0, 470, 599, 0, 195, 186, 0, 322, 0, 209, 0, 679, 599, 0, 787, 320, 317, 314, 316, 321, 311, 728, 725, 734, 729, 0, 0, 0, 0, 0, 726, 712, 728, 0, 791, 0, 499, 540, 0, 0, 0, 18, 205, 0, 0, 0, 207, 196, 0, 495, 493, 490, 0, 45, 0, 330, 0, 0, 333, 331, 0, 45, 974, 382, 922, 969, 0, 0, 967, 0, 562, 0, 88, 89, 87, 86, 92, 91, 103, 96, 99, 98, 101, 100, 97, 102, 95, 93, 90, 94, 84, 0, 85, 198, 0, 0, 0, 0, 0, 0, 298, 0, 189, 437, 0, 45, 959, 957, 134, 816, 0, 0, 0, 293, 540, 181, 0, 580, 0, 579, 288, 288, 0, 760, 0, 728, 712, 940, 0, 0, 937, 285, 284, 63, 282, 0, 0, 0, 0, 0, 0, 0, 689, 688, 136, 14, 183, 947, 45, 950, 949, 147, 0, 104, 47, 0, 0, 696, 0, 728, 528, 0, 1147, 1117, 1112, 728, 528, 1149, 1192, 728, 528, 728, 528, 528, 528, 728, 528, 728, 528, 697, 0, 0, 0, 0, 1222, 0, 0, 1209, 1213, 1215, 1214, 45, 1204, 852, 1223, 0, 1207, 0, 0, 1238, 1233, 1230, 1231, 0, 0, 1000, 45, 45, 45, 0, 391, 392, 1030, 0, 0, 0, 0, 1261, 1263, 1264, 1265, 1267, 1266, 0, 0, 1276, 1278, 1279, 1280, 0, 0, 1284, 45, 0, 0, 1299, 28, 37, 0, 0, 39, 0, 30, 160, 117, 311, 340, 119, 121, 0, 122, 115, 123, 131, 130, 124, 125, 126, 0, 113, 116, 26, 0, 311, 0, 0, 145, 178, 0, 0, 223, 223, 0, 225, 218, 222, 0, 0, 0, 353, 0, 360, 362, 359, 358, 376, 378, 372, 366, 505, 369, 367, 370, 368, 371, 373, 375, 361, 374, 379, 599, 412, 390, 0, 344, 0, 415, 416, 402, 413, 404, 0, 599, 514, 0, 533, 531, 0, 599, 567, 574, 575, 573, 602, 611, 606, 608, 610, 607, 605, 566, 550, 0, 0, 0, 352, 0, 0, 0, 0, 0, 698, 780, 0, 790, 793, 783, 0, 792, 786, 0, 784, 785, 782, 775, 0, 430, 0, 0, 507, 0, 0, 0, 0, 812, 478, 477, 0, 475, 0, 194, 0, 528, 807, 428, 429, 433, 0, 0, 0, 315, 318, 177, 0, 599, 0, 0, 0, 0, 0, 713, 724, 311, 463, 728, 682, 0, 482, 0, 0, 202, 0, 395, 982, 0, 0, 0, 16, 803, 328, 338, 0, 334, 336, 332, 0, 0, 0, 0, 0, 0, 0, 966, 686, 563, 81, 80, 129, 127, 128, 341, 0, 488, 424, 0, 0, 0, 0, 192, 0, 521, 0, 0, 728, 0, 0, 65, 528, 506, 602, 139, 0, 143, 45, 0, 712, 0, 0, 0, 0, 935, 0, 0, 0, 0, 0, 915, 917, 0, 693, 691, 0, 45, 952, 45, 951, 146, 341, 0, 503, 0, 1182, 0, 728, 1184, 0, 728, 0, 0, 728, 0, 728, 0, 728, 0, 728, 0, 0, 0, 45, 0, 0, 0, 1212, 0, 1203, 1206, 0, 1240, 0, 1004, 1002, 1003, 45, 999, 0, 0, 0, 351, 599, 599, 0, 1029, 1032, 0, 0, 0, 0, 0, 45, 1247, 0, 0, 0, 45, 1248, 1286, 1288, 0, 0, 1291, 1293, 45, 1249, 0, 0, 0, 0, 0, 0, 45, 1298, 15, 29, 41, 0, 174, 161, 118, 0, 45, 0, 45, 27, 160, 540, 540, 170, 173, 169, 0, 187, 190, 215, 0, 0, 0, 248, 246, 253, 250, 264, 257, 262, 0, 0, 216, 239, 251, 243, 254, 244, 259, 245, 0, 238, 0, 233, 230, 219, 220, 0, 0, 426, 352, 0, 388, 599, 348, 345, 346, 0, 399, 0, 535, 534, 0, 0, 582, 353, 0, 0, 0, 352, 589, 352, 593, 352, 591, 311, 0, 599, 519, 0, 0, 981, 0, 312, 479, 481, 173, 323, 0, 599, 520, 0, 985, 599, 984, 319, 321, 727, 0, 0, 0, 737, 0, 0, 0, 0, 711, 465, 482, 502, 0, 204, 203, 382, 494, 491, 489, 0, 492, 0, 329, 0, 0, 0, 0, 0, 0, 968, 0, 1014, 0, 0, 423, 418, 955, 956, 722, 311, 962, 438, 0, 817, 819, 825, 295, 294, 0, 288, 0, 0, 290, 289, 0, 761, 762, 714, 0, 944, 943, 0, 941, 0, 938, 283, 0, 1020, 1009, 0, 1007, 1010, 756, 0, 0, 929, 921, 694, 0, 0, 0, 0, 0, 301, 0, 300, 308, 0, 1191, 0, 1191, 1191, 1127, 0, 1121, 1123, 1124, 1122, 728, 1126, 1125, 0, 1191, 728, 1145, 1144, 0, 0, 1188, 1187, 0, 0, 1191, 0, 1191, 0, 728, 1066, 1070, 1071, 1072, 1068, 1069, 1073, 1074, 1067, 0, 1155, 1159, 1160, 1161, 1157, 1158, 1162, 1163, 1156, 1165, 1164, 728, 0, 1108, 1110, 1111, 1109, 728, 0, 1138, 1139, 728, 0, 0, 0, 0, 0, 0, 1224, 0, 0, 853, 0, 1232, 1001, 0, 1027, 0, 599, 0, 1031, 0, 0, 45, 0, 0, 1262, 0, 0, 0, 1277, 0, 0, 0, 0, 1285, 0, 0, 45, 0, 0, 0, 45, 1300, 0, 0, 0, 109, 795, 0, 112, 0, 174, 0, 147, 0, 172, 171, 268, 254, 267, 0, 256, 261, 255, 260, 0, 0, 0, 0, 0, 223, 213, 224, 242, 0, 223, 235, 236, 0, 0, 0, 0, 279, 224, 280, 0, 0, 228, 269, 274, 277, 230, 221, 0, 504, 0, 414, 386, 389, 0, 347, 0, 532, 569, 570, 0, 0, 352, 0, 0, 0, 779, 773, 789, 0, 0, 0, 526, 0, 341, 527, 0, 987, 0, 0, 0, 741, 0, 739, 736, 731, 735, 733, 0, 45, 0, 464, 451, 206, 335, 337, 0, 0, 0, 970, 965, 132, 0, 1013, 422, 0, 0, 417, 961, 0, 0, 45, 815, 826, 827, 832, 836, 829, 837, 838, 839, 833, 835, 834, 830, 831, 0, 0, 0, 0, 286, 0, 0, 0, 0, 939, 934, 473, 0, 1006, 728, 916, 0, 0, 891, 105, 307, 302, 304, 306, 0, 0, 0, 1076, 728, 1077, 1078, 45, 1119, 728, 1146, 1142, 728, 1191, 0, 1075, 45, 1079, 0, 1080, 0, 1064, 728, 1153, 728, 1106, 728, 1136, 728, 1216, 1217, 1218, 1226, 1227, 45, 1221, 1219, 1220, 0, 0, 0, 0, 394, 0, 0, 1273, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1296, 0, 0, 0, 45, 45, 0, 0, 1306, 0, 0, 0, 0, 0, 31, 176, 175, 0, 0, 120, 114, 108, 0, 0, 162, 599, 167, 0, 249, 247, 265, 258, 263, 217, 223, 599, 0, 241, 237, 224, 0, 234, 0, 271, 270, 0, 226, 230, 0, 0, 0, 0, 0, 231, 0, 427, 387, 349, 398, 0, 584, 596, 598, 597, 0, 431, 0, 0, 810, 0, 434, 0, 986, 757, 730, 0, 0, 45, 0, 0, 0, 845, 975, 846, 1019, 0, 1016, 1018, 421, 420, 0, 0, 0, 818, 0, 828, 0, 289, 0, 0, 766, 763, 720, 715, 716, 718, 719, 942, 1008, 1012, 0, 0, 382, 0, 0, 0, 0, 310, 309, 522, 0, 0, 0, 1120, 1143, 0, 1190, 1189, 0, 0, 0, 1065, 1154, 1107, 1137, 1225, 1239, 0, 0, 393, 0, 0, 1272, 1269, 903, 904, 905, 902, 907, 901, 908, 900, 899, 898, 906, 894, 0, 0, 45, 1268, 1271, 1270, 1282, 1283, 1281, 1289, 1287, 0, 1290, 0, 1292, 0, 0, 1253, 0, 1308, 1309, 45, 1301, 1302, 1303, 1304, 1310, 1311, 0, 0, 0, 796, 163, 164, 0, 0, 240, 599, 242, 0, 281, 229, 0, 273, 272, 275, 276, 278, 474, 0, 771, 770, 772, 0, 768, 432, 0, 998, 435, 0, 742, 740, 0, 732, 0, 0, 0, 1015, 419, 847, 0, 0, 0, 0, 912, 0, 0, 0, 0, 0, 0, 0, 287, 292, 291, 0, 0, 0, 1005, 918, 919, 0, 843, 892, 892, 305, 1092, 1091, 1090, 1097, 1098, 1099, 1096, 1093, 1095, 1094, 1103, 1100, 1101, 1102, 0, 1087, 1131, 1130, 1132, 1133, 0, 1192, 1082, 1084, 1083, 0, 1086, 1085, 0, 1028, 1275, 1274, 0, 0, 0, 1297, 0, 1255, 45, 1256, 1258, 1307, 0, 797, 0, 173, 266, 0, 0, 228, 227, 0, 0, 767, 511, 0, 0, 0, 467, 1017, 824, 823, 0, 821, 863, 860, 0, 0, 0, 0, 910, 911, 0, 0, 0, 0, 0, 717, 923, 1011, 45, 0, 0, 0, 0, 0, 1129, 1186, 1081, 45, 0, 0, 895, 0, 1254, 45, 1251, 45, 1252, 1305, 0, 0, 252, 232, 496, 769, 758, 745, 738, 743, 0, 0, 820, 866, 861, 0, 0, 0, 0, 0, 0, 0, 849, 0, 855, 0, 468, 721, 0, 0, 842, 45, 45, 889, 1089, 1088, 0, 0, 896, 0, 1294, 0, 0, 800, 794, 798, 168, 0, 0, 466, 822, 0, 0, 0, 0, 858, 0, 841, 0, 909, 859, 0, 848, 0, 854, 0, 924, 0, 0, 0, 1128, 0, 0, 355, 0, 0, 0, 497, 0, 748, 0, 746, 749, 864, 865, 0, 867, 869, 0, 0, 0, 850, 856, 469, 920, 890, 888, 0, 897, 45, 45, 799, 751, 752, 0, 744, 0, 862, 0, 857, 840, 0, 0, 0, 0, 0, 0, 750, 753, 747, 868, 0, 0, 872, 913, 851, 1022, 1257, 1259, 754, 0, 0, 0, 870, 45, 1021, 755, 874, 873, 45, 0, 0, 0, 875, 880, 882, 883, 1023, 1024, 0, 0, 0, 45, 871, 45, 45, 599, 886, 885, 884, 876, 0, 878, 879, 0, 881, 0, 45, 887, 877 }; /* YYPGOTO[NTERM-NUM]. */ static const yytype_int16 yypgoto[] = { -2221, -2221, -2221, -2221, -2221, 10, 1808, 1179, -2221, -2221, -667, -31, -2221, -2221, -400, -2221, 806, -2221, -50, 1173, -2221, -2221, -2221, 2675, 66, -2221, -2221, -2221, -2221, -2221, -2221, 196, 487, 897, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -169, -907, -2221, -2221, -2221, 994, 490, 1513, -2221, -191, -1580, 209, -2221, -2221, -2221, -2221, -2221, -2221, 1507, -270, -335, -2221, -2221, -2221, 1505, -2221, -408, -2221, -2221, -2221, -2221, 1389, -2221, -2221, 794, -1287, -1543, 1175, 472, -1546, -167, -15, 1180, -2221, 208, 217, -1818, -2221, -1552, -1257, -1550, -261, -2221, 4, -1587, -1798, -1393, -2221, -2221, 630, 967, 391, -55, 124, -2221, 650, -2221, -2221, -2221, -2221, -2221, -69, -2221, -1469, -220, 1107, -2221, 1088, 721, 748, -377, -2221, -2221, 1059, -2221, -2221, -2221, -2221, 439, 440, 2083, 2922, -362, -1314, 222, -439, -1019, 1093, -576, -596, 1860, 19, 1701, -881, -879, -2221, -2221, -625, -615, -218, -2221, -792, -2221, -594, -953, -1128, -2221, -2221, -2221, 207, -2221, -2221, 1455, -2221, -2221, 1937, -2221, 1938, -2221, -2221, 767, -2221, -387, 15, -2221, -2221, 1939, 1941, -2221, 733, -2221, -711, -187, 1386, -2221, 1112, -2221, -2221, -113, -2221, 1155, 538, -2221, 4421, -391, -1099, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -186, -2221, 522, -931, -2221, -2221, -2221, 369, -1281, -620, 1195, -930, -369, -384, -456, 645, 5, -2221, -2221, -2221, 1537, -2221, -2221, 1124, -2221, -2221, 1094, -2221, 1362, -1975, 1024, -2221, -2221, -2221, 1545, -2221, 1542, -2221, 1544, -2221, 1547, -1011, -2221, -2221, -2221, -122, -233, -2221, -2221, -2221, -402, -2221, 825, 789, -373, 791, -2221, 47, -2221, -2221, -2221, -332, -2221, -2221, -2221, -1907, -2221, -2221, -2221, -2221, -2221, -1446, -515, 201, -2221, -176, -2221, 1410, 1200, -2221, -2221, 1201, -2221, -2221, -2221, -2221, -295, -2221, -2221, 1131, -2221, -2221, 1178, -2221, 269, 1197, -2221, -2221, -826, -2221, -2220, -2221, -226, -2221, -2221, 231, -2221, -760, -392, 1785, 1441, -2221, -2221, -1659, -2221, -2221, -2221, -2221, -2221, -174, -2221, -2221, -2221, -314, -2221, -339, -2221, -358, -2221, -357, -1871, -1200, -764, -2221, -102, -484, -1024, -2067, -2221, -2221, -2221, -491, -1805, 475, -2221, -756, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -488, -1473, 743, -2221, 224, -2221, 1575, -2221, 1739, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -1440, 786, -2221, 1485, -2221, -2221, -2221, -2221, 1868, -2221, -2221, -2221, 285, 1842, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, 704, -2221, -2221, -2221, 238, -2221, -2221, -2221, -2221, -49, -1941, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, 627, 445, -530, -1309, -1245, -1318, -1443, -1435, -1432, -2221, -1427, -1426, -1255, -2221, -2221, -2221, -2221, -2221, 429, -2221, -2221, -2221, -2221, -2221, 474, -1424, -1423, -2221, -2221, -2221, 427, -2221, -2221, 471, -2221, 303, -2221, -2221, -2221, -2221, 444, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, 227, -2221, 223, -94, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, 1047, -2221, 1042, -2221, -851, -2221, 216, -2221, -2221, -2221, 428, 732, -2221, -2221, -2221, 1400, -2221, -2221, -2221, -2221, -2221, -2025, -95, -2221, -2221, -2221, -2221, 718, -2221, -2221, -2221, -2221, -2221, -2221, 56, -2221, 715, -2221, -2221, -2221, -2221, 709, -2221, -2221, -2221, -2221, -2221, 705, -2221, 22, -2221, 1286 }; /* YYDEFGOTO[NTERM-NUM]. */ static const yytype_int16 yydefgoto[] = { -1, 1, 6, 7, 209, 387, 210, 844, 755, 211, 910, 623, 808, 693, 573, 908, 909, 444, 2262, 1227, 1518, 212, 213, 624, 1131, 1132, 214, 215, 216, 583, 1298, 1299, 1135, 1300, 217, 218, 219, 220, 1160, 221, 222, 1161, 223, 586, 224, 225, 226, 227, 1596, 1597, 925, 1608, 944, 1886, 228, 229, 230, 231, 232, 233, 789, 1171, 1172, 234, 235, 236, 750, 1083, 1084, 237, 238, 714, 456, 937, 938, 1624, 939, 940, 1924, 1634, 1639, 1640, 1925, 1926, 1635, 1636, 1637, 1626, 1627, 1628, 1629, 1898, 1631, 1632, 1633, 1900, 2144, 1928, 1929, 1930, 1173, 1174, 1490, 1491, 2015, 1745, 1152, 1153, 239, 461, 240, 854, 2032, 2033, 1777, 2034, 1034, 722, 723, 1057, 1058, 1046, 1047, 241, 760, 761, 762, 763, 1099, 1451, 1452, 1453, 400, 377, 407, 1343, 1648, 1344, 892, 1006, 626, 645, 627, 628, 629, 630, 2078, 1086, 977, 1938, 827, 631, 632, 633, 634, 635, 1348, 1650, 636, 1318, 1935, 1416, 1397, 1417, 1027, 1144, 242, 243, 1976, 244, 245, 696, 1039, 1040, 713, 426, 246, 247, 248, 249, 1090, 1091, 1445, 1945, 1946, 1077, 250, 251, 252, 253, 1209, 254, 980, 1356, 255, 379, 731, 1434, 256, 257, 258, 259, 260, 261, 656, 648, 986, 987, 988, 262, 263, 264, 1003, 1004, 1009, 1010, 1011, 1345, 773, 649, 805, 568, 265, 266, 267, 717, 268, 733, 734, 269, 771, 772, 270, 502, 839, 840, 842, 271, 272, 769, 273, 824, 274, 818, 275, 705, 1074, 276, 277, 2194, 2195, 2196, 2197, 1731, 1071, 410, 725, 726, 1070, 1696, 1760, 1967, 1968, 2451, 2452, 2523, 2524, 2546, 2560, 2561, 1765, 1965, 278, 279, 1747, 677, 813, 814, 1953, 2300, 2301, 1954, 674, 675, 280, 281, 282, 283, 2108, 2109, 2487, 2488, 284, 758, 759, 285, 710, 711, 286, 689, 690, 287, 288, 1150, 1737, 2184, 2405, 2406, 1997, 1998, 1999, 2000, 2001, 707, 2002, 2003, 2004, 2466, 1234, 2005, 2468, 2006, 2007, 2008, 2408, 2456, 2496, 2528, 2529, 2565, 2566, 2585, 2586, 2587, 2588, 2589, 2600, 2009, 2206, 2425, 820, 2083, 2246, 2247, 2248, 2010, 832, 1505, 1506, 2027, 1167, 2422, 289, 290, 291, 292, 293, 294, 295, 296, 801, 1169, 1170, 1753, 1754, 297, 848, 298, 784, 299, 785, 300, 1147, 301, 302, 303, 304, 305, 1107, 1108, 306, 766, 307, 308, 309, 685, 686, 310, 311, 1419, 1686, 719, 312, 313, 780, 314, 315, 316, 317, 318, 319, 320, 1244, 1245, 321, 1177, 1761, 1762, 2335, 322, 1724, 2176, 2177, 1763, 323, 2578, 324, 325, 326, 327, 1253, 328, 329, 330, 331, 332, 333, 1210, 1808, 866, 1786, 1787, 1788, 1812, 1813, 1814, 2368, 1815, 1816, 1789, 2212, 2478, 2357, 334, 1216, 1836, 335, 336, 337, 338, 1200, 1790, 1791, 1792, 2363, 339, 1218, 1840, 340, 1206, 1795, 1796, 1797, 341, 342, 343, 1212, 1830, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 1801, 1802, 867, 1527, 359, 360, 361, 362, 363, 364, 877, 878, 879, 1228, 1229, 1230, 1235, 1846, 1847, 365, 366, 367, 1241, 1242, 368, 883, 884, 885, 369, 370, 371, 372, 373, 2263, 2264, 2439, 2441, 374, 1256, 1257, 1258, 1259, 1260, 1261, 1262, 2079, 2080, 1264, 1265, 1266, 1267, 1268, 1270, 1271, 2094, 900, 2092, 375, 1274, 1275, 2098, 2099, 2104, 561 }; /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If positive, shift that token. If negative, reduce the rule whose number is the opposite. If YYTABLE_NINF, syntax error. */ static const yytype_int16 yytable[] = { 413, 825, 821, 708, 682, 833, 834, 835, 836, 978, 1475, 1105, 1401, 1251, 874, 1252, 678, 720, 1306, 804, 1720, 697, 1350, 982, 1625, 1755, 1645, 735, 1894, 738, 1237, 425, 425, 747, 741, 742, 743, 946, 433, 647, 1012, 571, 744, 1092, 647, 746, 2178, 748, 1748, 1778, 1357, 1927, 2202, 996, 1630, 1487, 702, 1981, 1982, 1983, 1430, 2086, 1897, 2088, 1899, 1008, 1008, 460, 479, 1254, 405, 2265, 482, 653, 751, 1377, 657, 659, 427, 796, 1081, 816, 1913, 1007, 1007, 1190, 440, 1822, 1917, 1189, 405, 777, 1658, 1932, 797, 1823, 810, 2128, 1824, 1378, 1959, -564, -566, 1825, 1826, 793, 1828, 1829, -542, 462, 798, -585, 2, 3, 806, 2359, 809, 405, 970, 592, 594, 701, 2134, 2135, 1770, 599, 477, 1564, -594, 828, -595, 598, 857, -588, 46, 1565, 1571, -592, 1974, 2341, -594, 843, -595, 846, 2590, -588, 1251, 8, 1396, -592, 852, 1547, 1566, 25, 504, 1496, 1455, 598, 29, 1476, 1508, 598, 1025, -590, 671, 1605, 672, 74, -528, 1415, 905, 1063, 687, 1780, 1799, -590, 728, 376, 1550, -138, 47, 48, 1347, 1347, 424, 989, 906, 598, 598, 991, 886, 905, 598, -340, 585, 1456, 998, 2467, 598, -142, 96, 2266, 2081, -566, 1232, 2085, 593, -585, 996, -564, 1811, 424, 1821, 598, 1834, 408, -566, 574, 972, 1809, 598, 1819, 598, 1832, 1064, 1838, -62, 1775, 598, 598, 109, 1236, 443, 1156, 90, -528, -594, 2267, -595, -1116, 2141, -588, 972, 915, 95, -592, 1858, 600, 985, -542, 815, 2360, 1065, 927, 928, 929, 930, 647, -793, -793, 2481, 1771, 4, 602, 1782, -1141, 424, 997, 981, 1457, 999, -590, 2142, 1817, 1223, 1827, 646, 1835, 500, 1106, 2591, 646, -528, 1810, 1516, 1820, 2535, 1833, 424, 1839, 121, -340, 1066, 424, 424, -1063, -1152, 603, 1163, 621, -1168, 1567, 1568, 1067, 1572, 2361, -1171, 2283, 1477, 1041, 2435, 1551, 424, 698, 1552, 424, 2362, 1794, 1712, 737, -138, -1105, 931, 1573, 811, 1036, 1072, 699, -1135, -340, -1115, 1068, 2133, 424, 1168, 2182, -1140, -1062, 1202, 424, -142, 2290, 2291, 1026, -566, 673, 676, 1158, -585, 971, -564, 683, 684, 688, 684, 1093, 692, 694, 1901, 1903, 700, 1351, 704, 706, 706, 709, 1045, -62, 712, 5, 2129, 716, 2178, 712, 1610, 2131, 1658, -594, 727, -595, -1116, 732, -588, 712, 1975, 712, -592, 510, 1822, 425, 712, 712, 712, 996, 2087, 996, 1823, 598, 712, 1824, 745, 712, 996, 712, 1825, 1826, -1141, 1828, 1829, 756, 757, 1008, -590, 1165, 1651, 2228, 768, 770, 1157, 1704, 1159, 776, 1507, 647, 1069, 1513, 1447, 647, 783, 1375, 1515, 787, 511, 424, 647, 740, -1063, -1152, 424, -383, 1719, -1168, 829, 800, 1185, 1742, 807, -1171, 1664, 1666, 1668, 1559, 727, 817, 819, 819, 753, 823, 800, 1384, 1442, 598, -1105, 1155, 831, 831, 831, 831, 831, -1135, 841, -1115, 1621, 845, 1919, 847, 783, -1140, -1062, 850, 1044, 408, 853, 1385, 1749, 791, 858, 1685, 1001, 598, 1464, 598, 799, 567, 646, 1312, 1051, 876, 1386, 1293, 1811, 2304, 1294, 1387, 1388, -1151, 1892, 1893, 1184, 1809, 1389, 1186, 1606, 1821, 598, 875, 1008, 2557, 2558, 1834, 572, 2365, 1819, 911, 1615, 1616, 2533, 424, 1832, 1622, 917, 1304, 1838, 899, 1007, 1023, 1365, 1366, 1367, 1368, 1369, 907, 2494, 2076, 912, 913, 914, 700, 1024, 2288, 2525, 575, 920, 921, 1305, 2205, 926, 700, 700, 700, 700, 576, 996, 1817, 934, 935, 1897, 2209, 1899, -1167, 1030, 2192, 577, 1810, 2495, 1743, 1827, 1467, 1468, 902, 903, 1623, 1835, 424, 2285, 647, 1820, 1110, 424, 1349, 698, 918, 1833, -384, 1098, 424, 1839, -1170, 601, -1104, 1621, 1340, 424, 621, 699, 1560, 2525, 2463, 1922, 424, 1469, 591, 579, 580, 2592, -231, 951, 992, 2366, 1021, 952, 993, -1134, 1625, 2139, 2140, -528, 1187, 2127, 2367, 716, 1014, 768, 823, 817, 704, 1019, 1032, 1197, 847, -528, 922, 405, 2593, 1390, 578, -1151, 700, 967, 995, 406, 923, 2572, 1630, 424, 1219, 2235, 1622, 2236, 1310, 646, 972, 1220, 1221, 646, 712, 2579, 2237, 1043, 2238, 700, 646, 1910, 981, 621, 1391, 1002, 584, 2592, 1585, 1251, 1803, 1859, 1418, 1088, 1842, 1843, 1844, 1311, 1848, 1849, 587, 1283, 1060, 588, 1222, 424, 911, 1643, 2392, 50, 1911, 972, 2594, 1105, 1105, 1307, 2593, 1053, 1623, -1167, 1919, 1920, 1921, 1100, 668, 669, 2434, 1082, 1392, 1087, 1054, 1357, 1089, 1008, 2037, 2606, 2608, 1134, 581, 1664, 1666, 1668, 1092, 589, 1139, 1103, 1780, -1170, 2612, -1104, -383, 1007, 1803, 1644, 1061, 1133, 1199, 2292, 2293, 2294, 1205, 1181, 970, 1781, 1140, 1211, 1141, 1062, 1215, 1217, 1964, 1148, -1134, 1151, 1182, 1586, 700, 2477, 996, 996, 996, 996, 996, 647, 647, 647, 647, 647, 1884, 673, 1587, 1588, 1589, 1008, 1008, 1008, 1885, 1780, 1780, 590, 1103, 2239, 2240, 1381, 2241, 2242, 700, 1279, 1382, 118, 1192, 1663, 1665, 1667, 1781, 1781, 122, 2444, 598, 1352, 1280, 700, 595, 25, 700, -528, 1759, 1308, 29, 1309, 1193, 646, 1353, 596, 424, 2243, 1693, 1782, 1223, 1224, 1783, 1238, 1225, 1226, 597, 1784, 1243, 2127, 1358, 1422, 47, 48, 637, 1785, 1922, 1255, 1263, 1269, -384, 1780, 1273, 1359, 1576, -388, 1240, 1577, 1578, 1579, 2139, 2140, 973, 1804, 655, 2287, 2424, 976, 1781, 2244, 1580, 1581, 1276, 845, 641, 642, 643, 1407, 1592, 652, 1782, 1782, 2245, 1783, 1783, 1411, 616, 1805, 1301, 660, 1408, 1439, 1316, 661, 1461, 618, 90, 1806, 1412, 1479, 1233, 1233, 1807, 650, 1440, 2343, 95, 1462, 658, 992, 1313, 662, 1480, 993, 791, 1278, 2344, 2345, 1482, 663, 642, 643, 2346, 619, 2347, 1804, 664, 994, 992, 665, 1302, 1483, 993, 2348, 1485, 2349, 666, 2350, 2461, 642, 643, 995, 1782, 667, 1363, 1783, 994, 1486, 1023, 1805, 1784, 620, 121, 2119, 2120, 2121, 2122, 2123, 1785, 1806, 995, 1493, -385, 1499, 1807, 670, 1553, 1145, 1561, 1482, 2459, 2390, 1569, 1574, 1611, 1395, 1500, 2318, 1654, 1554, 1251, 1562, 1563, 1097, 1653, 1570, 1575, 2115, 644, 405, 1656, 951, 1251, 673, 2091, 952, 150, 1582, 1759, 1399, 2175, 721, 953, 954, 1590, 688, 1671, 1770, 621, 1651, 1583, 1507, 646, 646, 646, 646, 646, 1591, 709, 1672, 1002, 1002, 1673, 967, 1249, 2157, 1053, 2532, 2299, 1352, 2011, 2162, 1705, 1685, 1706, 1681, 1683, 1675, 1941, 1677, 1601, 1602, 1680, 1432, 911, 2089, 2090, 791, 732, 1684, 1687, 1703, 1458, 2100, 2101, 1697, 1692, 1699, 2531, 2351, 622, 1713, 2352, 1688, 757, 1766, 1598, 1008, 1008, 1008, 791, 2319, 2084, 681, 1714, 1251, 1249, 2156, 1767, 770, 2235, 1415, 2236, -386, 1604, 1947, 1665, 1667, 1523, 1769, 1411, 2237, 25, 2238, 1526, 976, 1481, 29, 1529, 1249, 1531, 1529, 1529, 1957, 1533, 1455, 1535, 679, 1443, 1722, 1249, 1507, 1978, 1507, 1347, 1347, 1347, 1347, 1347, 47, 48, 680, 992, 1984, 1461, 972, 993, 1734, 2019, 695, -853, 992, 718, 642, 643, 993, 1499, 1985, 1370, 1511, 994, 2020, 642, 643, 1771, 2320, 703, 2353, 2023, 2021, 715, 2049, 730, 569, 995, 764, 1774, 2321, 2069, 2322, 2323, 2024, 2324, 995, 2050, 2325, 1203, 1204, 992, 1207, 736, 2070, 993, 90, 749, 2116, 2136, -588, 788, 642, 643, 2167, 1542, 95, 1489, 754, 994, 424, 2117, 2137, 1936, 1857, 1875, 1876, 2168, 1284, 1544, 1555, 1556, 1557, 995, 1944, 1544, 2067, 2068, 2354, 2355, 2356, 1544, 2172, 767, 1549, 2232, 1700, 1544, 2173, 2239, 2240, 1457, 2241, 2242, 2174, 774, 1584, 2227, 2233, 775, 2234, 778, 121, 1055, 781, 1056, 782, 2249, 611, 729, 786, 1285, 612, 613, 614, 615, 790, 1286, 2273, 2274, 2250, 1593, 907, 2243, 2038, 616, 2040, 2041, 794, 2326, 795, 2327, 617, 822, 618, 570, 1544, 830, 2045, 855, 1766, 2299, 856, 1287, 859, 1603, 150, 1499, 2052, 2252, 2054, 700, 1939, 2253, 882, 1313, 1614, 1615, 1616, 1766, 2254, 1482, 619, 2139, 2140, 2244, 1482, 1288, 1617, 1289, 2258, 2268, 2255, 1682, 2256, 904, 1955, 1618, 2245, 2257, 1482, 1482, 2276, 2259, 2269, 2313, 2147, 2419, 1961, 1977, 620, 1544, 1963, 2270, 2271, 2277, 1181, 1499, 2314, 1544, 1619, 2381, 1290, 2381, 2316, 1620, 916, 1291, 943, 2337, 2339, 1292, 2371, 861, 2382, 1293, 2383, -1191, 1294, 625, 880, 860, 996, 862, 1610, 1251, 1669, 424, 1902, 1904, 863, 864, 865, 1621, 609, 610, 868, 869, 870, 871, 1295, 872, 873, 1371, 1372, 2395, 2428, 621, 1740, 2398, 881, 1251, 1360, 2378, 1296, 887, 1361, 611, 2396, 2429, 1297, 612, 613, 614, 615, 2136, 1002, 2601, 2602, 1695, 1695, 894, 1695, 2454, 616, 1249, 1499, 895, 2446, 2475, 712, 617, 1082, 618, 1082, 1461, 2455, 1707, 2470, 2473, 1622, 1499, 2476, 1766, 2506, 2249, 2249, 2547, 2498, 622, 2549, 1461, 1499, 1181, 2500, 1249, 2502, 2507, 2538, 2539, 2548, 619, 647, 2550, 2552, 2553, 2554, 1746, 2569, 1730, 896, 1354, 2381, 1951, 2511, 2512, 611, 2381, 1151, 972, 612, 613, 614, 615, 1744, 2570, 1772, 897, 1773, 620, 2571, 2575, 1623, 616, 700, 2595, 1647, 1948, 1949, 1950, 617, 898, 618, 919, 2576, 901, 973, 974, 2596, 2611, 975, 1776, 976, 1845, 562, 563, 564, 565, 566, 979, 1732, 1213, 1214, 1000, 1020, 990, 424, 1243, 811, 1031, 619, 1033, 1029, 1035, 1042, 1993, 1048, 1052, 408, 1073, 983, 1076, 1240, 1255, 984, 2556, 621, 1078, 1263, 970, 803, 642, 643, 1094, 1095, 1096, 1269, 1101, 620, 1109, 1164, 1342, 616, 1779, 1273, 1138, 1175, 1111, 1188, 1178, 1179, 618, 779, 1191, 1134, 1194, 1890, 1202, 1208, 1233, 1233, 1233, 1281, 1233, 1233, 1231, 1249, 1850, 1883, 803, 642, 643, 1272, 598, 1317, 424, 1320, 1341, 622, 619, 952, 616, 2421, 2158, 791, 993, 1373, 826, -343, 1379, 618, 1380, 1400, 1410, 1402, 621, 1446, 838, 1912, 1424, 1425, 2160, 1426, 1427, 1428, 1429, 1438, 620, 1441, 2147, 1607, 1923, 985, 1459, 1444, 611, 1450, -936, 619, 612, 613, 614, 615, 1460, 1465, 1466, 1471, 1484, 1470, 1478, 1707, 1494, 616, 1707, 1707, 1707, 1497, 1498, 1502, 617, 2204, 618, 1501, 1952, 644, 1166, 620, 622, 1503, 1512, 1514, 888, 889, 890, 891, 893, 2297, 1105, 1473, 2462, 1507, 611, 1504, 1536, 621, 612, 613, 614, 615, 619, 1521, 1524, 1537, 1538, 1539, 712, 1540, 1541, 616, 646, 1002, 985, 1544, 644, 1545, 617, 1546, 618, 1549, 922, 1595, 1600, 1638, 1641, 1646, 1986, 1647, 620, 1652, 1702, 1657, 1660, 1661, 621, 1662, 376, 1670, 1676, 985, 1456, 945, 947, 948, 1089, 949, 619, 622, 406, 1693, 2509, 1710, 950, 1715, 1716, 1717, 1718, 2340, 1734, 1729, 1741, 1750, 1768, 1851, 1854, 424, 826, 1855, 1856, 1905, 1233, 1233, 1233, 1860, 620, 2530, 1105, 1861, 2030, 2031, 1862, 1863, 2281, 1864, 1759, 621, 622, 1866, 1867, 611, 1868, 1870, 2284, 612, 613, 614, 615, 1871, 1872, 1873, 1877, 1878, 985, 2048, 1879, 1284, 616, 1880, 1028, 1881, 1887, 424, 1889, 617, 639, 618, 1906, 1915, 640, 2521, 1936, 1907, 802, 1038, 641, 642, 643, 1908, 2530, 1909, 1055, 621, 803, 642, 643, 611, 616, 622, 1918, 612, 613, 614, 615, 619, 616, 618, 1931, 2082, 1285, 1933, 1937, 1059, 616, 618, 1956, 1240, 1958, 1969, 1075, 617, 1970, 618, 2097, 1971, 1079, 1080, 2103, 2413, 2414, 1973, -495, 620, 1987, 619, 1988, 1994, 1995, 1996, 2013, 2014, 1287, 619, 2016, 622, 2017, 2018, 2025, 2028, 2029, 619, 1770, 1771, 2035, 2036, 2039, 2042, 2051, 2053, 2055, 621, 2138, 620, 2074, 2075, 1288, 2064, 1289, 2065, 424, 620, 1137, 2066, 2071, 2072, 791, 1233, 2095, 620, 1233, 2077, 2096, 1423, 2130, 1923, 1923, 1923, 791, 2105, 621, 2110, 2118, -382, 1431, 2125, 2126, 1923, 2143, 2146, 644, 1290, 2150, 2149, 2151, 2207, 1291, 2152, 644, 2153, 1292, 2155, 2154, 2165, 1293, 2171, 424, 1294, 2458, 2460, 621, 2170, 2275, 2397, 688, 2187, 2230, 2189, 621, 2231, 2251, 2261, 2278, 2279, -225, 2303, 621, 2286, 2317, 1295, 2333, 2330, 622, 2185, 2311, 1195, 1196, 837, 2332, 2331, 611, 2336, 2334, 1296, 612, 613, 614, 615, -844, 1297, 2338, 2364, 2358, 2372, 2375, 2376, 2380, 616, 2386, 2387, 2399, 791, 622, 2389, 617, 2393, 618, 791, 1744, 2400, 622, 2407, 1952, 2409, 2193, 2410, 2411, 1495, 622, 2213, 2412, 2415, 2416, 2417, 2203, 2423, 2427, 2443, 2219, 2432, 2431, 2208, 1776, 2438, 619, 2440, 2445, 2471, 2474, 2489, 1233, 2482, 2497, 2491, 2499, 2501, 1845, 2505, 2201, 2519, 2526, 1522, 2510, 2518, 2514, 2517, 2527, 1525, 582, 2537, 2540, 1528, 620, 1530, 2559, 2542, 2543, 1532, 2551, 1534, 2577, 1321, 1322, 1323, 1324, 1325, 1326, 1327, 1328, 1329, 1330, 1331, 1332, 1333, 1334, 1335, 1336, 1337, 1338, 1339, 2567, 2573, 2582, 1895, 2597, 2599, 826, 2598, 611, 424, 2610, 1355, 612, 613, 614, 615, 2592, 2190, 1362, 1277, 1364, 1282, 1594, 2111, 1888, 616, 1517, 2388, 1454, 621, 1233, 1891, 617, 1912, 618, 1374, 924, 2112, 933, 936, 1049, 1613, 1923, 1916, 1923, 1923, 1923, 1923, 1923, 1923, 13, 14, 1314, 15, 16, 2309, 2391, 1315, 20, 2282, 2289, 893, 619, 2132, 2124, 1492, 23, 1405, 1757, 2012, 2329, 27, 1739, 2188, 30, 2342, 951, 1403, 1420, 1689, 952, 622, 37, 1059, 38, 1674, 40, 953, 954, 1979, 620, 1449, 1980, 955, 956, 439, 958, 2609, 2148, 960, 961, 962, 963, 964, 792, 2161, 951, 1050, 967, 59, 952, 1679, 819, 2031, 1709, 1943, 1233, 953, 954, 1154, 70, 604, 605, 606, 956, 607, 958, 424, 1942, 960, 961, 962, 963, 964, 1409, 1013, 2377, 1376, 967, 1435, 1463, 1183, 1510, 1016, 85, 1015, 1017, 621, 2420, 1691, 1018, 2308, 2562, 1694, 2191, 2097, 2448, 93, 1162, 1393, 1394, 2544, 1448, 1413, 2159, 2493, 2186, 765, 1474, 1404, 1146, 2457, 2563, 2581, 2603, 102, 2426, 2605, 2026, 1756, 2198, 104, 1022, 849, 1721, 2163, 1488, 1102, 791, 108, 691, 110, 1923, 112, 1853, 114, 1701, 739, 2199, 622, 2057, 2402, 119, 2061, 2044, 2063, 2047, 2430, 2216, 893, 1509, 838, 2059, 2218, 791, 1543, 2073, 1548, 1852, 130, 131, 1239, 2226, 2437, 1865, 2374, 1869, 2384, 1874, 831, 831, 0, 1882, 0, 752, 0, 0, 143, 0, 2193, 0, 0, 951, 0, 608, 1736, 952, 0, 0, 0, 0, 0, 0, 953, 954, 0, 0, 0, 155, 955, 956, 156, 958, 752, 0, 960, 961, 962, 963, 964, 752, 0, 966, 0, 967, 968, 0, 0, 812, 1558, 0, 0, 0, 0, 0, 1793, 0, 0, 1798, 0, 0, 1818, 0, 1831, 0, 1837, 0, 1841, 0, 0, 0, 0, 0, 0, 0, 2450, 0, 0, 0, 0, 2472, 0, 0, 0, 0, 1103, 1103, 0, 0, 2480, 0, 0, 0, 0, 0, 2484, 0, 2485, 0, 0, 0, 2433, 1233, 0, 0, 1609, 13, 14, 0, 15, 16, 0, 0, 0, 20, 0, 0, 1642, 0, 2486, 0, 0, 23, 0, 0, 0, 0, 27, 0, 0, 30, 2082, 2082, 0, 0, 0, 0, 0, 37, 2113, 38, 0, 40, 0, 611, 1649, 0, 0, 612, 613, 614, 615, 0, 1233, 0, 0, 0, 1655, 0, 0, 932, 616, 0, 0, 0, 59, 0, 0, 617, 0, 618, 0, 0, 0, 2403, 0, 70, 0, 0, 611, 0, 0, 0, 612, 613, 614, 615, 0, 0, 0, 0, 0, 0, 0, 0, 2486, 616, 2545, 619, 0, 85, 0, 0, 617, 0, 618, 1678, 1038, 2516, 0, 0, 0, 0, 93, 0, 0, 0, 0, 0, 0, 0, 1690, 0, 0, 752, 0, 620, 0, 1698, 0, 0, 102, 0, 619, 2583, 0, 0, 104, 893, 2584, 0, 0, 0, 0, 1708, 108, 1711, 110, 0, 112, 0, 114, 2584, 0, 2604, 2607, 0, 0, 119, 893, 0, 620, 1473, 424, 0, 611, 0, 2607, 0, 612, 613, 614, 615, 1726, 0, 130, 131, 0, 0, 0, 0, 0, 616, 621, 1738, 0, 0, 0, 0, 617, 0, 618, 0, 143, 0, 0, 0, 1752, 424, 0, 0, 0, 1758, 837, 1764, 0, 611, 0, 0, 0, 612, 613, 614, 615, 155, 0, 1085, 156, 621, 619, 0, 0, 2043, 616, 0, 0, 0, 2046, 0, 0, 617, 0, 618, 0, 1104, 622, 0, 0, 0, 0, 2056, 0, 0, 0, 0, 0, 0, 620, 1136, 0, 0, 0, 0, 0, 0, 951, 1142, 1143, 0, 952, 619, 1149, 2058, 0, 0, 0, 953, 954, 2060, 0, 622, 0, 2062, 956, 0, -1192, 0, 0, -1192, -1192, -1192, -1192, -1192, 0, 424, 0, 0, 967, 620, 1104, 0, 0, 0, 1037, 0, 0, 611, 1176, 0, 0, 612, 613, 614, 615, 621, 0, 0, 0, 0, 1473, 1896, 0, 611, 616, 0, 0, 612, 613, 614, 615, 617, 985, 618, 0, 0, 424, 1198, 0, 1201, 616, 0, 0, 0, 0, 0, 0, 617, 0, 618, 0, 0, 0, 0, 0, 0, 621, 0, 752, 752, 0, 619, 1940, 826, 1355, 0, 0, 622, 0, 0, 0, 1725, 1250, 1149, 611, 0, 0, 619, 612, 613, 614, 615, 0, 0, 0, 0, 0, 0, 0, 620, 0, 616, 0, 1960, 0, 0, 1962, 0, 617, 0, 618, 0, 0, 1751, 1966, 620, 611, 0, 622, 0, 612, 613, 614, 615, 0, 0, 0, 0, 0, 0, 0, 0, 0, 616, 0, 0, 424, 0, 619, 0, 617, 0, 618, 0, 0, 0, 1989, 0, 1992, 0, 0, 0, 424, 0, 0, 0, 621, 0, 0, 0, 0, 0, 1346, 1346, 0, 0, 620, 0, 0, 0, 619, 0, 621, 0, 0, 0, 0, 0, 2200, 0, 0, 0, 0, 0, 0, 0, 0, 0, 752, 752, 0, 0, 2211, 0, 0, 0, 0, 2214, 620, 0, 2215, 0, 0, 424, 0, 0, 0, 0, 622, 0, 2222, 0, 2223, 0, 2224, 1250, 2225, 0, 0, 0, 0, 0, 0, 621, 622, 0, 0, 0, 0, 0, 0, 0, 0, 951, 0, 424, 0, 952, 1414, 0, 0, 0, 0, 0, 953, 954, 0, 0, 0, 0, 955, 956, 957, 958, 0, 621, 960, 961, 962, 963, 964, 965, 378, 966, 0, 967, 968, 0, 384, 0, 0, 0, 0, 0, 0, 622, 752, 0, 391, 0, 0, 393, 0, 0, 396, 0, 0, 0, 0, 0, 0, 402, 0, 0, 2093, 409, 0, 0, 0, 412, 0, 2102, 0, 0, 0, 2106, 2107, 622, 0, 0, 0, 0, 0, 2114, 0, 0, 0, 431, 0, 0, 0, 435, 436, 0, 0, 0, 0, 441, 442, 0, 0, 0, 0, 447, 448, 0, 450, 451, 452, 453, 0, 454, 0, 0, 0, 0, 0, 0, 0, 0, 463, 0, 0, 0, 2145, 467, 0, 469, 0, 0, 1649, 472, 0, 0, 0, 476, 1104, 478, 0, 0, 0, 0, 0, 0, 484, 0, 0, 0, 488, 0, 0, 0, 491, 0, 493, 2164, 0, 0, 0, 0, 1991, 501, 503, 611, 2169, 505, 506, 612, 613, 614, 615, 512, 0, 513, 0, 0, 0, 517, 0, 611, 616, 2179, 2180, 612, 613, 614, 615, 617, 0, 618, 0, 0, 0, 0, 0, 611, 616, 0, 0, 612, 1005, 614, 615, 617, 544, 618, 546, 0, 0, 0, 1752, 0, 616, 551, 552, 0, 0, 619, 838, 617, 0, 618, 0, 0, 0, 0, 0, 0, 2210, 0, 0, 0, 0, 619, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2220, 620, 2221, 0, 0, 619, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 620, 0, 0, 0, 0, 0, 1612, 0, 0, 0, 0, 0, 0, 0, 0, 0, 620, 0, 0, 0, 0, 424, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 424, 0, 0, 0, 621, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 424, 0, 0, 0, 621, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 752, 0, 0, 621, 0, 0, 0, 0, 0, 0, 2296, 0, 0, 0, 0, 2298, 0, 0, 0, 0, 0, 0, 0, 622, 0, 0, 2307, 1966, 0, 0, 0, 2312, 0, 0, 0, 0, 0, 0, 0, 622, 0, 2315, 0, 0, 0, 0, 0, 2328, 0, 0, 0, 0, 951, 0, 0, 622, 952, 611, 0, 0, 0, 0, 0, 953, 954, 0, 1085, 969, 1085, 955, 956, 957, 958, 959, 0, 960, 961, 962, 963, 964, 965, 0, 966, 0, 967, 968, 0, 1104, 1104, 0, 0, 2373, 0, 0, 0, 0, 724, 0, 1723, 0, 0, 0, 0, 0, 752, 0, 1733, 0, 0, 1735, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2379, 812, 0, 0, 0, 1104, 1104, 0, 0, 0, 0, 0, 0, 0, 0, 2385, 0, 0, 0, 0, 0, 1609, 0, 0, 0, 0, 0, 752, 0, 0, 0, 0, 0, 0, 1800, 0, 0, 0, 0, 0, 0, 0, 0, 752, 752, 752, 0, 752, 752, 0, 0, 752, 0, 0, 0, 0, 0, 2404, 951, 0, 1727, 0, 952, 611, 0, 0, 0, 0, 1250, 953, 954, 0, 893, 0, 1728, 955, 956, 957, 958, 0, 851, 960, 961, 962, 963, 964, 965, 0, 966, 0, 967, 968, 0, 0, 1112, 0, 0, 1130, 1113, 611, 0, 969, 0, 0, 0, 1114, 1115, 0, 0, 0, 0, 1116, 1117, 1118, 1119, 0, 0, 1120, 1121, 1122, 1123, 1124, 1125, 1126, 1127, 0, 1128, 1129, 0, 0, 0, 0, 1914, 0, 2447, 2298, 0, 0, 2449, 0, 2453, 0, 0, 0, 0, 0, 0, 0, 969, 0, 0, 0, 0, 0, 0, 2464, 2465, 0, 2469, 0, 969, 0, 0, 0, 752, 0, 0, 0, 2479, 0, 0, 0, 0, 951, 0, 1180, 2483, 952, 611, 0, 0, 0, 0, 0, 953, 954, 0, 0, 0, 0, 955, 956, 957, 958, 2404, 0, 960, 961, 962, 963, 964, 965, 0, 966, 0, 967, 968, 0, 0, 0, 969, 969, 969, 969, 0, 969, 0, 0, 0, 0, 0, 0, 2515, 752, 752, 752, 0, 0, 0, 0, 2520, 2522, 0, 0, 0, 0, 0, 0, 0, 0, 0, 838, 0, 0, 2534, 0, 0, 0, 2536, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 969, 0, 969, 969, 969, 969, 1104, 0, 0, 0, 0, 0, 0, 893, 0, 0, 0, 0, 0, 0, 2522, 0, 0, 0, 2564, 0, 0, 0, 2568, 0, 0, 0, 1764, 0, 0, 0, 0, 0, 0, 951, 0, 0, 1246, 952, 611, 0, 1764, 2580, 2564, 0, 953, 954, 0, 0, 0, 0, 955, 956, 957, 958, 0, 969, 960, 961, 962, 963, 964, 965, 0, 966, 0, 967, 968, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 969, 0, 0, 0, 0, 0, 0, 0, 0, 0, 969, 0, 0, 0, 0, 0, 0, 1250, 752, 0, 0, 752, 0, 1104, 1104, 1104, 0, 1149, 1149, 1250, 0, 969, 0, 0, 0, 1149, 1149, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 969, 0, 0, 0, 969, 969, 0, 0, 0, 951, 0, 0, 1247, 952, 611, 1346, 1346, 1346, 1346, 1346, 953, 954, 0, 0, 0, 0, 955, 956, 957, 958, 0, 0, 960, 961, 962, 963, 964, 965, 0, 966, 0, 967, 968, 0, 0, 0, 0, 0, 0, 951, 0, 0, 1248, 952, 611, 0, 0, 0, 0, 0, 953, 954, 969, 0, 0, 1250, 955, 956, 957, 958, 0, 1414, 960, 961, 962, 963, 964, 965, 0, 966, 0, 967, 968, 951, 0, 0, 0, 952, 611, 0, 0, 0, 1303, 0, 953, 954, 0, 0, 0, 1319, 955, 956, 957, 958, 752, 2183, 960, 961, 962, 963, 964, 965, 0, 966, 0, 967, 968, 0, 0, 0, 969, 969, 0, 0, 951, 0, 0, 812, 952, 611, 0, 0, 0, 0, 0, 953, 954, 0, 1104, 0, 1398, 955, 956, 957, 958, 0, 0, 960, 961, 962, 963, 964, 965, 0, 966, 0, 967, 968, 0, 2217, 0, 0, 0, 951, 0, 1406, 0, 952, 611, 0, 0, 0, 0, 0, 953, 954, 0, 0, 0, 0, 955, 956, 957, 958, 752, 2229, 960, 961, 962, 963, 964, 965, 1383, 966, 0, 967, 968, 951, 0, 1421, 0, 952, 611, 0, 0, 0, 0, 0, 953, 954, 0, 0, 0, 0, 955, 956, 957, 958, 0, 0, 960, 961, 962, 963, 964, 965, 0, 966, 0, 967, 968, 0, 0, 0, 0, 0, 0, 1914, 0, 0, 0, 0, 0, 0, 0, 0, 969, 969, 969, 969, 969, 969, 969, 969, 969, 969, 969, 969, 969, 969, 969, 969, 969, 969, 969, 0, 0, 2302, 0, 0, 752, 0, 2305, 0, 0, 0, 0, 0, 0, 0, 969, 0, 0, 0, 0, 0, 951, 969, 0, 969, 952, 611, 0, 0, 0, 0, 0, 953, 954, 969, 0, 0, 1433, 955, 956, 957, 958, 0, 0, 960, 961, 962, 963, 964, 965, 0, 966, 0, 967, 968, 951, 0, 0, 0, 952, 611, 0, 0, 0, 0, 969, 953, 954, 0, 0, 0, 1436, 955, 956, 957, 958, 0, 1250, 960, 961, 962, 963, 964, 965, 0, 966, 0, 967, 968, 951, 0, 0, 0, 952, 611, 0, 0, 0, 0, 0, 953, 954, 0, 1250, 0, 1437, 955, 956, 957, 958, 0, 0, 960, 961, 962, 963, 964, 965, 0, 966, 0, 967, 968, 0, 0, 0, 951, 0, 0, 0, 952, 611, 0, 0, 969, 0, 0, 953, 954, 0, 0, 0, 1472, 955, 956, 957, 958, 0, 969, 960, 961, 962, 963, 964, 965, 0, 966, 0, 967, 968, 0, 0, 0, 0, 0, 0, 0, 0, 0, 969, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1104, 951, 0, 0, 1104, 952, 611, 0, 0, 0, 0, 0, 953, 954, 1599, 0, 0, 1519, 955, 956, 957, 958, 0, 0, 960, 961, 962, 963, 964, 965, 0, 966, 951, 967, 968, 0, 952, 611, 0, 969, 0, 752, 752, 953, 954, 0, 0, 0, 1520, 955, 956, 957, 958, 0, 0, 960, 961, 962, 963, 964, 965, 0, 966, 0, 967, 968, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1104, 1104, 1104, 1104, 0, 951, 0, 0, 2183, 952, 611, 0, 0, 0, 0, 969, 953, 954, 752, 0, 0, 1659, 955, 956, 957, 958, 0, 0, 960, 961, 962, 963, 964, 965, 0, 966, 0, 967, 968, 0, 951, 0, 0, 0, 952, 611, 0, 0, 969, 0, 0, 953, 954, 0, 0, 969, 1934, 955, 956, 957, 958, 969, 1104, 960, 961, 962, 963, 964, 965, 0, 966, 0, 967, 968, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 969, 0, 0, 1104, 1104, 0, 1104, 0, 0, 0, 0, 0, 969, 2183, 0, 0, 0, 951, 0, 1727, 969, 952, 611, 0, 0, 0, 0, 0, 953, 954, 969, 0, 0, 969, 955, 956, 957, 958, 0, 0, 960, 961, 962, 963, 964, 965, 0, 966, 969, 967, 968, 0, 0, 0, 0, 0, 1104, 0, 0, 0, 969, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 969, 0, 0, 0, 0, 0, 969, 0, 380, 381, 382, 383, 969, 385, 0, 386, 0, 388, 389, 0, 390, 0, 0, 0, 392, 0, 394, 395, 0, 0, 397, 398, 399, 0, 401, 0, 403, 404, 0, 0, 411, 0, 0, 0, 0, 414, 415, 416, 417, 418, 419, 420, 421, 0, 422, 423, 0, 0, 428, 429, 430, 0, 432, 0, 434, 0, 0, 437, 438, 0, 0, 0, 0, 0, 0, 445, 446, 0, 0, 449, 0, 0, 0, 0, 0, 0, 455, 0, 457, 0, 458, 459, 0, 0, 0, 464, 465, 466, 0, 0, 468, 0, 0, 470, 471, 0, 473, 474, 475, 0, 0, 0, 0, 480, 481, 0, 0, 483, 0, 485, 486, 487, 0, 489, 490, 0, 0, 492, 0, 494, 495, 496, 497, 498, 499, 0, 0, 0, 0, 0, 0, 507, 508, 509, 969, 0, 0, 0, 514, 515, 516, 0, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 0, 545, 0, 547, 0, 548, 0, 549, 550, 0, 969, 553, 554, 555, 556, 557, 558, 559, 560, 0, 0, 0, 951, 0, 0, 0, 952, 611, 0, 0, 969, 0, 969, 953, 954, 0, 969, 0, 1972, 955, 956, 957, 958, 0, 0, 960, 961, 962, 963, 964, 965, 0, 966, 0, 967, 968, 0, 0, 0, 969, 0, 0, 969, 0, 0, 0, 0, 0, 951, 0, 1990, 638, 952, 611, 651, 0, 654, 0, 0, 953, 954, 0, 0, 0, 1130, 955, 956, 957, 958, 0, 0, 960, 961, 962, 963, 964, 965, 0, 966, 951, 967, 968, 0, 952, 611, 0, 0, 0, 0, 0, 953, 954, 0, 0, 0, 2022, 955, 956, 957, 958, 0, 0, 960, 961, 962, 963, 964, 965, 0, 966, 0, 967, 968, 0, 951, 0, 2166, 0, 952, 611, 0, 0, 0, 0, 0, 953, 954, 0, 0, 0, 0, 955, 956, 957, 958, 0, 0, 960, 961, 962, 963, 964, 965, 969, 966, 0, 967, 968, 0, 951, 0, 2181, 969, 952, 611, 0, 969, 969, 0, 0, 953, 954, 0, 0, 969, 0, 955, 956, 957, 958, 0, 0, 960, 961, 962, 963, 964, 965, 0, 966, 951, 967, 968, 2260, 952, 611, 0, 0, 0, 0, 0, 953, 954, 0, 0, 969, 0, 955, 956, 957, 958, 0, 0, 960, 961, 962, 963, 964, 965, 0, 966, 0, 967, 968, 969, 0, 951, 0, 0, 969, 952, 611, 0, 0, 0, 0, 0, 953, 954, 969, 969, 0, 2272, 955, 956, 957, 958, 0, 0, 960, 961, 962, 963, 964, 965, 0, 966, 0, 967, 968, 0, 0, 0, 0, 0, 0, 0, 951, 0, 0, 969, 952, 611, 0, 0, 0, 0, 0, 953, 954, 969, 969, 0, 2280, 955, 956, 957, 958, 0, 0, 960, 961, 962, 963, 964, 965, 0, 966, 951, 967, 968, 0, 952, 611, 0, 0, 0, 0, 0, 953, 954, 0, 0, 0, 2295, 955, 956, 957, 958, 0, 0, 960, 961, 962, 963, 964, 965, 0, 966, 0, 967, 968, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 969, 0, 969, 951, 0, 0, 2306, 952, 611, 0, 0, 969, 0, 0, 953, 954, 969, 0, 0, 969, 955, 956, 957, 958, 0, 0, 960, 961, 962, 963, 964, 965, 969, 966, 0, 967, 968, 0, 951, 0, 0, 0, 952, 611, 0, 0, 0, 0, 0, 953, 954, 0, 941, 942, 2310, 955, 956, 957, 958, 0, 0, 960, 961, 962, 963, 964, 965, 0, 966, 0, 967, 968, 0, 0, 951, 0, 0, 969, 952, 611, 0, 0, 0, 969, 0, 953, 954, 0, 0, 969, 2369, 955, 956, 957, 958, 0, 0, 960, 961, 962, 963, 964, 965, 0, 966, 951, 967, 968, 969, 952, 611, 0, 0, 0, 0, 0, 953, 954, 0, 0, 0, 2370, 955, 956, 957, 958, 0, 0, 960, 961, 962, 963, 964, 965, 0, 966, 0, 967, 968, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 969, 0, 969, 0, 0, 0, 969, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 969, 969, 0, 0, 0, 969, 951, 0, 0, 2394, 952, 611, 0, 0, 0, 969, 0, 953, 954, 969, 0, 0, 0, 955, 956, 957, 958, 0, 0, 960, 961, 962, 963, 964, 965, 0, 966, 0, 967, 968, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 969, 0, 0, 0, 0, 969, 0, 969, 0, 0, 0, 951, 0, 0, 0, 952, 611, 9, 0, 969, 0, 969, 953, 954, 10, 0, 0, 2401, 955, 956, 957, 958, 0, 0, 960, 961, 962, 963, 964, 965, 0, 966, 0, 967, 968, 0, 0, 0, 0, 969, 0, 0, 0, 969, 11, 12, 13, 14, 0, 15, 16, 17, 18, 19, 20, 969, 0, 21, 22, 0, 0, 0, 23, 24, 25, 0, 26, 27, 28, 29, 30, 31, 0, 32, 33, 34, 35, 36, 37, 0, 38, 39, 40, 41, 42, 43, 0, 0, 44, 45, 46, 47, 48, 0, 0, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 0, 71, 0, 72, 73, 0, 74, 75, 76, 0, 0, 77, 0, 0, 78, 79, 0, 80, 81, 82, 83, 0, 84, 85, 86, 87, 88, 89, 90, 91, 92, 0, 0, 0, 0, 0, 93, 94, 95, 96, 0, 0, 0, 0, 97, 0, 0, 98, 99, 0, 0, 100, 101, 0, 102, 0, 0, 0, 103, 0, 104, 0, 105, 0, 0, 0, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 0, 116, 117, 118, 0, 119, 0, 120, 121, 0, 122, 0, 123, 124, 125, 126, 0, 0, 127, 128, 129, 0, 130, 131, 132, 0, 133, 134, 135, 0, 136, 0, 137, 138, 139, 140, 141, 0, 142, 0, 143, 144, 0, 0, 145, 146, 147, 0, 0, 148, 149, 0, 150, 151, 0, 152, 153, 0, 0, 0, 154, 155, 0, 0, 156, 0, 0, 157, 0, 0, 0, 158, 159, 0, 0, 160, 161, 162, 0, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 0, 174, 0, 0, 175, 0, 0, 0, 176, 177, 178, 179, 180, 0, 181, 182, 0, 0, 183, 184, 185, 186, 0, 0, 0, 0, 187, 188, 189, 190, 191, 192, 0, 0, 0, 0, 0, 0, 0, 193, 0, 194, 0, 195, 196, 197, 198, 199, 0, 0, 0, 200, 201, 202, 203, 204, 205, 951, 206, 207, 2418, 952, 611, 208, 0, 0, 0, 0, 953, 954, 0, 0, 0, 0, 955, 956, 957, 958, 0, 0, 960, 961, 962, 963, 964, 965, 0, 966, 951, 967, 968, 2436, 952, 611, 0, 0, 0, 0, 0, 953, 954, 0, 0, 0, 0, 955, 956, 957, 958, 0, 0, 960, 961, 962, 963, 964, 965, 0, 966, 951, 967, 968, 0, 952, 611, 0, 0, 0, 0, 0, 953, 954, 0, 0, 0, 2442, 955, 956, 957, 958, 0, 0, 960, 961, 962, 963, 964, 965, 0, 966, 951, 967, 968, 2490, 952, 611, 0, 0, 0, 0, 0, 953, 954, 0, 0, 0, 0, 955, 956, 957, 958, 0, 0, 960, 961, 962, 963, 964, 965, 0, 966, 951, 967, 968, 0, 952, 611, 0, 0, 0, 0, 0, 953, 954, 0, 0, 0, 2492, 955, 956, 957, 958, 0, 0, 960, 961, 962, 963, 964, 965, 0, 966, 951, 967, 968, 0, 952, 611, 0, 0, 0, 0, 0, 953, 954, 0, 0, 0, 2503, 955, 956, 957, 958, 0, 0, 960, 961, 962, 963, 964, 965, 0, 966, 951, 967, 968, 2504, 952, 611, 0, 0, 0, 0, 0, 953, 954, 0, 0, 0, 0, 955, 956, 957, 958, 0, 0, 960, 961, 962, 963, 964, 965, 0, 966, 951, 967, 968, 2508, 952, 611, 0, 0, 0, 0, 0, 953, 954, 0, 0, 0, 0, 955, 956, 957, 958, 0, 0, 960, 961, 962, 963, 964, 965, 0, 966, 951, 967, 968, 0, 952, 611, 0, 0, 0, 0, 0, 953, 954, 0, 0, 0, 2513, 955, 956, 957, 958, 0, 0, 960, 961, 962, 963, 964, 965, 0, 966, 951, 967, 968, 0, 952, 611, 0, 0, 0, 0, 0, 953, 954, 0, 0, 0, 2541, 955, 956, 957, 958, 0, 0, 960, 961, 962, 963, 964, 965, 0, 966, 951, 967, 968, 2555, 952, 611, 0, 0, 0, 0, 0, 953, 954, 0, 0, 0, 0, 955, 956, 957, 958, 0, 0, 960, 961, 962, 963, 964, 965, 0, 966, 0, 967, 968, 951, 0, 2574, 0, 952, 611, 0, 0, 0, 0, 0, 953, 954, 0, 0, 0, 0, 955, 956, 957, 958, 0, 0, 960, 961, 962, 963, 964, 965, 0, 966, 951, 967, 968, 0, 952, 611, 0, 0, 0, 0, 0, 953, 954, 0, 0, 0, 0, 955, 956, 957, 958, 0, 0, 960, 961, 962, 963, 964, 965, 0, 966, 0, 967, 968 }; static const yytype_int16 yycheck[] = { 50, 489, 486, 395, 381, 496, 497, 498, 499, 634, 1138, 767, 1031, 894, 544, 894, 378, 404, 925, 475, 1460, 390, 975, 638, 1311, 1498, 1340, 414, 1608, 416, 881, 62, 63, 433, 421, 422, 423, 613, 69, 257, 660, 210, 429, 754, 262, 432, 1987, 434, 1494, 1518, 981, 1638, 2027, 649, 1311, 1154, 391, 1716, 1717, 1718, 1071, 1866, 1614, 1868, 1614, 659, 660, 98, 118, 895, 7, 2096, 122, 259, 436, 1005, 262, 263, 63, 470, 747, 483, 1625, 659, 660, 849, 76, 1530, 1634, 849, 7, 453, 1373, 1639, 471, 1530, 480, 1915, 1530, 8, 1680, 8, 15, 1530, 1530, 467, 1530, 1530, 116, 99, 472, 20, 0, 1, 476, 94, 478, 7, 15, 232, 233, 391, 1920, 1921, 71, 238, 116, 183, 8, 491, 8, 8, 516, 8, 89, 191, 41, 8, 8, 2206, 20, 503, 20, 505, 182, 20, 1027, 116, 1027, 20, 512, 191, 208, 63, 144, 1166, 169, 8, 68, 175, 1179, 8, 677, 8, 5, 15, 7, 122, 15, 1050, 5, 5, 8, 191, 37, 20, 409, 15, 182, 116, 90, 91, 974, 975, 129, 641, 21, 8, 8, 645, 552, 5, 8, 129, 225, 208, 652, 2417, 8, 116, 155, 315, 1861, 116, 21, 1864, 8, 116, 804, 116, 1528, 129, 1530, 8, 1532, 15, 129, 212, 3, 1528, 8, 1530, 8, 1532, 58, 1534, 116, 172, 8, 8, 185, 21, 64, 18, 144, 37, 116, 351, 116, 116, 5, 116, 3, 578, 154, 116, 1560, 242, 166, 257, 483, 230, 86, 588, 589, 590, 591, 475, 7, 8, 21, 208, 150, 218, 282, 116, 129, 651, 637, 282, 654, 116, 37, 1528, 314, 1530, 257, 1532, 15, 767, 318, 262, 129, 1528, 1191, 1530, 2506, 1532, 129, 1534, 200, 129, 126, 129, 129, 116, 116, 252, 813, 149, 116, 357, 358, 137, 209, 284, 116, 2125, 324, 696, 2377, 315, 129, 23, 318, 129, 295, 266, 1446, 15, 257, 116, 592, 228, 15, 694, 728, 37, 116, 129, 116, 165, 1919, 129, 822, 1994, 116, 116, 287, 129, 257, 2139, 2140, 678, 257, 376, 377, 803, 257, 246, 257, 382, 383, 384, 385, 755, 387, 388, 1615, 1616, 391, 976, 393, 394, 395, 396, 701, 257, 399, 257, 1916, 402, 2313, 404, 1305, 1918, 1657, 257, 409, 257, 257, 412, 257, 414, 254, 416, 257, 15, 1831, 420, 421, 422, 423, 989, 1867, 991, 1831, 8, 429, 1831, 431, 432, 998, 434, 1831, 1831, 257, 1831, 1831, 440, 441, 1005, 257, 815, 1345, 2074, 447, 448, 802, 1438, 804, 452, 1178, 641, 258, 1189, 1093, 645, 459, 1005, 1190, 462, 8, 129, 652, 420, 257, 257, 129, 3, 1459, 257, 492, 474, 844, 47, 477, 257, 1378, 1379, 1380, 15, 483, 484, 485, 486, 437, 488, 489, 43, 1085, 8, 257, 798, 495, 496, 497, 498, 499, 257, 501, 257, 92, 504, 15, 506, 507, 257, 257, 510, 700, 15, 513, 67, 1495, 466, 517, 1418, 15, 8, 1110, 8, 473, 257, 475, 15, 716, 547, 82, 191, 1818, 2160, 194, 87, 88, 116, 1605, 1606, 843, 1818, 94, 846, 1304, 1831, 8, 546, 1110, 2542, 2543, 1837, 15, 191, 1831, 573, 16, 17, 2501, 129, 1837, 149, 580, 922, 1841, 564, 1110, 8, 992, 993, 994, 995, 996, 572, 148, 1857, 575, 576, 577, 578, 21, 2136, 2491, 8, 583, 584, 923, 2028, 587, 588, 589, 590, 591, 8, 1158, 1818, 595, 596, 2118, 2036, 2118, 116, 683, 2017, 8, 1818, 180, 177, 1831, 147, 148, 569, 570, 201, 1837, 129, 2127, 803, 1831, 773, 129, 64, 23, 581, 1837, 3, 763, 129, 1841, 116, 7, 116, 92, 970, 129, 149, 37, 15, 2547, 2412, 149, 129, 180, 8, 7, 8, 128, 7, 5, 5, 288, 669, 9, 9, 116, 1910, 16, 17, 23, 847, 1915, 299, 661, 662, 663, 664, 665, 666, 667, 687, 858, 670, 37, 5, 7, 157, 228, 8, 257, 678, 37, 37, 15, 15, 2559, 1910, 129, 875, 22, 149, 24, 8, 641, 3, 147, 148, 645, 696, 2573, 33, 699, 35, 701, 652, 8, 1042, 149, 259, 657, 8, 128, 244, 1561, 84, 1561, 1052, 26, 1536, 1537, 1538, 37, 1540, 1541, 8, 912, 724, 8, 180, 129, 747, 1318, 2286, 95, 37, 3, 217, 1460, 1461, 926, 157, 8, 201, 257, 15, 16, 17, 764, 7, 8, 2376, 749, 303, 751, 21, 1653, 754, 1318, 26, 2597, 2598, 778, 124, 1660, 1661, 1662, 1444, 8, 785, 767, 191, 257, 2610, 257, 3, 1318, 84, 1320, 8, 777, 860, 2141, 2142, 2143, 864, 8, 15, 208, 786, 869, 788, 21, 872, 873, 1692, 793, 257, 795, 21, 331, 798, 2427, 1365, 1366, 1367, 1368, 1369, 992, 993, 994, 995, 996, 18, 811, 346, 347, 348, 1378, 1379, 1380, 26, 191, 191, 8, 822, 158, 159, 1014, 161, 162, 828, 8, 1019, 195, 851, 1378, 1379, 1380, 208, 208, 202, 2388, 8, 8, 21, 843, 8, 63, 846, 15, 5, 931, 68, 933, 852, 803, 21, 8, 129, 192, 15, 282, 314, 315, 285, 882, 318, 319, 8, 290, 887, 2125, 8, 1060, 90, 91, 15, 298, 149, 896, 897, 898, 3, 191, 901, 21, 339, 3, 886, 342, 343, 344, 16, 17, 15, 265, 5, 21, 2338, 15, 208, 234, 355, 356, 902, 903, 15, 16, 17, 8, 1277, 15, 282, 282, 247, 285, 285, 8, 27, 289, 918, 8, 21, 8, 941, 8, 8, 36, 144, 299, 21, 8, 880, 881, 304, 257, 21, 5, 154, 21, 262, 5, 940, 8, 21, 9, 894, 904, 16, 17, 8, 8, 16, 17, 22, 64, 24, 265, 8, 23, 5, 8, 919, 21, 9, 33, 8, 35, 8, 37, 2410, 16, 17, 37, 282, 8, 21, 285, 23, 21, 8, 289, 290, 92, 200, 1905, 1906, 1907, 1908, 1909, 298, 299, 37, 21, 3, 8, 304, 8, 8, 8, 8, 8, 2409, 2284, 8, 8, 1308, 1024, 21, 41, 1354, 21, 1860, 21, 21, 231, 1352, 21, 21, 1893, 129, 7, 1358, 5, 1872, 1023, 1872, 9, 244, 8, 5, 1029, 7, 7, 16, 17, 8, 1035, 8, 71, 149, 1939, 21, 1766, 992, 993, 994, 995, 996, 21, 1048, 21, 1000, 1001, 1398, 37, 8, 1955, 8, 2499, 2155, 8, 1740, 1961, 1439, 1963, 1441, 1411, 8, 21, 1652, 21, 7, 8, 21, 1073, 1093, 1870, 1871, 1027, 1078, 21, 8, 1437, 1101, 1878, 1879, 1427, 1424, 1429, 2497, 159, 201, 8, 162, 21, 1094, 8, 1285, 1660, 1661, 1662, 1050, 135, 1863, 149, 21, 1955, 8, 1955, 21, 1109, 22, 1961, 24, 3, 1303, 1660, 1661, 1662, 1200, 21, 8, 33, 63, 35, 1206, 15, 1145, 68, 1210, 8, 1212, 1213, 1214, 21, 1216, 169, 1218, 15, 1088, 1470, 8, 1866, 21, 1868, 1905, 1906, 1907, 1908, 1909, 90, 91, 15, 5, 21, 8, 3, 9, 191, 8, 15, 8, 5, 149, 16, 17, 9, 8, 21, 21, 1188, 23, 21, 16, 17, 208, 209, 15, 247, 8, 21, 15, 8, 15, 124, 37, 8, 1517, 221, 8, 223, 224, 21, 226, 37, 21, 229, 862, 863, 5, 865, 15, 21, 9, 144, 15, 8, 8, 8, 37, 16, 17, 8, 1231, 154, 21, 15, 23, 129, 21, 21, 21, 1559, 352, 353, 21, 44, 8, 1246, 1247, 1248, 37, 1656, 8, 316, 317, 305, 306, 307, 8, 21, 15, 8, 8, 1432, 8, 21, 158, 159, 282, 161, 162, 21, 15, 1272, 21, 21, 15, 21, 15, 200, 5, 15, 7, 15, 8, 10, 410, 8, 87, 14, 15, 16, 17, 15, 93, 349, 350, 21, 1278, 1279, 192, 1780, 27, 1782, 1783, 15, 320, 15, 322, 34, 15, 36, 233, 8, 15, 1794, 15, 8, 2395, 15, 119, 15, 1302, 244, 8, 1804, 21, 1806, 1308, 1647, 21, 8, 1312, 15, 16, 17, 8, 21, 8, 64, 16, 17, 234, 8, 143, 27, 145, 8, 8, 21, 1412, 21, 124, 1671, 36, 247, 21, 8, 8, 8, 21, 21, 8, 1937, 2332, 1683, 1702, 92, 8, 1687, 21, 21, 21, 8, 8, 21, 8, 59, 8, 178, 8, 21, 64, 7, 183, 239, 21, 21, 187, 21, 15, 21, 191, 21, 15, 194, 252, 15, 522, 1944, 524, 2281, 2232, 1383, 129, 1615, 1616, 531, 532, 533, 92, 248, 249, 537, 538, 539, 540, 216, 542, 543, 1000, 1001, 8, 8, 149, 1487, 2306, 15, 2258, 5, 2258, 230, 15, 9, 10, 21, 21, 236, 14, 15, 16, 17, 8, 1373, 2593, 2594, 1426, 1427, 15, 1429, 8, 27, 8, 8, 15, 21, 8, 1437, 34, 1439, 36, 1441, 8, 21, 1444, 21, 21, 149, 8, 21, 8, 8, 8, 8, 8, 21, 201, 8, 8, 8, 8, 21, 8, 21, 21, 21, 21, 21, 64, 1656, 21, 21, 21, 21, 1493, 21, 1476, 15, 5, 8, 1669, 2474, 2475, 10, 8, 1485, 3, 14, 15, 16, 17, 1491, 21, 1512, 15, 1514, 92, 21, 8, 201, 27, 1501, 8, 8, 1660, 1661, 1662, 34, 15, 36, 124, 21, 15, 15, 246, 21, 21, 246, 1518, 15, 1539, 204, 205, 206, 207, 208, 21, 1477, 870, 871, 8, 7, 26, 129, 1553, 15, 15, 64, 15, 240, 8, 15, 1731, 8, 15, 15, 175, 5, 149, 1549, 1569, 9, 2540, 149, 8, 1574, 15, 15, 16, 17, 8, 8, 15, 1582, 8, 92, 8, 7, 129, 27, 1520, 1590, 15, 62, 26, 8, 15, 15, 36, 455, 21, 1600, 8, 1602, 287, 15, 1536, 1537, 1538, 213, 1540, 1541, 8, 8, 1544, 1595, 15, 16, 17, 8, 8, 15, 129, 8, 64, 201, 64, 9, 27, 2334, 1956, 1561, 9, 8, 490, 21, 8, 36, 8, 15, 37, 67, 149, 26, 500, 1625, 15, 15, 1959, 15, 15, 15, 15, 15, 92, 8, 2230, 5, 1638, 166, 15, 8, 10, 129, 7, 64, 14, 15, 16, 17, 7, 21, 21, 18, 26, 21, 37, 1657, 7, 27, 1660, 1661, 1662, 15, 7, 15, 34, 2028, 36, 8, 1670, 129, 816, 92, 201, 15, 8, 8, 554, 555, 556, 557, 558, 5, 2409, 7, 2411, 2412, 10, 26, 15, 149, 14, 15, 16, 17, 64, 21, 21, 15, 15, 15, 1702, 15, 15, 27, 1656, 1657, 166, 8, 129, 21, 34, 21, 36, 8, 5, 15, 15, 15, 62, 21, 1722, 8, 92, 7, 239, 8, 8, 8, 149, 8, 15, 255, 7, 166, 208, 613, 614, 615, 1740, 617, 64, 201, 15, 15, 2471, 21, 624, 16, 15, 15, 15, 2206, 191, 21, 8, 7, 15, 15, 331, 129, 638, 315, 332, 246, 1716, 1717, 1718, 15, 92, 2496, 2497, 15, 1774, 1775, 15, 15, 2116, 15, 5, 149, 201, 15, 15, 10, 15, 15, 2126, 14, 15, 16, 17, 15, 15, 15, 15, 15, 166, 1799, 15, 44, 27, 15, 680, 15, 15, 129, 7, 34, 5, 36, 246, 5, 9, 40, 21, 246, 5, 695, 15, 16, 17, 246, 2549, 246, 5, 149, 15, 16, 17, 10, 27, 201, 8, 14, 15, 16, 17, 64, 27, 36, 15, 1862, 87, 15, 21, 723, 27, 36, 8, 1851, 7, 21, 730, 34, 21, 36, 1877, 21, 736, 737, 1881, 2323, 2324, 8, 26, 92, 15, 64, 21, 15, 173, 8, 15, 15, 119, 64, 255, 201, 8, 7, 21, 15, 15, 64, 71, 208, 18, 8, 15, 15, 15, 15, 15, 149, 7, 92, 15, 15, 143, 21, 145, 21, 129, 92, 782, 21, 21, 21, 1860, 1861, 15, 92, 1864, 21, 15, 1061, 1918, 1919, 1920, 1921, 1872, 21, 149, 21, 8, 15, 1072, 5, 15, 1931, 9, 20, 129, 178, 26, 21, 21, 8, 183, 21, 129, 21, 187, 15, 21, 21, 191, 15, 129, 194, 2409, 2410, 149, 1974, 8, 2303, 1958, 26, 21, 26, 149, 26, 21, 21, 7, 21, 15, 8, 149, 26, 15, 216, 8, 21, 201, 1996, 254, 855, 856, 7, 15, 21, 10, 21, 132, 230, 14, 15, 16, 17, 7, 236, 7, 37, 21, 21, 15, 15, 354, 27, 7, 7, 255, 1955, 201, 21, 34, 21, 36, 1961, 2012, 15, 201, 15, 2016, 15, 2018, 15, 15, 1165, 201, 2042, 15, 15, 15, 15, 2028, 15, 7, 7, 2051, 8, 21, 2035, 2036, 8, 64, 8, 21, 8, 7, 21, 1994, 8, 7, 15, 7, 15, 2069, 21, 78, 8, 7, 1199, 78, 352, 330, 353, 7, 1205, 223, 21, 15, 1209, 92, 1211, 17, 15, 15, 1215, 15, 1217, 8, 951, 952, 953, 954, 955, 956, 957, 958, 959, 960, 961, 962, 963, 964, 965, 966, 967, 968, 969, 21, 17, 15, 5, 7, 15, 976, 7, 10, 129, 7, 981, 14, 15, 16, 17, 128, 2014, 988, 903, 990, 911, 1279, 1890, 1600, 27, 1192, 2281, 1097, 149, 2074, 1604, 34, 2127, 36, 1005, 586, 1891, 594, 597, 714, 1310, 2136, 1634, 2138, 2139, 2140, 2141, 2142, 2143, 45, 46, 940, 48, 49, 2168, 2286, 940, 53, 2118, 2138, 1031, 64, 1918, 1910, 1161, 61, 1037, 1501, 1741, 2188, 66, 1485, 2012, 69, 2207, 5, 1033, 1053, 1421, 9, 201, 77, 1053, 79, 1400, 81, 16, 17, 1713, 92, 1095, 1715, 22, 23, 75, 25, 2599, 1939, 28, 29, 30, 31, 32, 466, 1961, 5, 715, 37, 104, 9, 1407, 2206, 2207, 1444, 1656, 2160, 16, 17, 796, 115, 247, 247, 247, 23, 247, 25, 129, 1653, 28, 29, 30, 31, 32, 1042, 661, 2249, 1005, 37, 1078, 1109, 842, 1181, 664, 139, 663, 665, 149, 2333, 1423, 666, 2167, 2547, 1425, 2016, 2268, 2395, 152, 811, 1021, 1023, 2519, 1094, 1048, 1958, 2454, 1998, 445, 1138, 1035, 792, 2408, 2549, 2575, 2595, 170, 2341, 2597, 1766, 1499, 2019, 176, 670, 507, 1461, 1963, 1156, 765, 2232, 184, 385, 186, 2286, 188, 1553, 190, 1434, 418, 2023, 201, 1818, 2313, 197, 1837, 1793, 1841, 1798, 2364, 2048, 1179, 1180, 1181, 1831, 2049, 2258, 1231, 1851, 1238, 1549, 214, 215, 884, 2069, 2381, 1569, 2232, 1574, 2268, 1582, 2323, 2324, -1, 1590, -1, 437, -1, -1, 232, -1, 2333, -1, -1, 5, -1, 239, 1483, 9, -1, -1, -1, -1, -1, -1, 16, 17, -1, -1, -1, 253, 22, 23, 256, 25, 466, -1, 28, 29, 30, 31, 32, 473, -1, 35, -1, 37, 38, -1, -1, 481, 1249, -1, -1, -1, -1, -1, 1523, -1, -1, 1526, -1, -1, 1529, -1, 1531, -1, 1533, -1, 1535, -1, -1, -1, -1, -1, -1, -1, 2399, -1, -1, -1, -1, 2423, -1, -1, -1, -1, 2409, 2410, -1, -1, 2432, -1, -1, -1, -1, -1, 2438, -1, 2440, -1, -1, -1, 2375, 2376, -1, -1, 1305, 45, 46, -1, 48, 49, -1, -1, -1, 53, -1, -1, 1317, -1, 2443, -1, -1, 61, -1, -1, -1, -1, 66, -1, -1, 69, 2474, 2475, -1, -1, -1, -1, -1, 77, 5, 79, -1, 81, -1, 10, 1345, -1, -1, 14, 15, 16, 17, -1, 2427, -1, -1, -1, 1357, -1, -1, 593, 27, -1, -1, -1, 104, -1, -1, 34, -1, 36, -1, -1, -1, 5, -1, 115, -1, -1, 10, -1, -1, -1, 14, 15, 16, 17, -1, -1, -1, -1, -1, -1, -1, -1, 2519, 27, 2521, 64, -1, 139, -1, -1, 34, -1, 36, 1406, 1407, 2482, -1, -1, -1, -1, 152, -1, -1, -1, -1, -1, -1, -1, 1421, -1, -1, 657, -1, 92, -1, 1428, -1, -1, 170, -1, 64, 2577, -1, -1, 176, 1438, 2582, -1, -1, -1, -1, 1444, 184, 1446, 186, -1, 188, -1, 190, 2595, -1, 2597, 2598, -1, -1, 197, 1459, -1, 92, 7, 129, -1, 10, -1, 2610, -1, 14, 15, 16, 17, 1473, -1, 214, 215, -1, -1, -1, -1, -1, 27, 149, 1484, -1, -1, -1, -1, 34, -1, 36, -1, 232, -1, -1, -1, 1497, 129, -1, -1, -1, 1502, 7, 1504, -1, 10, -1, -1, -1, 14, 15, 16, 17, 253, -1, 749, 256, 149, 64, -1, -1, 1790, 27, -1, -1, -1, 1795, -1, -1, 34, -1, 36, -1, 767, 201, -1, -1, -1, -1, 1808, -1, -1, -1, -1, -1, -1, 92, 781, -1, -1, -1, -1, -1, -1, 5, 789, 790, -1, 9, 64, 794, 1830, -1, -1, -1, 16, 17, 1836, -1, 201, -1, 1840, 23, -1, 25, -1, -1, 28, 29, 30, 31, 32, -1, 129, -1, -1, 37, 92, 822, -1, -1, -1, 7, -1, -1, 10, 830, -1, -1, 14, 15, 16, 17, 149, -1, -1, -1, -1, 7, 1610, -1, 10, 27, -1, -1, 14, 15, 16, 17, 34, 166, 36, -1, -1, 129, 859, -1, 861, 27, -1, -1, -1, -1, -1, -1, 34, -1, 36, -1, -1, -1, -1, -1, -1, 149, -1, 880, 881, -1, 64, 1651, 1652, 1653, -1, -1, 201, -1, -1, -1, 7, 894, 895, 10, -1, -1, 64, 14, 15, 16, 17, -1, -1, -1, -1, -1, -1, -1, 92, -1, 27, -1, 1682, -1, -1, 1685, -1, 34, -1, 36, -1, -1, 7, 1693, 92, 10, -1, 201, -1, 14, 15, 16, 17, -1, -1, -1, -1, -1, -1, -1, -1, -1, 27, -1, -1, 129, -1, 64, -1, 34, -1, 36, -1, -1, -1, 1725, -1, 1727, -1, -1, -1, 129, -1, -1, -1, 149, -1, -1, -1, -1, -1, 974, 975, -1, -1, 92, -1, -1, -1, 64, -1, 149, -1, -1, -1, -1, -1, 2025, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1000, 1001, -1, -1, 2039, -1, -1, -1, -1, 2044, 92, -1, 2047, -1, -1, 129, -1, -1, -1, -1, 201, -1, 2057, -1, 2059, -1, 2061, 1027, 2063, -1, -1, -1, -1, -1, -1, 149, 201, -1, -1, -1, -1, -1, -1, -1, -1, 5, -1, 129, -1, 9, 1050, -1, -1, -1, -1, -1, 16, 17, -1, -1, -1, -1, 22, 23, 24, 25, -1, 149, 28, 29, 30, 31, 32, 33, 12, 35, -1, 37, 38, -1, 18, -1, -1, -1, -1, -1, -1, 201, 1088, -1, 28, -1, -1, 31, -1, -1, 34, -1, -1, -1, -1, -1, -1, 41, -1, -1, 1873, 45, -1, -1, -1, 49, -1, 1880, -1, -1, -1, 1884, 1885, 201, -1, -1, -1, -1, -1, 1892, -1, -1, -1, 67, -1, -1, -1, 71, 72, -1, -1, -1, -1, 77, 78, -1, -1, -1, -1, 83, 84, -1, 86, 87, 88, 89, -1, 91, -1, -1, -1, -1, -1, -1, -1, -1, 100, -1, -1, -1, 1933, 105, -1, 107, -1, -1, 1939, 111, -1, -1, -1, 115, 1178, 117, -1, -1, -1, -1, -1, -1, 124, -1, -1, -1, 128, -1, -1, -1, 132, -1, 134, 1964, -1, -1, -1, -1, 7, 141, 142, 10, 1973, 145, 146, 14, 15, 16, 17, 151, -1, 153, -1, -1, -1, 157, -1, 10, 27, 1990, 1991, 14, 15, 16, 17, 34, -1, 36, -1, -1, -1, -1, -1, 10, 27, -1, -1, 14, 15, 16, 17, 34, 184, 36, 186, -1, -1, -1, 2019, -1, 27, 193, 194, -1, -1, 64, 2027, 34, -1, 36, -1, -1, -1, -1, -1, -1, 2037, -1, -1, -1, -1, 64, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2053, 92, 2055, -1, -1, 64, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 92, -1, -1, -1, -1, -1, 1309, -1, -1, -1, -1, -1, -1, -1, -1, -1, 92, -1, -1, -1, -1, 129, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 129, -1, -1, -1, 149, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 129, -1, -1, -1, 149, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1373, -1, -1, 149, -1, -1, -1, -1, -1, -1, 2150, -1, -1, -1, -1, 2155, -1, -1, -1, -1, -1, -1, -1, 201, -1, -1, 2166, 2167, -1, -1, -1, 2171, -1, -1, -1, -1, -1, -1, -1, 201, -1, 2181, -1, -1, -1, -1, -1, 2187, -1, -1, -1, -1, 5, -1, -1, 201, 9, 10, -1, -1, -1, -1, -1, 16, 17, -1, 1439, 625, 1441, 22, 23, 24, 25, 26, -1, 28, 29, 30, 31, 32, 33, -1, 35, -1, 37, 38, -1, 1460, 1461, -1, -1, 2231, -1, -1, -1, -1, 407, -1, 1471, -1, -1, -1, -1, -1, 1477, -1, 1479, -1, -1, 1482, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2260, 1494, -1, -1, -1, 1498, 1499, -1, -1, -1, -1, -1, -1, -1, -1, 2275, -1, -1, -1, -1, -1, 2281, -1, -1, -1, -1, -1, 1520, -1, -1, -1, -1, -1, -1, 1527, -1, -1, -1, -1, -1, -1, -1, -1, 1536, 1537, 1538, -1, 1540, 1541, -1, -1, 1544, -1, -1, -1, -1, -1, 2317, 5, -1, 7, -1, 9, 10, -1, -1, -1, -1, 1561, 16, 17, -1, 2332, -1, 21, 22, 23, 24, 25, -1, 511, 28, 29, 30, 31, 32, 33, -1, 35, -1, 37, 38, -1, -1, 5, -1, -1, 775, 9, 10, -1, 779, -1, -1, -1, 16, 17, -1, -1, -1, -1, 22, 23, 24, 25, -1, -1, 28, 29, 30, 31, 32, 33, 34, 35, -1, 37, 38, -1, -1, -1, -1, 1625, -1, 2394, 2395, -1, -1, 2398, -1, 2400, -1, -1, -1, -1, -1, -1, -1, 826, -1, -1, -1, -1, -1, -1, 2415, 2416, -1, 2418, -1, 838, -1, -1, -1, 1657, -1, -1, -1, 2428, -1, -1, -1, -1, 5, -1, 7, 2436, 9, 10, -1, -1, -1, -1, -1, 16, 17, -1, -1, -1, -1, 22, 23, 24, 25, 2454, -1, 28, 29, 30, 31, 32, 33, -1, 35, -1, 37, 38, -1, -1, -1, 888, 889, 890, 891, -1, 893, -1, -1, -1, -1, -1, -1, 2482, 1716, 1717, 1718, -1, -1, -1, -1, 2490, 2491, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2501, -1, -1, 2504, -1, -1, -1, 2508, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 945, -1, 947, 948, 949, 950, 1766, -1, -1, -1, -1, -1, -1, 2540, -1, -1, -1, -1, -1, -1, 2547, -1, -1, -1, 2551, -1, -1, -1, 2555, -1, -1, -1, 2559, -1, -1, -1, -1, -1, -1, 5, -1, -1, 8, 9, 10, -1, 2573, 2574, 2575, -1, 16, 17, -1, -1, -1, -1, 22, 23, 24, 25, -1, 1006, 28, 29, 30, 31, 32, 33, -1, 35, -1, 37, 38, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1028, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1038, -1, -1, -1, -1, -1, -1, 1860, 1861, -1, -1, 1864, -1, 1866, 1867, 1868, -1, 1870, 1871, 1872, -1, 1059, -1, -1, -1, 1878, 1879, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1075, -1, -1, -1, 1079, 1080, -1, -1, -1, 5, -1, -1, 8, 9, 10, 1905, 1906, 1907, 1908, 1909, 16, 17, -1, -1, -1, -1, 22, 23, 24, 25, -1, -1, 28, 29, 30, 31, 32, 33, -1, 35, -1, 37, 38, -1, -1, -1, -1, -1, -1, 5, -1, -1, 8, 9, 10, -1, -1, -1, -1, -1, 16, 17, 1137, -1, -1, 1955, 22, 23, 24, 25, -1, 1961, 28, 29, 30, 31, 32, 33, -1, 35, -1, 37, 38, 5, -1, -1, -1, 9, 10, -1, -1, -1, 920, -1, 16, 17, -1, -1, -1, 21, 22, 23, 24, 25, 1994, 1995, 28, 29, 30, 31, 32, 33, -1, 35, -1, 37, 38, -1, -1, -1, 1195, 1196, -1, -1, 5, -1, -1, 2017, 9, 10, -1, -1, -1, -1, -1, 16, 17, -1, 2028, -1, 21, 22, 23, 24, 25, -1, -1, 28, 29, 30, 31, 32, 33, -1, 35, -1, 37, 38, -1, 2049, -1, -1, -1, 5, -1, 7, -1, 9, 10, -1, -1, -1, -1, -1, 16, 17, -1, -1, -1, -1, 22, 23, 24, 25, 2074, 2075, 28, 29, 30, 31, 32, 33, 1020, 35, -1, 37, 38, 5, -1, 7, -1, 9, 10, -1, -1, -1, -1, -1, 16, 17, -1, -1, -1, -1, 22, 23, 24, 25, -1, -1, 28, 29, 30, 31, 32, 33, -1, 35, -1, 37, 38, -1, -1, -1, -1, -1, -1, 2127, -1, -1, -1, -1, -1, -1, -1, -1, 1321, 1322, 1323, 1324, 1325, 1326, 1327, 1328, 1329, 1330, 1331, 1332, 1333, 1334, 1335, 1336, 1337, 1338, 1339, -1, -1, 2157, -1, -1, 2160, -1, 2162, -1, -1, -1, -1, -1, -1, -1, 1355, -1, -1, -1, -1, -1, 5, 1362, -1, 1364, 9, 10, -1, -1, -1, -1, -1, 16, 17, 1374, -1, -1, 21, 22, 23, 24, 25, -1, -1, 28, 29, 30, 31, 32, 33, -1, 35, -1, 37, 38, 5, -1, -1, -1, 9, 10, -1, -1, -1, -1, 1405, 16, 17, -1, -1, -1, 21, 22, 23, 24, 25, -1, 2232, 28, 29, 30, 31, 32, 33, -1, 35, -1, 37, 38, 5, -1, -1, -1, 9, 10, -1, -1, -1, -1, -1, 16, 17, -1, 2258, -1, 21, 22, 23, 24, 25, -1, -1, 28, 29, 30, 31, 32, 33, -1, 35, -1, 37, 38, -1, -1, -1, 5, -1, -1, -1, 9, 10, -1, -1, 1474, -1, -1, 16, 17, -1, -1, -1, 21, 22, 23, 24, 25, -1, 1488, 28, 29, 30, 31, 32, 33, -1, 35, -1, 37, 38, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1509, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2334, 5, -1, -1, 2338, 9, 10, -1, -1, -1, -1, -1, 16, 17, 1286, -1, -1, 21, 22, 23, 24, 25, -1, -1, 28, 29, 30, 31, 32, 33, -1, 35, 5, 37, 38, -1, 9, 10, -1, 1558, -1, 2375, 2376, 16, 17, -1, -1, -1, 21, 22, 23, 24, 25, -1, -1, 28, 29, 30, 31, 32, 33, -1, 35, -1, 37, 38, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2409, 2410, 2411, 2412, -1, 5, -1, -1, 2417, 9, 10, -1, -1, -1, -1, 1609, 16, 17, 2427, -1, -1, 21, 22, 23, 24, 25, -1, -1, 28, 29, 30, 31, 32, 33, -1, 35, -1, 37, 38, -1, 5, -1, -1, -1, 9, 10, -1, -1, 1642, -1, -1, 16, 17, -1, -1, 1649, 21, 22, 23, 24, 25, 1655, 2471, 28, 29, 30, 31, 32, 33, -1, 35, -1, 37, 38, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1678, -1, -1, 2496, 2497, -1, 2499, -1, -1, -1, -1, -1, 1690, 2506, -1, -1, -1, 5, -1, 7, 1698, 9, 10, -1, -1, -1, -1, -1, 16, 17, 1708, -1, -1, 1711, 22, 23, 24, 25, -1, -1, 28, 29, 30, 31, 32, 33, -1, 35, 1726, 37, 38, -1, -1, -1, -1, -1, 2549, -1, -1, -1, 1738, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1752, -1, -1, -1, -1, -1, 1758, -1, 14, 15, 16, 17, 1764, 19, -1, 21, -1, 23, 24, -1, 26, -1, -1, -1, 30, -1, 32, 33, -1, -1, 36, 37, 38, -1, 40, -1, 42, 43, -1, -1, 46, -1, -1, -1, -1, 51, 52, 53, 54, 55, 56, 57, 58, -1, 60, 61, -1, -1, 64, 65, 66, -1, 68, -1, 70, -1, -1, 73, 74, -1, -1, -1, -1, -1, -1, 81, 82, -1, -1, 85, -1, -1, -1, -1, -1, -1, 92, -1, 94, -1, 96, 97, -1, -1, -1, 101, 102, 103, -1, -1, 106, -1, -1, 109, 110, -1, 112, 113, 114, -1, -1, -1, -1, 119, 120, -1, -1, 123, -1, 125, 126, 127, -1, 129, 130, -1, -1, 133, -1, 135, 136, 137, 138, 139, 140, -1, -1, -1, -1, -1, -1, 147, 148, 149, 1896, -1, -1, -1, 154, 155, 156, -1, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, -1, 185, -1, 187, -1, 189, -1, 191, 192, -1, 1940, 195, 196, 197, 198, 199, 200, 201, 202, -1, -1, -1, 5, -1, -1, -1, 9, 10, -1, -1, 1960, -1, 1962, 16, 17, -1, 1966, -1, 21, 22, 23, 24, 25, -1, -1, 28, 29, 30, 31, 32, 33, -1, 35, -1, 37, 38, -1, -1, -1, 1989, -1, -1, 1992, -1, -1, -1, -1, -1, 5, -1, 7, 255, 9, 10, 258, -1, 260, -1, -1, 16, 17, -1, -1, -1, 2014, 22, 23, 24, 25, -1, -1, 28, 29, 30, 31, 32, 33, -1, 35, 5, 37, 38, -1, 9, 10, -1, -1, -1, -1, -1, 16, 17, -1, -1, -1, 21, 22, 23, 24, 25, -1, -1, 28, 29, 30, 31, 32, 33, -1, 35, -1, 37, 38, -1, 5, -1, 7, -1, 9, 10, -1, -1, -1, -1, -1, 16, 17, -1, -1, -1, -1, 22, 23, 24, 25, -1, -1, 28, 29, 30, 31, 32, 33, 2093, 35, -1, 37, 38, -1, 5, -1, 7, 2102, 9, 10, -1, 2106, 2107, -1, -1, 16, 17, -1, -1, 2114, -1, 22, 23, 24, 25, -1, -1, 28, 29, 30, 31, 32, 33, -1, 35, 5, 37, 38, 8, 9, 10, -1, -1, -1, -1, -1, 16, 17, -1, -1, 2145, -1, 22, 23, 24, 25, -1, -1, 28, 29, 30, 31, 32, 33, -1, 35, -1, 37, 38, 2164, -1, 5, -1, -1, 2169, 9, 10, -1, -1, -1, -1, -1, 16, 17, 2179, 2180, -1, 21, 22, 23, 24, 25, -1, -1, 28, 29, 30, 31, 32, 33, -1, 35, -1, 37, 38, -1, -1, -1, -1, -1, -1, -1, 5, -1, -1, 2210, 9, 10, -1, -1, -1, -1, -1, 16, 17, 2220, 2221, -1, 21, 22, 23, 24, 25, -1, -1, 28, 29, 30, 31, 32, 33, -1, 35, 5, 37, 38, -1, 9, 10, -1, -1, -1, -1, -1, 16, 17, -1, -1, -1, 21, 22, 23, 24, 25, -1, -1, 28, 29, 30, 31, 32, 33, -1, 35, -1, 37, 38, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2296, -1, 2298, 5, -1, -1, 8, 9, 10, -1, -1, 2307, -1, -1, 16, 17, 2312, -1, -1, 2315, 22, 23, 24, 25, -1, -1, 28, 29, 30, 31, 32, 33, 2328, 35, -1, 37, 38, -1, 5, -1, -1, -1, 9, 10, -1, -1, -1, -1, -1, 16, 17, -1, 602, 603, 21, 22, 23, 24, 25, -1, -1, 28, 29, 30, 31, 32, 33, -1, 35, -1, 37, 38, -1, -1, 5, -1, -1, 2373, 9, 10, -1, -1, -1, 2379, -1, 16, 17, -1, -1, 2385, 21, 22, 23, 24, 25, -1, -1, 28, 29, 30, 31, 32, 33, -1, 35, 5, 37, 38, 2404, 9, 10, -1, -1, -1, -1, -1, 16, 17, -1, -1, -1, 21, 22, 23, 24, 25, -1, -1, 28, 29, 30, 31, 32, 33, -1, 35, -1, 37, 38, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2447, -1, 2449, -1, -1, -1, 2453, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2464, 2465, -1, -1, -1, 2469, 5, -1, -1, 8, 9, 10, -1, -1, -1, 2479, -1, 16, 17, 2483, -1, -1, -1, 22, 23, 24, 25, -1, -1, 28, 29, 30, 31, 32, 33, -1, 35, -1, 37, 38, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2515, -1, -1, -1, -1, 2520, -1, 2522, -1, -1, -1, 5, -1, -1, -1, 9, 10, 6, -1, 2534, -1, 2536, 16, 17, 13, -1, -1, 21, 22, 23, 24, 25, -1, -1, 28, 29, 30, 31, 32, 33, -1, 35, -1, 37, 38, -1, -1, -1, -1, 2564, -1, -1, -1, 2568, 43, 44, 45, 46, -1, 48, 49, 50, 51, 52, 53, 2580, -1, 56, 57, -1, -1, -1, 61, 62, 63, -1, 65, 66, 67, 68, 69, 70, -1, 72, 73, 74, 75, 76, 77, -1, 79, 80, 81, 82, 83, 84, -1, -1, 87, 88, 89, 90, 91, -1, -1, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, -1, 117, -1, 119, 120, -1, 122, 123, 124, -1, -1, 127, -1, -1, 130, 131, -1, 133, 134, 135, 136, -1, 138, 139, 140, 141, 142, 143, 144, 145, 146, -1, -1, -1, -1, -1, 152, 153, 154, 155, -1, -1, -1, -1, 160, -1, -1, 163, 164, -1, -1, 167, 168, -1, 170, -1, -1, -1, 174, -1, 176, -1, 178, -1, -1, -1, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, -1, 193, 194, 195, -1, 197, -1, 199, 200, -1, 202, -1, 204, 205, 206, 207, -1, -1, 210, 211, 212, -1, 214, 215, 216, -1, 218, 219, 220, -1, 222, -1, 224, 225, 226, 227, 228, -1, 230, -1, 232, 233, -1, -1, 236, 237, 238, -1, -1, 241, 242, -1, 244, 245, -1, 247, 248, -1, -1, -1, 252, 253, -1, -1, 256, -1, -1, 259, -1, -1, -1, 263, 264, -1, -1, 267, 268, 269, -1, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, -1, 283, -1, -1, 286, -1, -1, -1, 290, 291, 292, 293, 294, -1, 296, 297, -1, -1, 300, 301, 302, 303, -1, -1, -1, -1, 308, 309, 310, 311, 312, 313, -1, -1, -1, -1, -1, -1, -1, 321, -1, 323, -1, 325, 326, 327, 328, 329, -1, -1, -1, 333, 334, 335, 336, 337, 338, 5, 340, 341, 8, 9, 10, 345, -1, -1, -1, -1, 16, 17, -1, -1, -1, -1, 22, 23, 24, 25, -1, -1, 28, 29, 30, 31, 32, 33, -1, 35, 5, 37, 38, 8, 9, 10, -1, -1, -1, -1, -1, 16, 17, -1, -1, -1, -1, 22, 23, 24, 25, -1, -1, 28, 29, 30, 31, 32, 33, -1, 35, 5, 37, 38, -1, 9, 10, -1, -1, -1, -1, -1, 16, 17, -1, -1, -1, 21, 22, 23, 24, 25, -1, -1, 28, 29, 30, 31, 32, 33, -1, 35, 5, 37, 38, 8, 9, 10, -1, -1, -1, -1, -1, 16, 17, -1, -1, -1, -1, 22, 23, 24, 25, -1, -1, 28, 29, 30, 31, 32, 33, -1, 35, 5, 37, 38, -1, 9, 10, -1, -1, -1, -1, -1, 16, 17, -1, -1, -1, 21, 22, 23, 24, 25, -1, -1, 28, 29, 30, 31, 32, 33, -1, 35, 5, 37, 38, -1, 9, 10, -1, -1, -1, -1, -1, 16, 17, -1, -1, -1, 21, 22, 23, 24, 25, -1, -1, 28, 29, 30, 31, 32, 33, -1, 35, 5, 37, 38, 8, 9, 10, -1, -1, -1, -1, -1, 16, 17, -1, -1, -1, -1, 22, 23, 24, 25, -1, -1, 28, 29, 30, 31, 32, 33, -1, 35, 5, 37, 38, 8, 9, 10, -1, -1, -1, -1, -1, 16, 17, -1, -1, -1, -1, 22, 23, 24, 25, -1, -1, 28, 29, 30, 31, 32, 33, -1, 35, 5, 37, 38, -1, 9, 10, -1, -1, -1, -1, -1, 16, 17, -1, -1, -1, 21, 22, 23, 24, 25, -1, -1, 28, 29, 30, 31, 32, 33, -1, 35, 5, 37, 38, -1, 9, 10, -1, -1, -1, -1, -1, 16, 17, -1, -1, -1, 21, 22, 23, 24, 25, -1, -1, 28, 29, 30, 31, 32, 33, -1, 35, 5, 37, 38, 8, 9, 10, -1, -1, -1, -1, -1, 16, 17, -1, -1, -1, -1, 22, 23, 24, 25, -1, -1, 28, 29, 30, 31, 32, 33, -1, 35, -1, 37, 38, 5, -1, 7, -1, 9, 10, -1, -1, -1, -1, -1, 16, 17, -1, -1, -1, -1, 22, 23, 24, 25, -1, -1, 28, 29, 30, 31, 32, 33, -1, 35, 5, 37, 38, -1, 9, 10, -1, -1, -1, -1, -1, 16, 17, -1, -1, -1, -1, 22, 23, 24, 25, -1, -1, 28, 29, 30, 31, 32, 33, -1, 35, -1, 37, 38 }; /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing symbol of state STATE-NUM. */ static const yytype_uint16 yystos[] = { 0, 362, 0, 1, 150, 257, 363, 364, 116, 6, 13, 43, 44, 45, 46, 48, 49, 50, 51, 52, 53, 56, 57, 61, 62, 63, 65, 66, 67, 68, 69, 70, 72, 73, 74, 75, 76, 77, 79, 80, 81, 82, 83, 84, 87, 88, 89, 90, 91, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 117, 119, 120, 122, 123, 124, 127, 130, 131, 133, 134, 135, 136, 138, 139, 140, 141, 142, 143, 144, 145, 146, 152, 153, 154, 155, 160, 163, 164, 167, 168, 170, 174, 176, 178, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 193, 194, 195, 197, 199, 200, 202, 204, 205, 206, 207, 210, 211, 212, 214, 215, 216, 218, 219, 220, 222, 224, 225, 226, 227, 228, 230, 232, 233, 236, 237, 238, 241, 242, 244, 245, 247, 248, 252, 253, 256, 259, 263, 264, 267, 268, 269, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 283, 286, 290, 291, 292, 293, 294, 296, 297, 300, 301, 302, 303, 308, 309, 310, 311, 312, 313, 321, 323, 325, 326, 327, 328, 329, 333, 334, 335, 336, 337, 338, 340, 341, 345, 365, 367, 370, 382, 383, 387, 388, 389, 395, 396, 397, 398, 400, 401, 403, 405, 406, 407, 408, 415, 416, 417, 418, 419, 420, 424, 425, 426, 430, 431, 469, 471, 484, 527, 528, 530, 531, 537, 538, 539, 540, 547, 548, 549, 550, 552, 555, 559, 560, 561, 562, 563, 564, 570, 571, 572, 583, 584, 585, 587, 590, 593, 598, 599, 601, 603, 605, 608, 609, 633, 634, 645, 646, 647, 648, 653, 656, 659, 662, 663, 713, 714, 715, 716, 717, 718, 719, 720, 726, 728, 730, 732, 734, 735, 736, 737, 738, 741, 743, 744, 745, 748, 749, 753, 754, 756, 757, 758, 759, 760, 761, 762, 765, 770, 775, 777, 778, 779, 780, 782, 783, 784, 785, 786, 787, 804, 807, 808, 809, 810, 816, 819, 824, 825, 826, 829, 830, 831, 832, 833, 834, 835, 836, 837, 838, 839, 840, 841, 842, 843, 848, 849, 850, 851, 852, 853, 863, 864, 865, 868, 872, 873, 874, 875, 876, 881, 901, 15, 494, 494, 556, 556, 556, 556, 556, 494, 556, 556, 366, 556, 556, 556, 494, 556, 494, 556, 556, 494, 556, 556, 556, 493, 556, 494, 556, 556, 7, 15, 495, 15, 494, 616, 556, 494, 379, 556, 556, 556, 556, 556, 556, 556, 556, 556, 556, 129, 372, 536, 536, 556, 556, 556, 494, 556, 372, 556, 494, 494, 556, 556, 493, 366, 494, 494, 64, 378, 556, 556, 494, 494, 556, 494, 494, 494, 494, 494, 556, 433, 556, 556, 556, 372, 470, 366, 494, 556, 556, 556, 494, 556, 494, 556, 556, 494, 556, 556, 556, 494, 366, 494, 379, 556, 556, 379, 556, 494, 556, 556, 556, 494, 556, 556, 494, 556, 494, 556, 556, 556, 556, 556, 556, 15, 494, 594, 494, 366, 494, 494, 556, 556, 556, 15, 8, 494, 494, 556, 556, 556, 494, 556, 556, 556, 556, 556, 556, 556, 556, 556, 556, 556, 556, 556, 556, 556, 556, 556, 556, 556, 556, 556, 556, 556, 556, 556, 556, 494, 556, 494, 556, 556, 556, 556, 494, 494, 556, 556, 556, 556, 556, 556, 556, 556, 907, 907, 907, 907, 907, 907, 257, 582, 124, 233, 403, 15, 375, 582, 8, 8, 8, 8, 7, 8, 124, 367, 390, 8, 372, 404, 8, 8, 8, 8, 8, 551, 8, 551, 8, 8, 8, 8, 551, 582, 7, 218, 252, 528, 530, 539, 540, 239, 548, 548, 10, 14, 15, 16, 17, 27, 34, 36, 64, 92, 149, 201, 372, 384, 500, 501, 503, 504, 505, 506, 512, 513, 514, 515, 516, 519, 15, 556, 5, 9, 15, 16, 17, 129, 502, 504, 512, 566, 580, 581, 556, 15, 566, 556, 5, 565, 566, 581, 566, 8, 8, 8, 8, 8, 8, 8, 8, 7, 8, 8, 5, 7, 372, 643, 644, 372, 636, 495, 15, 15, 149, 483, 372, 372, 746, 747, 8, 372, 660, 661, 747, 372, 374, 372, 15, 532, 578, 23, 37, 372, 422, 423, 15, 372, 606, 372, 674, 674, 372, 657, 658, 372, 535, 432, 15, 372, 586, 149, 752, 535, 7, 478, 479, 494, 617, 618, 372, 612, 618, 15, 557, 372, 588, 589, 535, 15, 15, 535, 752, 536, 535, 535, 535, 535, 372, 535, 375, 535, 15, 427, 495, 503, 504, 15, 369, 372, 372, 654, 655, 485, 486, 487, 488, 8, 675, 742, 15, 372, 600, 372, 591, 592, 579, 15, 15, 372, 495, 15, 500, 755, 15, 15, 372, 729, 731, 8, 372, 37, 421, 15, 504, 505, 495, 15, 15, 557, 483, 495, 504, 372, 721, 5, 15, 580, 581, 495, 372, 373, 495, 579, 15, 503, 637, 638, 612, 616, 372, 604, 372, 701, 701, 15, 372, 602, 721, 500, 511, 495, 379, 15, 372, 707, 707, 707, 707, 707, 7, 500, 595, 596, 372, 597, 495, 368, 372, 495, 372, 727, 729, 372, 494, 495, 372, 472, 15, 15, 579, 372, 15, 618, 15, 618, 618, 618, 618, 790, 846, 618, 618, 618, 618, 618, 618, 790, 372, 379, 854, 855, 856, 15, 15, 8, 869, 870, 871, 495, 15, 500, 500, 500, 500, 499, 500, 15, 15, 15, 15, 15, 372, 899, 15, 366, 366, 124, 5, 21, 372, 376, 377, 371, 379, 372, 372, 372, 423, 7, 379, 366, 124, 372, 372, 5, 15, 410, 411, 372, 423, 423, 423, 423, 422, 503, 421, 372, 372, 427, 434, 435, 437, 438, 556, 556, 239, 413, 500, 501, 500, 500, 500, 500, 5, 9, 16, 17, 22, 23, 24, 25, 26, 28, 29, 30, 31, 32, 33, 35, 37, 38, 384, 15, 246, 3, 15, 246, 246, 15, 509, 510, 21, 553, 578, 511, 5, 9, 166, 567, 568, 569, 580, 26, 580, 5, 9, 23, 37, 502, 579, 580, 579, 8, 15, 504, 573, 574, 15, 500, 501, 516, 575, 576, 577, 575, 586, 372, 600, 602, 604, 606, 372, 7, 379, 727, 8, 21, 638, 423, 525, 500, 240, 551, 15, 379, 15, 477, 8, 578, 7, 500, 533, 534, 535, 15, 372, 477, 423, 482, 483, 8, 434, 525, 477, 15, 8, 21, 5, 7, 480, 481, 500, 372, 8, 21, 5, 58, 86, 126, 137, 165, 258, 619, 615, 616, 175, 607, 500, 149, 546, 8, 500, 500, 371, 372, 428, 429, 503, 508, 372, 26, 372, 541, 542, 544, 375, 8, 8, 15, 231, 403, 489, 379, 8, 742, 372, 503, 711, 721, 739, 740, 8, 566, 26, 5, 9, 16, 17, 22, 23, 24, 25, 28, 29, 30, 31, 32, 33, 34, 35, 37, 38, 384, 385, 386, 372, 379, 393, 503, 500, 15, 379, 372, 372, 503, 503, 526, 8, 676, 733, 372, 503, 664, 372, 467, 468, 546, 423, 18, 579, 580, 579, 399, 402, 643, 638, 7, 616, 618, 711, 721, 722, 723, 422, 423, 461, 462, 62, 503, 766, 15, 15, 7, 8, 21, 594, 423, 375, 423, 477, 8, 673, 698, 21, 379, 372, 8, 500, 500, 477, 503, 551, 811, 503, 287, 823, 823, 551, 820, 823, 15, 551, 788, 551, 827, 788, 788, 551, 805, 551, 817, 477, 147, 148, 180, 314, 315, 318, 319, 380, 857, 858, 859, 8, 21, 504, 679, 860, 21, 860, 379, 871, 372, 866, 867, 379, 763, 764, 8, 8, 8, 8, 503, 506, 507, 781, 664, 379, 882, 883, 884, 885, 886, 887, 888, 379, 891, 892, 893, 894, 895, 379, 896, 897, 8, 379, 902, 903, 372, 368, 366, 8, 21, 213, 380, 477, 44, 87, 93, 119, 143, 145, 178, 183, 187, 191, 194, 216, 230, 236, 391, 392, 394, 372, 366, 494, 557, 578, 404, 477, 551, 551, 8, 37, 15, 372, 440, 445, 379, 15, 520, 21, 8, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 578, 64, 129, 496, 498, 578, 503, 514, 517, 64, 517, 511, 8, 21, 5, 500, 554, 569, 8, 21, 5, 9, 500, 21, 500, 580, 580, 580, 580, 580, 21, 573, 573, 8, 500, 501, 576, 577, 8, 8, 8, 477, 477, 494, 43, 67, 82, 87, 88, 94, 228, 259, 303, 647, 644, 379, 507, 523, 21, 372, 15, 499, 67, 478, 661, 500, 7, 8, 21, 553, 37, 8, 21, 658, 503, 506, 522, 524, 578, 750, 480, 7, 477, 618, 15, 15, 15, 15, 15, 15, 607, 618, 372, 21, 558, 589, 21, 21, 15, 8, 21, 8, 510, 504, 8, 543, 26, 371, 655, 486, 129, 490, 491, 492, 408, 169, 208, 282, 379, 15, 7, 8, 21, 592, 575, 21, 21, 147, 148, 180, 21, 18, 21, 7, 500, 518, 175, 324, 37, 8, 21, 379, 8, 21, 26, 8, 21, 558, 500, 21, 463, 464, 463, 21, 7, 618, 607, 15, 7, 8, 21, 8, 15, 15, 26, 708, 709, 711, 499, 500, 596, 379, 8, 698, 8, 673, 404, 394, 381, 21, 21, 21, 618, 551, 21, 618, 551, 847, 618, 551, 618, 551, 618, 551, 618, 551, 15, 15, 15, 15, 15, 15, 379, 856, 8, 21, 21, 191, 858, 8, 182, 315, 318, 8, 21, 379, 379, 379, 500, 15, 15, 8, 21, 21, 183, 191, 208, 357, 358, 8, 21, 41, 209, 228, 8, 21, 339, 342, 343, 344, 355, 356, 8, 21, 379, 244, 331, 346, 347, 348, 8, 21, 375, 372, 377, 15, 409, 410, 477, 494, 15, 7, 8, 372, 477, 15, 514, 5, 412, 500, 569, 423, 503, 437, 15, 16, 17, 27, 36, 59, 64, 92, 149, 201, 436, 438, 448, 449, 450, 451, 452, 453, 454, 455, 440, 445, 446, 447, 15, 441, 442, 62, 500, 575, 501, 496, 21, 8, 497, 500, 518, 569, 7, 578, 483, 500, 578, 8, 574, 21, 8, 8, 8, 501, 577, 501, 577, 501, 577, 372, 255, 8, 21, 483, 482, 21, 7, 21, 500, 533, 21, 483, 551, 8, 21, 569, 751, 8, 21, 481, 500, 619, 578, 15, 621, 372, 620, 620, 500, 620, 477, 618, 239, 535, 499, 429, 429, 372, 500, 542, 21, 500, 518, 8, 21, 16, 15, 15, 15, 499, 739, 740, 495, 503, 771, 7, 500, 7, 21, 21, 372, 614, 504, 503, 191, 503, 618, 665, 500, 468, 551, 8, 47, 177, 372, 466, 379, 635, 637, 607, 7, 7, 500, 724, 725, 722, 723, 462, 500, 5, 621, 767, 768, 774, 500, 631, 8, 21, 15, 21, 71, 208, 379, 379, 495, 172, 372, 475, 476, 504, 191, 208, 282, 285, 290, 298, 791, 792, 793, 800, 812, 813, 814, 618, 266, 821, 822, 823, 618, 37, 503, 844, 845, 84, 265, 289, 299, 304, 789, 791, 792, 793, 794, 795, 796, 798, 799, 800, 618, 791, 792, 793, 794, 795, 796, 798, 799, 800, 813, 814, 828, 618, 791, 792, 793, 800, 806, 618, 791, 792, 818, 618, 860, 860, 860, 379, 861, 862, 860, 860, 504, 15, 867, 764, 331, 315, 332, 578, 496, 507, 15, 15, 15, 15, 15, 883, 15, 15, 15, 892, 15, 15, 15, 15, 897, 352, 353, 15, 15, 15, 15, 15, 903, 372, 18, 26, 414, 15, 393, 7, 379, 409, 558, 558, 413, 5, 500, 451, 452, 453, 456, 452, 454, 452, 454, 246, 246, 246, 246, 246, 8, 37, 372, 439, 503, 5, 441, 442, 8, 15, 16, 17, 149, 372, 439, 443, 444, 457, 458, 459, 460, 15, 442, 15, 21, 521, 21, 21, 510, 578, 500, 511, 554, 568, 580, 544, 545, 501, 545, 545, 545, 477, 372, 639, 642, 578, 8, 21, 7, 413, 500, 578, 500, 578, 569, 632, 500, 622, 623, 21, 21, 21, 21, 8, 8, 254, 529, 535, 21, 491, 492, 679, 679, 679, 21, 21, 372, 15, 21, 500, 7, 7, 500, 477, 15, 173, 8, 669, 670, 671, 672, 673, 675, 676, 677, 680, 682, 683, 684, 698, 706, 544, 464, 15, 15, 465, 255, 8, 7, 8, 21, 21, 21, 8, 21, 21, 709, 710, 15, 15, 372, 372, 473, 474, 476, 18, 8, 26, 790, 15, 790, 790, 15, 618, 812, 790, 618, 821, 372, 8, 21, 15, 790, 15, 790, 15, 618, 789, 618, 828, 618, 806, 618, 818, 21, 21, 21, 316, 317, 8, 21, 21, 21, 866, 15, 15, 496, 21, 507, 889, 890, 679, 379, 702, 514, 679, 708, 722, 708, 664, 664, 507, 900, 500, 898, 15, 15, 379, 904, 905, 664, 664, 500, 379, 906, 21, 500, 500, 649, 650, 21, 392, 414, 5, 500, 404, 8, 21, 8, 517, 517, 517, 517, 517, 448, 5, 15, 438, 449, 442, 372, 439, 447, 457, 458, 458, 8, 21, 7, 16, 17, 5, 37, 9, 457, 500, 20, 510, 497, 21, 26, 21, 21, 21, 21, 15, 507, 569, 483, 660, 495, 522, 569, 751, 500, 21, 7, 8, 21, 500, 379, 15, 21, 21, 21, 7, 772, 773, 774, 500, 500, 7, 679, 503, 666, 379, 671, 26, 466, 26, 385, 639, 637, 372, 610, 611, 612, 613, 725, 768, 618, 78, 595, 372, 674, 722, 699, 8, 372, 476, 500, 618, 801, 379, 618, 618, 846, 503, 844, 379, 500, 500, 618, 618, 618, 618, 862, 21, 679, 503, 21, 26, 8, 21, 21, 22, 24, 33, 35, 158, 159, 161, 162, 192, 234, 247, 703, 704, 705, 8, 21, 21, 21, 21, 21, 21, 21, 21, 8, 21, 8, 21, 379, 877, 878, 877, 315, 351, 8, 21, 21, 21, 21, 349, 350, 8, 8, 21, 7, 21, 21, 578, 456, 449, 578, 439, 26, 21, 457, 444, 458, 458, 459, 459, 459, 21, 500, 5, 500, 518, 640, 641, 503, 8, 679, 503, 8, 500, 623, 379, 21, 254, 500, 8, 21, 500, 21, 15, 41, 135, 209, 221, 223, 224, 226, 229, 320, 322, 500, 465, 21, 21, 15, 8, 132, 769, 21, 21, 7, 21, 701, 703, 474, 5, 16, 17, 22, 24, 33, 35, 37, 159, 162, 247, 305, 306, 307, 803, 21, 94, 230, 284, 295, 815, 37, 191, 288, 299, 797, 21, 21, 21, 21, 500, 890, 15, 15, 379, 507, 500, 354, 8, 21, 21, 905, 500, 7, 7, 412, 21, 496, 443, 457, 21, 8, 8, 21, 483, 569, 255, 15, 21, 773, 5, 500, 667, 668, 15, 685, 15, 15, 15, 15, 707, 707, 15, 15, 15, 8, 499, 611, 711, 712, 15, 722, 700, 700, 7, 8, 21, 847, 21, 8, 504, 679, 703, 8, 878, 8, 879, 8, 880, 21, 7, 413, 21, 21, 500, 641, 500, 372, 624, 625, 500, 8, 21, 686, 685, 721, 739, 721, 722, 711, 708, 500, 500, 678, 666, 681, 500, 21, 8, 379, 21, 7, 8, 21, 679, 802, 500, 379, 21, 8, 500, 379, 379, 372, 651, 652, 21, 8, 15, 21, 668, 148, 180, 687, 7, 21, 7, 21, 15, 21, 21, 8, 21, 8, 21, 8, 711, 78, 702, 702, 21, 330, 500, 504, 353, 352, 8, 500, 40, 500, 626, 627, 774, 7, 7, 688, 689, 711, 739, 722, 595, 500, 666, 500, 21, 21, 21, 15, 21, 15, 15, 652, 372, 628, 8, 21, 8, 21, 15, 21, 21, 21, 8, 499, 877, 877, 17, 629, 630, 627, 689, 500, 690, 691, 21, 500, 21, 21, 21, 631, 17, 7, 8, 21, 8, 776, 631, 500, 691, 15, 379, 379, 692, 693, 694, 695, 696, 182, 318, 128, 157, 217, 8, 21, 7, 7, 15, 697, 697, 697, 693, 379, 695, 696, 379, 696, 498, 7, 21, 696 }; /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ static const yytype_uint16 yyr1[] = { 0, 361, 362, 362, 363, 363, 363, 363, 363, 363, 363, 364, 365, 365, 365, 365, 365, 365, 365, 365, 366, 367, 367, 367, 368, 369, 370, 370, 370, 370, 371, 371, 372, 373, 373, 374, 374, 375, 375, 375, 376, 376, 377, 377, 378, 379, 380, 381, 382, 382, 382, 382, 382, 382, 382, 382, 382, 382, 382, 382, 382, 382, 382, 382, 382, 382, 382, 382, 382, 382, 382, 382, 382, 382, 382, 382, 382, 382, 383, 383, 383, 383, 383, 384, 385, 385, 386, 386, 386, 386, 386, 386, 386, 386, 386, 386, 386, 386, 386, 386, 386, 386, 386, 386, 387, 387, 388, 388, 389, 389, 390, 390, 390, 391, 391, 392, 392, 392, 392, 392, 392, 392, 392, 392, 392, 392, 392, 393, 393, 393, 394, 394, 395, 395, 396, 396, 397, 397, 398, 398, 399, 400, 401, 401, 402, 403, 403, 404, 405, 405, 406, 406, 407, 408, 408, 408, 408, 408, 408, 408, 409, 409, 410, 410, 410, 411, 411, 411, 411, 412, 412, 412, 412, 413, 414, 414, 414, 415, 415, 416, 416, 417, 417, 418, 418, 419, 419, 419, 419, 420, 420, 420, 421, 422, 422, 423, 424, 424, 425, 425, 426, 426, 427, 428, 428, 429, 429, 429, 430, 431, 431, 432, 433, 434, 435, 435, 436, 436, 437, 437, 437, 437, 437, 438, 439, 440, 441, 442, 443, 443, 444, 444, 445, 446, 446, 447, 447, 447, 447, 448, 448, 448, 449, 449, 449, 449, 449, 449, 449, 449, 449, 449, 449, 450, 451, 451, 451, 452, 452, 453, 453, 453, 454, 454, 454, 454, 455, 456, 456, 457, 457, 457, 457, 457, 458, 458, 458, 459, 459, 460, 460, 460, 461, 461, 462, 462, 463, 463, 464, 465, 466, 466, 466, 467, 467, 468, 469, 470, 470, 471, 471, 471, 471, 472, 473, 473, 474, 474, 475, 475, 476, 477, 477, 479, 478, 478, 480, 480, 480, 480, 481, 481, 482, 482, 483, 484, 484, 485, 485, 486, 488, 487, 489, 489, 490, 490, 491, 491, 492, 493, 494, 495, 495, 496, 496, 497, 497, 497, 498, 498, 499, 499, 500, 500, 500, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 501, 502, 502, 503, 504, 504, 504, 505, 505, 505, 505, 506, 507, 507, 507, 507, 508, 509, 509, 510, 511, 511, 512, 512, 512, 512, 512, 513, 513, 513, 513, 514, 515, 515, 515, 516, 517, 517, 518, 518, 518, 518, 518, 518, 518, 518, 520, 521, 519, 522, 522, 523, 523, 523, 524, 524, 524, 525, 526, 526, 527, 527, 527, 527, 527, 527, 527, 527, 527, 527, 527, 527, 527, 527, 527, 527, 527, 527, 527, 527, 527, 527, 527, 527, 528, 528, 529, 529, 529, 530, 530, 531, 531, 531, 531, 531, 532, 533, 533, 533, 533, 534, 534, 535, 535, 536, 536, 537, 538, 539, 540, 541, 541, 542, 543, 543, 544, 545, 545, 546, 546, 547, 547, 547, 547, 547, 548, 548, 548, 548, 548, 548, 548, 548, 548, 548, 548, 548, 548, 548, 548, 548, 548, 548, 549, 550, 550, 550, 550, 551, 551, 552, 553, 553, 554, 554, 554, 555, 555, 556, 557, 558, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 560, 561, 561, 561, 562, 563, 563, 564, 564, 565, 565, 566, 566, 567, 567, 568, 568, 568, 568, 568, 568, 569, 570, 571, 572, 572, 573, 573, 574, 574, 575, 575, 575, 576, 576, 576, 576, 576, 576, 577, 577, 577, 577, 577, 578, 579, 580, 580, 581, 581, 581, 581, 581, 581, 581, 581, 581, 582, 582, 583, 583, 583, 583, 583, 583, 583, 583, 583, 583, 583, 583, 583, 583, 583, 583, 583, 583, 583, 584, 584, 584, 584, 584, 584, 584, 584, 584, 584, 584, 584, 584, 584, 584, 584, 584, 584, 584, 584, 584, 584, 584, 584, 584, 584, 584, 584, 584, 584, 584, 584, 584, 584, 584, 584, 584, 584, 584, 584, 584, 584, 584, 584, 585, 585, 586, 587, 588, 588, 589, 590, 591, 591, 592, 593, 594, 595, 595, 596, 596, 596, 597, 598, 598, 598, 599, 599, 600, 601, 601, 602, 603, 603, 604, 605, 605, 606, 607, 607, 608, 609, 609, 610, 610, 611, 611, 612, 613, 614, 615, 615, 616, 617, 617, 618, 619, 619, 619, 619, 619, 619, 619, 619, 620, 621, 622, 622, 623, 623, 624, 624, 625, 626, 626, 627, 627, 627, 628, 629, 629, 630, 630, 631, 632, 632, 633, 634, 634, 635, 635, 636, 637, 638, 639, 640, 640, 641, 641, 641, 642, 643, 643, 644, 644, 644, 645, 645, 646, 646, 647, 647, 647, 647, 647, 647, 647, 647, 647, 647, 647, 648, 650, 649, 649, 651, 651, 652, 653, 654, 654, 655, 656, 657, 657, 658, 659, 659, 660, 660, 661, 662, 663, 664, 664, 665, 665, 666, 667, 667, 668, 668, 669, 669, 670, 670, 671, 671, 671, 671, 671, 671, 671, 671, 671, 671, 671, 672, 672, 673, 673, 674, 675, 675, 676, 677, 678, 678, 678, 679, 679, 680, 681, 681, 682, 682, 683, 684, 684, 685, 686, 687, 687, 687, 688, 688, 689, 689, 689, 690, 690, 691, 692, 692, 693, 693, 693, 693, 693, 693, 693, 694, 695, 696, 697, 698, 698, 698, 699, 700, 701, 702, 702, 703, 703, 704, 704, 704, 704, 704, 704, 704, 704, 704, 705, 705, 706, 706, 706, 706, 706, 707, 708, 708, 709, 709, 709, 709, 710, 711, 712, 712, 713, 713, 714, 714, 715, 716, 717, 718, 719, 720, 720, 721, 722, 722, 723, 723, 724, 724, 725, 725, 726, 726, 727, 728, 728, 728, 728, 728, 729, 730, 731, 731, 732, 733, 733, 734, 735, 735, 736, 737, 738, 738, 739, 739, 740, 740, 741, 741, 741, 741, 742, 743, 744, 745, 746, 747, 747, 748, 749, 749, 750, 750, 751, 752, 753, 754, 755, 755, 756, 757, 758, 759, 760, 761, 762, 763, 763, 764, 764, 764, 765, 766, 767, 767, 768, 768, 769, 769, 770, 771, 771, 772, 772, 773, 773, 774, 775, 776, 776, 776, 777, 778, 778, 779, 780, 781, 781, 782, 783, 784, 784, 784, 784, 784, 784, 784, 784, 784, 784, 784, 784, 784, 784, 784, 784, 784, 784, 784, 784, 784, 784, 784, 784, 784, 784, 785, 786, 787, 787, 788, 788, 789, 789, 789, 789, 789, 789, 789, 789, 789, 790, 791, 792, 793, 794, 795, 796, 797, 797, 797, 798, 799, 800, 801, 802, 803, 803, 803, 803, 803, 803, 803, 803, 803, 803, 803, 803, 803, 803, 804, 804, 805, 805, 806, 806, 806, 806, 807, 807, 808, 809, 809, 810, 810, 811, 811, 812, 812, 812, 812, 812, 812, 813, 814, 814, 815, 815, 815, 815, 816, 816, 817, 817, 818, 818, 819, 819, 820, 820, 821, 821, 822, 823, 824, 825, 825, 826, 826, 827, 827, 828, 828, 828, 828, 828, 828, 828, 828, 828, 828, 828, 829, 830, 830, 831, 832, 832, 833, 834, 835, 836, 837, 838, 839, 840, 841, 841, 842, 842, 843, 843, 844, 845, 845, 845, 845, 846, 847, 848, 848, 849, 849, 849, 849, 849, 849, 850, 851, 852, 852, 852, 853, 853, 853, 854, 854, 855, 855, 856, 856, 856, 857, 857, 857, 857, 857, 858, 859, 860, 861, 861, 862, 862, 863, 864, 865, 866, 866, 867, 868, 869, 869, 870, 870, 871, 871, 872, 872, 872, 872, 872, 872, 873, 874, 875, 876, 876, 876, 877, 877, 878, 879, 879, 880, 880, 881, 882, 882, 883, 883, 883, 883, 883, 884, 885, 886, 887, 888, 889, 889, 890, 891, 891, 892, 892, 892, 893, 894, 895, 896, 896, 897, 897, 897, 897, 897, 897, 897, 897, 898, 899, 900, 900, 901, 902, 902, 903, 903, 903, 903, 903, 904, 904, 905, 905, 906, 906, 907 }; /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */ static const yytype_uint8 yyr2[] = { 0, 2, 0, 3, 3, 3, 3, 3, 2, 1, 1, 1, 3, 3, 4, 5, 5, 3, 4, 3, 0, 2, 2, 2, 1, 1, 4, 5, 4, 5, 2, 5, 1, 0, 1, 0, 1, 0, 2, 3, 1, 3, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 4, 2, 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 5, 5, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, 7, 2, 3, 7, 6, 0, 2, 5, 1, 4, 1, 1, 1, 2, 1, 4, 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 7, 3, 4, 3, 4, 3, 2, 5, 0, 2, 2, 5, 0, 4, 5, 0, 2, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 5, 6, 6, 0, 1, 5, 9, 1, 1, 2, 2, 0, 0, 2, 2, 5, 4, 4, 3, 4, 3, 4, 3, 3, 4, 5, 3, 4, 5, 3, 3, 1, 3, 2, 4, 3, 4, 3, 3, 3, 3, 3, 3, 1, 4, 1, 1, 4, 3, 0, 0, 4, 1, 3, 1, 3, 2, 3, 3, 4, 2, 0, 1, 1, 3, 5, 1, 3, 0, 1, 7, 1, 3, 2, 2, 3, 1, 1, 4, 3, 2, 1, 1, 1, 1, 3, 1, 3, 1, 1, 6, 1, 1, 2, 2, 1, 3, 1, 2, 2, 1, 3, 1, 3, 5, 1, 1, 1, 2, 2, 3, 3, 1, 3, 3, 1, 3, 1, 1, 3, 1, 3, 1, 1, 3, 5, 0, 0, 1, 4, 4, 1, 3, 3, 2, 1, 3, 3, 6, 6, 7, 1, 1, 3, 1, 1, 1, 3, 3, 0, 3, 0, 2, 3, 1, 1, 2, 3, 1, 1, 1, 3, 1, 3, 1, 1, 3, 4, 0, 2, 2, 1, 1, 3, 1, 3, 1, 0, 0, 0, 2, 0, 1, 1, 1, 2, 2, 4, 1, 3, 1, 3, 1, 1, 1, 1, 3, 3, 3, 3, 3, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 3, 3, 1, 1, 1, 1, 1, 1, 5, 6, 4, 5, 3, 1, 1, 5, 4, 2, 0, 1, 5, 0, 1, 1, 3, 1, 3, 2, 1, 1, 1, 1, 1, 1, 3, 3, 5, 1, 1, 3, 2, 5, 4, 4, 3, 2, 1, 0, 0, 6, 1, 1, 1, 4, 5, 1, 4, 5, 0, 1, 3, 1, 1, 1, 2, 3, 3, 2, 1, 2, 2, 2, 3, 7, 3, 3, 1, 2, 2, 1, 2, 3, 1, 1, 1, 5, 7, 0, 6, 4, 11, 13, 4, 3, 3, 7, 8, 3, 1, 2, 2, 3, 1, 3, 0, 1, 0, 1, 1, 2, 5, 6, 1, 3, 3, 0, 2, 1, 5, 7, 0, 1, 3, 3, 6, 5, 6, 4, 5, 5, 2, 1, 1, 10, 1, 3, 4, 3, 3, 3, 3, 6, 6, 5, 8, 2, 3, 3, 7, 7, 0, 1, 4, 2, 4, 1, 2, 2, 1, 1, 0, 0, 0, 2, 2, 2, 2, 2, 1, 2, 2, 3, 4, 2, 3, 1, 3, 3, 1, 1, 1, 3, 1, 1, 4, 5, 1, 1, 3, 3, 1, 4, 1, 1, 1, 2, 2, 2, 1, 3, 3, 4, 4, 1, 3, 1, 5, 1, 1, 1, 3, 3, 3, 3, 3, 3, 1, 3, 5, 5, 5, 0, 0, 1, 3, 1, 1, 3, 3, 3, 3, 2, 3, 3, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 3, 2, 3, 1, 3, 1, 3, 1, 3, 1, 4, 3, 1, 3, 1, 3, 4, 1, 4, 4, 4, 3, 3, 1, 3, 3, 1, 3, 3, 1, 3, 3, 1, 3, 0, 5, 6, 8, 1, 3, 1, 1, 1, 4, 1, 0, 2, 3, 2, 4, 0, 1, 5, 4, 6, 4, 1, 4, 4, 1, 6, 1, 3, 1, 3, 1, 4, 1, 1, 3, 1, 1, 3, 1, 0, 1, 2, 3, 1, 2, 5, 4, 4, 6, 1, 3, 1, 1, 6, 4, 1, 3, 1, 1, 1, 1, 1, 3, 1, 1, 1, 6, 4, 1, 4, 1, 1, 1, 1, 4, 2, 7, 1, 4, 1, 1, 11, 0, 2, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 8, 1, 3, 2, 2, 7, 1, 3, 3, 1, 4, 1, 3, 1, 1, 0, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 8, 6, 8, 6, 1, 6, 6, 6, 6, 1, 3, 5, 1, 3, 6, 1, 3, 8, 6, 6, 4, 5, 5, 0, 2, 2, 0, 1, 3, 1, 4, 7, 1, 3, 3, 1, 3, 5, 3, 3, 1, 3, 1, 1, 3, 3, 3, 3, 10, 8, 10, 0, 0, 1, 2, 4, 4, 6, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 6, 4, 4, 3, 9, 1, 1, 3, 1, 5, 5, 9, 0, 1, 1, 3, 3, 3, 3, 3, 6, 3, 3, 3, 3, 7, 5, 1, 1, 3, 4, 1, 1, 3, 1, 1, 3, 3, 2, 3, 4, 4, 5, 5, 1, 2, 4, 4, 4, 0, 1, 2, 7, 6, 3, 3, 7, 5, 1, 3, 1, 4, 2, 3, 3, 4, 6, 3, 2, 3, 1, 1, 4, 5, 3, 6, 2, 4, 2, 1, 3, 3, 0, 1, 3, 2, 2, 2, 2, 9, 5, 1, 3, 2, 2, 2, 9, 4, 1, 3, 1, 1, 2, 0, 7, 1, 4, 1, 3, 1, 1, 1, 16, 0, 3, 3, 3, 3, 6, 9, 5, 1, 3, 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 4, 3, 4, 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 2, 2, 2, 2, 2, 5, 1, 1, 1, 4, 4, 4, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, 3, 4, 5, 1, 1, 1, 1, 4, 3, 2, 4, 3, 4, 3, 4, 5, 1, 1, 1, 1, 1, 1, 1, 7, 5, 1, 1, 1, 1, 4, 3, 4, 5, 1, 1, 4, 3, 4, 5, 1, 1, 2, 1, 2, 4, 3, 4, 3, 4, 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 4, 3, 2, 4, 3, 2, 3, 2, 2, 2, 2, 2, 2, 3, 2, 5, 2, 5, 2, 5, 1, 1, 3, 3, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 3, 2, 5, 4, 2, 5, 4, 2, 2, 1, 1, 3, 2, 2, 2, 4, 4, 4, 4, 4, 4, 1, 1, 1, 3, 2, 2, 1, 1, 4, 1, 3, 1, 3, 0, 1, 1, 2, 6, 3, 1, 1, 1, 1, 1, 1, 5, 5, 5, 3, 10, 10, 1, 3, 2, 0, 6, 0, 6, 2, 1, 3, 1, 1, 1, 1, 1, 5, 5, 5, 5, 5, 1, 3, 3, 1, 3, 1, 1, 1, 5, 5, 5, 1, 3, 2, 5, 2, 5, 5, 2, 5, 2, 5, 1, 1, 3, 5, 1, 3, 5, 5, 5, 5, 7, 1, 3, 2, 2, 2, 2, 0 }; #define yyerrok (yyerrstatus = 0) #define yyclearin (yychar = YYEMPTY) #define YYEMPTY (-2) #define YYEOF 0 #define YYACCEPT goto yyacceptlab #define YYABORT goto yyabortlab #define YYERROR goto yyerrorlab #define YYRECOVERING() (!!yyerrstatus) #define YYBACKUP(Token, Value) \ do \ if (yychar == YYEMPTY) \ { \ yychar = (Token); \ yylval = (Value); \ YYPOPSTACK (yylen); \ yystate = *yyssp; \ goto yybackup; \ } \ else \ { \ yyerror (YY_("syntax error: cannot back up")); \ YYERROR; \ } \ while (0) /* Error token number */ #define YYTERROR 1 #define YYERRCODE 256 /* Enable debugging if requested. */ #if YYDEBUG # ifndef YYFPRINTF # include /* INFRINGES ON USER NAME SPACE */ # define YYFPRINTF fprintf # endif # define YYDPRINTF(Args) \ do { \ if (yydebug) \ YYFPRINTF Args; \ } while (0) /* This macro is provided for backward compatibility. */ #ifndef YY_LOCATION_PRINT # define YY_LOCATION_PRINT(File, Loc) ((void) 0) #endif # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ do { \ if (yydebug) \ { \ YYFPRINTF (stderr, "%s ", Title); \ yy_symbol_print (stderr, \ Type, Value); \ YYFPRINTF (stderr, "\n"); \ } \ } while (0) /*----------------------------------------. | Print this symbol's value on YYOUTPUT. | `----------------------------------------*/ static void yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) { FILE *yyo = yyoutput; YYUSE (yyo); if (!yyvaluep) return; # ifdef YYPRINT if (yytype < YYNTOKENS) YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); # endif YYUSE (yytype); } /*--------------------------------. | Print this symbol on YYOUTPUT. | `--------------------------------*/ static void yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) { YYFPRINTF (yyoutput, "%s %s (", yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]); yy_symbol_value_print (yyoutput, yytype, yyvaluep); YYFPRINTF (yyoutput, ")"); } /*------------------------------------------------------------------. | yy_stack_print -- Print the state stack from its BOTTOM up to its | | TOP (included). | `------------------------------------------------------------------*/ static void yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) { YYFPRINTF (stderr, "Stack now"); for (; yybottom <= yytop; yybottom++) { int yybot = *yybottom; YYFPRINTF (stderr, " %d", yybot); } YYFPRINTF (stderr, "\n"); } # define YY_STACK_PRINT(Bottom, Top) \ do { \ if (yydebug) \ yy_stack_print ((Bottom), (Top)); \ } while (0) /*------------------------------------------------. | Report that the YYRULE is going to be reduced. | `------------------------------------------------*/ static void yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule) { unsigned long int yylno = yyrline[yyrule]; int yynrhs = yyr2[yyrule]; int yyi; YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", yyrule - 1, yylno); /* The symbols being reduced. */ for (yyi = 0; yyi < yynrhs; yyi++) { YYFPRINTF (stderr, " $%d = ", yyi + 1); yy_symbol_print (stderr, yystos[yyssp[yyi + 1 - yynrhs]], &(yyvsp[(yyi + 1) - (yynrhs)]) ); YYFPRINTF (stderr, "\n"); } } # define YY_REDUCE_PRINT(Rule) \ do { \ if (yydebug) \ yy_reduce_print (yyssp, yyvsp, Rule); \ } while (0) /* Nonzero means print parse trace. It is left uninitialized so that multiple parsers can coexist. */ int yydebug; #else /* !YYDEBUG */ # define YYDPRINTF(Args) # define YY_SYMBOL_PRINT(Title, Type, Value, Location) # define YY_STACK_PRINT(Bottom, Top) # define YY_REDUCE_PRINT(Rule) #endif /* !YYDEBUG */ /* YYINITDEPTH -- initial size of the parser's stacks. */ #ifndef YYINITDEPTH # define YYINITDEPTH 200 #endif /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only if the built-in stack extension method is used). Do not make this value too large; the results are undefined if YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) evaluated with infinite-precision integer arithmetic. */ #ifndef YYMAXDEPTH # define YYMAXDEPTH 10000 #endif #if YYERROR_VERBOSE # ifndef yystrlen # if defined __GLIBC__ && defined _STRING_H # define yystrlen strlen # else /* Return the length of YYSTR. */ static YYSIZE_T yystrlen (const char *yystr) { YYSIZE_T yylen; for (yylen = 0; yystr[yylen]; yylen++) continue; return yylen; } # endif # endif # ifndef yystpcpy # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE # define yystpcpy stpcpy # else /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in YYDEST. */ static char * yystpcpy (char *yydest, const char *yysrc) { char *yyd = yydest; const char *yys = yysrc; while ((*yyd++ = *yys++) != '\0') continue; return yyd - 1; } # endif # endif # ifndef yytnamerr /* Copy to YYRES the contents of YYSTR after stripping away unnecessary quotes and backslashes, so that it's suitable for yyerror. The heuristic is that double-quoting is unnecessary unless the string contains an apostrophe, a comma, or backslash (other than backslash-backslash). YYSTR is taken from yytname. If YYRES is null, do not copy; instead, return the length of what the result would have been. */ static YYSIZE_T yytnamerr (char *yyres, const char *yystr) { if (*yystr == '"') { YYSIZE_T yyn = 0; char const *yyp = yystr; for (;;) switch (*++yyp) { case '\'': case ',': goto do_not_strip_quotes; case '\\': if (*++yyp != '\\') goto do_not_strip_quotes; /* Fall through. */ default: if (yyres) yyres[yyn] = *yyp; yyn++; break; case '"': if (yyres) yyres[yyn] = '\0'; return yyn; } do_not_strip_quotes: ; } if (! yyres) return yystrlen (yystr); return yystpcpy (yyres, yystr) - yyres; } # endif /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message about the unexpected token YYTOKEN for the state stack whose top is YYSSP. Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is not large enough to hold the message. In that case, also set *YYMSG_ALLOC to the required number of bytes. Return 2 if the required number of bytes is too large to store. */ static int yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, yytype_int16 *yyssp, int yytoken) { YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]); YYSIZE_T yysize = yysize0; enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; /* Internationalized format string. */ const char *yyformat = YY_NULLPTR; /* Arguments of yyformat. */ char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; /* Number of reported tokens (one for the "unexpected", one per "expected"). */ int yycount = 0; /* There are many possibilities here to consider: - If this state is a consistent state with a default action, then the only way this function was invoked is if the default action is an error action. In that case, don't check for expected tokens because there are none. - The only way there can be no lookahead present (in yychar) is if this state is a consistent state with a default action. Thus, detecting the absence of a lookahead is sufficient to determine that there is no unexpected or expected token to report. In that case, just report a simple "syntax error". - Don't assume there isn't a lookahead just because this state is a consistent state with a default action. There might have been a previous inconsistent state, consistent state with a non-default action, or user semantic action that manipulated yychar. - Of course, the expected token list depends on states to have correct lookahead information, and it depends on the parser not to perform extra reductions after fetching a lookahead from the scanner and before detecting a syntax error. Thus, state merging (from LALR or IELR) and default reductions corrupt the expected token list. However, the list is correct for canonical LR with one exception: it will still contain any token that will not be accepted due to an error action in a later state. */ if (yytoken != YYEMPTY) { int yyn = yypact[*yyssp]; yyarg[yycount++] = yytname[yytoken]; if (!yypact_value_is_default (yyn)) { /* Start YYX at -YYN if negative to avoid negative indexes in YYCHECK. In other words, skip the first -YYN actions for this state because they are default actions. */ int yyxbegin = yyn < 0 ? -yyn : 0; /* Stay within bounds of both yycheck and yytname. */ int yychecklim = YYLAST - yyn + 1; int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; int yyx; for (yyx = yyxbegin; yyx < yyxend; ++yyx) if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR && !yytable_value_is_error (yytable[yyx + yyn])) { if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) { yycount = 1; yysize = yysize0; break; } yyarg[yycount++] = yytname[yyx]; { YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]); if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) return 2; yysize = yysize1; } } } } switch (yycount) { # define YYCASE_(N, S) \ case N: \ yyformat = S; \ break YYCASE_(0, YY_("syntax error")); YYCASE_(1, YY_("syntax error, unexpected %s")); YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); # undef YYCASE_ } { YYSIZE_T yysize1 = yysize + yystrlen (yyformat); if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)) return 2; yysize = yysize1; } if (*yymsg_alloc < yysize) { *yymsg_alloc = 2 * yysize; if (! (yysize <= *yymsg_alloc && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; return 1; } /* Avoid sprintf, as that infringes on the user's name space. Don't have undefined behavior even if the translation produced a string with the wrong number of "%s"s. */ { char *yyp = *yymsg; int yyi = 0; while ((*yyp = *yyformat) != '\0') if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) { yyp += yytnamerr (yyp, yyarg[yyi++]); yyformat += 2; } else { yyp++; yyformat++; } } return 0; } #endif /* YYERROR_VERBOSE */ /*-----------------------------------------------. | Release the memory associated to this symbol. | `-----------------------------------------------*/ static void yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) { YYUSE (yyvaluep); if (!yymsg) yymsg = "Deleting"; YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN YYUSE (yytype); YY_IGNORE_MAYBE_UNINITIALIZED_END } /* The lookahead symbol. */ int yychar; /* The semantic value of the lookahead symbol. */ YYSTYPE yylval; /* Number of syntax errors so far. */ int yynerrs; /*----------. | yyparse. | `----------*/ int yyparse (void) { int yystate; /* Number of tokens to shift before error messages enabled. */ int yyerrstatus; /* The stacks and their tools: 'yyss': related to states. 'yyvs': related to semantic values. Refer to the stacks through separate pointers, to allow yyoverflow to reallocate them elsewhere. */ /* The state stack. */ yytype_int16 yyssa[YYINITDEPTH]; yytype_int16 *yyss; yytype_int16 *yyssp; /* The semantic value stack. */ YYSTYPE yyvsa[YYINITDEPTH]; YYSTYPE *yyvs; YYSTYPE *yyvsp; YYSIZE_T yystacksize; int yyn; int yyresult; /* Lookahead token as an internal (translated) token number. */ int yytoken = 0; /* The variables used to return semantic value and location from the action routines. */ YYSTYPE yyval; #if YYERROR_VERBOSE /* Buffer for error messages, and its allocated size. */ char yymsgbuf[128]; char *yymsg = yymsgbuf; YYSIZE_T yymsg_alloc = sizeof yymsgbuf; #endif #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) /* The number of symbols on the RHS of the reduced rule. Keep to zero when no symbol should be popped. */ int yylen = 0; yyssp = yyss = yyssa; yyvsp = yyvs = yyvsa; yystacksize = YYINITDEPTH; YYDPRINTF ((stderr, "Starting parse\n")); yystate = 0; yyerrstatus = 0; yynerrs = 0; yychar = YYEMPTY; /* Cause a token to be read. */ goto yysetstate; /*------------------------------------------------------------. | yynewstate -- Push a new state, which is found in yystate. | `------------------------------------------------------------*/ yynewstate: /* In all cases, when you get here, the value and location stacks have just been pushed. So pushing a state here evens the stacks. */ yyssp++; yysetstate: *yyssp = yystate; if (yyss + yystacksize - 1 <= yyssp) { /* Get the current used size of the three stacks, in elements. */ YYSIZE_T yysize = yyssp - yyss + 1; #ifdef yyoverflow { /* Give user a chance to reallocate the stack. Use copies of these so that the &'s don't force the real ones into memory. */ YYSTYPE *yyvs1 = yyvs; yytype_int16 *yyss1 = yyss; /* Each stack pointer address is followed by the size of the data in use in that stack, in bytes. This used to be a conditional around just the two extra args, but that might be undefined if yyoverflow is a macro. */ yyoverflow (YY_("memory exhausted"), &yyss1, yysize * sizeof (*yyssp), &yyvs1, yysize * sizeof (*yyvsp), &yystacksize); yyss = yyss1; yyvs = yyvs1; } #else /* no yyoverflow */ # ifndef YYSTACK_RELOCATE goto yyexhaustedlab; # else /* Extend the stack our own way. */ if (YYMAXDEPTH <= yystacksize) goto yyexhaustedlab; yystacksize *= 2; if (YYMAXDEPTH < yystacksize) yystacksize = YYMAXDEPTH; { yytype_int16 *yyss1 = yyss; union yyalloc *yyptr = (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); if (! yyptr) goto yyexhaustedlab; YYSTACK_RELOCATE (yyss_alloc, yyss); YYSTACK_RELOCATE (yyvs_alloc, yyvs); # undef YYSTACK_RELOCATE if (yyss1 != yyssa) YYSTACK_FREE (yyss1); } # endif #endif /* no yyoverflow */ yyssp = yyss + yysize - 1; yyvsp = yyvs + yysize - 1; YYDPRINTF ((stderr, "Stack size increased to %lu\n", (unsigned long int) yystacksize)); if (yyss + yystacksize - 1 <= yyssp) YYABORT; } YYDPRINTF ((stderr, "Entering state %d\n", yystate)); if (yystate == YYFINAL) YYACCEPT; goto yybackup; /*-----------. | yybackup. | `-----------*/ yybackup: /* Do appropriate processing given the current state. Read a lookahead token if we need one and don't already have one. */ /* First try to decide what to do without reference to lookahead token. */ yyn = yypact[yystate]; if (yypact_value_is_default (yyn)) goto yydefault; /* Not known => get a lookahead token if don't already have one. */ /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ if (yychar == YYEMPTY) { YYDPRINTF ((stderr, "Reading a token: ")); yychar = yylex (); } if (yychar <= YYEOF) { yychar = yytoken = YYEOF; YYDPRINTF ((stderr, "Now at end of input.\n")); } else { yytoken = YYTRANSLATE (yychar); YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); } /* If the proper action on seeing token YYTOKEN is to reduce or to detect an error, take that action. */ yyn += yytoken; if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) goto yydefault; yyn = yytable[yyn]; if (yyn <= 0) { if (yytable_value_is_error (yyn)) goto yyerrlab; yyn = -yyn; goto yyreduce; } /* Count tokens shifted since error; after three, turn off error status. */ if (yyerrstatus) yyerrstatus--; /* Shift the lookahead token. */ YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); /* Discard the shifted token. */ yychar = YYEMPTY; yystate = yyn; YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN *++yyvsp = yylval; YY_IGNORE_MAYBE_UNINITIALIZED_END goto yynewstate; /*-----------------------------------------------------------. | yydefault -- do the default action for the current state. | `-----------------------------------------------------------*/ yydefault: yyn = yydefact[yystate]; if (yyn == 0) goto yyerrlab; goto yyreduce; /*-----------------------------. | yyreduce -- Do a reduction. | `-----------------------------*/ yyreduce: /* yyn is the number of a rule to reduce with. */ yylen = yyr2[yyn]; /* If YYLEN is nonzero, implement the default value of the action: '$$ = $1'. Otherwise, the following line sets YYVAL to garbage. This behavior is undocumented and Bison users should not rely upon it. Assigning to YYVAL unconditionally makes the parser a bit smaller, and it avoids a GCC warning that YYVAL may be used uninitialized. */ yyval = yyvsp[1-yylen]; YY_REDUCE_PRINT (yyn); switch (yyn) { case 2: #line 796 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = BFNULL; } #line 4516 "gram1.tab.c" /* yacc.c:1646 */ break; case 3: #line 798 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = set_stat_list((yyvsp[-2].bf_node),(yyvsp[-1].bf_node)); } #line 4522 "gram1.tab.c" /* yacc.c:1646 */ break; case 4: #line 802 "gram1.y" /* yacc.c:1646 */ { lastwasbranch = NO; (yyval.bf_node) = BFNULL; } #line 4528 "gram1.tab.c" /* yacc.c:1646 */ break; case 5: #line 804 "gram1.y" /* yacc.c:1646 */ { if ((yyvsp[-1].bf_node) != BFNULL) { (yyvsp[-1].bf_node)->label = (yyvsp[-2].label); (yyval.bf_node) = (yyvsp[-1].bf_node); if (is_openmp_stmt) { /*OMP*/ is_openmp_stmt = 0; if((yyvsp[-1].bf_node)) { /*OMP*/ if ((yyvsp[-1].bf_node)->decl_specs != -BIT_OPENMP) (yyvsp[-1].bf_node)->decl_specs = BIT_OPENMP; /*OMP*/ } /*OMP*/ } /*OMP*/ } } #line 4546 "gram1.tab.c" /* yacc.c:1646 */ break; case 6: #line 818 "gram1.y" /* yacc.c:1646 */ { PTR_BFND p; if(lastwasbranch && ! thislabel) /*if (warn_all) warn("statement cannot be reached", 36);*/ lastwasbranch = thiswasbranch; thiswasbranch = NO; if((yyvsp[-1].bf_node)) (yyvsp[-1].bf_node)->label = (yyvsp[-2].label); if((yyvsp[-2].label) && (yyvsp[-1].bf_node)) (yyvsp[-2].label)->statbody = (yyvsp[-1].bf_node); /*8.11.06 podd*/ if((yyvsp[-2].label)) { /*$1->statbody = $2;*/ /*8.11.06 podd*/ if((yyvsp[-2].label)->labtype == LABFORMAT) err("label already that of a format",39); else (yyvsp[-2].label)->labtype = LABEXEC; } if (is_openmp_stmt) { /*OMP*/ is_openmp_stmt = 0; if((yyvsp[-1].bf_node)) { /*OMP*/ if ((yyvsp[-1].bf_node)->decl_specs != -BIT_OPENMP) (yyvsp[-1].bf_node)->decl_specs = BIT_OPENMP; /*OMP*/ } /*OMP*/ } /*OMP*/ for (p = pred_bfnd; (yyvsp[-2].label) && ((p->variant == FOR_NODE)||(p->variant == WHILE_NODE)) && (p->entry.for_node.doend) && (p->entry.for_node.doend->stateno == (yyvsp[-2].label)->stateno); p = p->control_parent) ++end_group; (yyval.bf_node) = (yyvsp[-1].bf_node); } #line 4581 "gram1.tab.c" /* yacc.c:1646 */ break; case 7: #line 849 "gram1.y" /* yacc.c:1646 */ { /* PTR_LLND p; */ doinclude( (yyvsp[0].charp) ); /* p = make_llnd(fi, STRING_VAL, LLNULL, LLNULL, SMNULL); p->entry.string_val = $3; p->type = global_string; $$ = get_bfnd(fi, INCLUDE_STAT, SMNULL, p, LLNULL); */ (yyval.bf_node) = BFNULL; } #line 4594 "gram1.tab.c" /* yacc.c:1646 */ break; case 8: #line 858 "gram1.y" /* yacc.c:1646 */ { err("Unclassifiable statement", 10); flline(); (yyval.bf_node) = BFNULL; } #line 4604 "gram1.tab.c" /* yacc.c:1646 */ break; case 9: #line 864 "gram1.y" /* yacc.c:1646 */ { PTR_CMNT p; PTR_BFND bif; if (last_bfnd && last_bfnd->control_parent &&((last_bfnd->control_parent->variant == LOGIF_NODE) ||(last_bfnd->control_parent->variant == FORALL_STAT))) bif = last_bfnd->control_parent; else bif = last_bfnd; p=bif->entry.Template.cmnt_ptr; if(p) p->string = StringConcatenation(p->string,commentbuf); else { p = make_comment(fi,commentbuf, FULL); bif->entry.Template.cmnt_ptr = p; } (yyval.bf_node) = BFNULL; } #line 4627 "gram1.tab.c" /* yacc.c:1646 */ break; case 10: #line 884 "gram1.y" /* yacc.c:1646 */ { flline(); needkwd = NO; inioctl = NO; /*!!!*/ opt_kwd_ = NO; intonly = NO; opt_kwd_hedr = NO; opt_kwd_r = NO; as_op_kwd_= NO; optcorner = NO; yyerrok; yyclearin; (yyval.bf_node) = BFNULL; } #line 4638 "gram1.tab.c" /* yacc.c:1646 */ break; case 11: #line 893 "gram1.y" /* yacc.c:1646 */ { if(yystno) { (yyval.label) = thislabel = make_label_node(fi,yystno); thislabel->scope = cur_scope(); if (thislabel->labdefined && (thislabel->scope == cur_scope())) errstr("Label %s already defined",convic(thislabel->stateno),40); else thislabel->labdefined = YES; } else (yyval.label) = thislabel = LBNULL; } #line 4656 "gram1.tab.c" /* yacc.c:1646 */ break; case 12: #line 909 "gram1.y" /* yacc.c:1646 */ { PTR_BFND p; if (pred_bfnd != global_bfnd) err("Misplaced PROGRAM statement", 33); p = get_bfnd(fi,PROG_HEDR, (yyvsp[0].symbol), LLNULL, LLNULL, LLNULL); (yyvsp[0].symbol)->entry.prog_decl.prog_hedr=p; set_blobs(p, global_bfnd, NEW_GROUP1); add_scope_level(p, NO); position = IN_PROC; } #line 4671 "gram1.tab.c" /* yacc.c:1646 */ break; case 13: #line 921 "gram1.y" /* yacc.c:1646 */ { PTR_BFND q = BFNULL; (yyvsp[0].symbol)->variant = PROCEDURE_NAME; (yyvsp[0].symbol)->decl = YES; /* variable declaration has been seen. */ q = get_bfnd(fi,BLOCK_DATA, (yyvsp[0].symbol), LLNULL, LLNULL, LLNULL); set_blobs(q, global_bfnd, NEW_GROUP1); add_scope_level(q, NO); } #line 4684 "gram1.tab.c" /* yacc.c:1646 */ break; case 14: #line 931 "gram1.y" /* yacc.c:1646 */ { install_param_list((yyvsp[-1].symbol), (yyvsp[0].symbol), LLNULL, PROCEDURE_NAME); /* if there is only a control end the control parent is not set */ } #line 4694 "gram1.tab.c" /* yacc.c:1646 */ break; case 15: #line 938 "gram1.y" /* yacc.c:1646 */ { install_param_list((yyvsp[-1].symbol), (yyvsp[0].symbol), LLNULL, PROCEDURE_NAME); if((yyvsp[-4].ll_node)->variant == RECURSIVE_OP) (yyvsp[-1].symbol)->attr = (yyvsp[-1].symbol)->attr | RECURSIVE_BIT; pred_bfnd->entry.Template.ll_ptr3 = (yyvsp[-4].ll_node); } #line 4704 "gram1.tab.c" /* yacc.c:1646 */ break; case 16: #line 944 "gram1.y" /* yacc.c:1646 */ { install_param_list((yyvsp[-2].symbol), (yyvsp[-1].symbol), (yyvsp[0].ll_node), FUNCTION_NAME); pred_bfnd->entry.Template.ll_ptr1 = (yyvsp[0].ll_node); } #line 4713 "gram1.tab.c" /* yacc.c:1646 */ break; case 17: #line 949 "gram1.y" /* yacc.c:1646 */ { install_param_list((yyvsp[-2].symbol), (yyvsp[-1].symbol), (yyvsp[0].ll_node), FUNCTION_NAME); pred_bfnd->entry.Template.ll_ptr1 = (yyvsp[0].ll_node); } #line 4722 "gram1.tab.c" /* yacc.c:1646 */ break; case 18: #line 954 "gram1.y" /* yacc.c:1646 */ {PTR_BFND p, bif; PTR_SYMB q = SMNULL; PTR_LLND l = LLNULL; if(parstate==OUTSIDE || procclass==CLMAIN || procclass==CLBLOCK) err("Misplaced ENTRY statement", 35); bif = cur_scope(); if (bif->variant == FUNC_HEDR) { q = make_function((yyvsp[-2].hash_entry), bif->entry.Template.symbol->type, LOCAL); l = construct_entry_list(q, (yyvsp[-1].symbol), FUNCTION_NAME); } else if ((bif->variant == PROC_HEDR) || (bif->variant == PROS_HEDR) || /* added for FORTRAN M */ (bif->variant == PROG_HEDR)) { q = make_procedure((yyvsp[-2].hash_entry),LOCAL); l = construct_entry_list(q, (yyvsp[-1].symbol), PROCEDURE_NAME); } p = get_bfnd(fi,ENTRY_STAT, q, l, (yyvsp[0].ll_node), LLNULL); set_blobs(p, pred_bfnd, SAME_GROUP); q->decl = YES; /*4.02.03*/ q->entry.proc_decl.proc_hedr = p; /*5.02.03*/ } #line 4750 "gram1.tab.c" /* yacc.c:1646 */ break; case 19: #line 978 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; PTR_BFND p; /* s = make_global_entity($3, MODULE_NAME, global_default, NO); s->decl = YES; p = get_bfnd(fi, MODULE_STMT, s, LLNULL, LLNULL, LLNULL); s->entry.Template.func_hedr = p; set_blobs(p, pred_bfnd, NEW_GROUP1); add_scope_level(p, NO); */ /*position = IN_MODULE;*/ s = make_module((yyvsp[0].hash_entry)); s->decl = YES; /* variable declaration has been seen. */ if (pred_bfnd != global_bfnd) err("Misplaced MODULE statement", 33); p = get_bfnd(fi, MODULE_STMT, s, LLNULL, LLNULL, LLNULL); s->entry.Template.func_hedr = p; /* !!!????*/ set_blobs(p, global_bfnd, NEW_GROUP1); add_scope_level(p, NO); position = IN_MODULE; /*IN_PROC*/ privateall = 0; } #line 4779 "gram1.tab.c" /* yacc.c:1646 */ break; case 20: #line 1004 "gram1.y" /* yacc.c:1646 */ { newprog(); if (position == IN_OUTSIDE) position = IN_PROC; else if (position != IN_INTERNAL_PROC){ if(!is_interface_stat(pred_bfnd)) position--; } else { if(!is_interface_stat(pred_bfnd)) err("Internal procedures can not contain procedures",304); } } #line 4796 "gram1.tab.c" /* yacc.c:1646 */ break; case 21: #line 1019 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi, RECURSIVE_OP, LLNULL, LLNULL, SMNULL); } #line 4802 "gram1.tab.c" /* yacc.c:1646 */ break; case 22: #line 1021 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi, PURE_OP, LLNULL, LLNULL, SMNULL); } #line 4808 "gram1.tab.c" /* yacc.c:1646 */ break; case 23: #line 1023 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi, ELEMENTAL_OP, LLNULL, LLNULL, SMNULL); } #line 4814 "gram1.tab.c" /* yacc.c:1646 */ break; case 24: #line 1027 "gram1.y" /* yacc.c:1646 */ { PTR_BFND p; (yyval.symbol) = make_procedure((yyvsp[0].hash_entry), LOCAL); (yyval.symbol)->decl = YES; /* variable declaration has been seen. */ /* if (pred_bfnd != global_bfnd) { err("Misplaced SUBROUTINE statement", 34); } */ p = get_bfnd(fi,PROC_HEDR, (yyval.symbol), LLNULL, LLNULL, LLNULL); (yyval.symbol)->entry.proc_decl.proc_hedr = p; set_blobs(p, pred_bfnd, NEW_GROUP1); add_scope_level(p, NO); } #line 4833 "gram1.tab.c" /* yacc.c:1646 */ break; case 25: #line 1044 "gram1.y" /* yacc.c:1646 */ { PTR_BFND p; (yyval.symbol) = make_function((yyvsp[0].hash_entry), TYNULL, LOCAL); (yyval.symbol)->decl = YES; /* variable declaration has been seen. */ /* if (pred_bfnd != global_bfnd) err("Misplaced FUNCTION statement", 34); */ p = get_bfnd(fi,FUNC_HEDR, (yyval.symbol), LLNULL, LLNULL, LLNULL); (yyval.symbol)->entry.func_decl.func_hedr = p; set_blobs(p, pred_bfnd, NEW_GROUP1); add_scope_level(p, NO); } #line 4849 "gram1.tab.c" /* yacc.c:1646 */ break; case 26: #line 1058 "gram1.y" /* yacc.c:1646 */ { PTR_BFND p; PTR_LLND l; (yyval.symbol) = make_function((yyvsp[0].hash_entry), (yyvsp[-3].data_type), LOCAL); (yyval.symbol)->decl = YES; /* variable declaration has been seen. */ l = make_llnd(fi, TYPE_OP, LLNULL, LLNULL, SMNULL); l->type = (yyvsp[-3].data_type); p = get_bfnd(fi,FUNC_HEDR, (yyval.symbol), LLNULL, l, LLNULL); (yyval.symbol)->entry.func_decl.func_hedr = p; /* if (pred_bfnd != global_bfnd) err("Misplaced FUNCTION statement", 34);*/ set_blobs(p, pred_bfnd, NEW_GROUP1); add_scope_level(p, NO); /* $$ = make_function($4, $1, LOCAL); $$->decl = YES; p = get_bfnd(fi,FUNC_HEDR, $$, LLNULL, LLNULL, LLNULL); if (pred_bfnd != global_bfnd) errstr("cftn.gram: misplaced SUBROUTINE statement."); set_blobs(p, pred_bfnd, NEW_GROUP1); add_scope_level(p, NO); */ } #line 4877 "gram1.tab.c" /* yacc.c:1646 */ break; case 27: #line 1082 "gram1.y" /* yacc.c:1646 */ { PTR_BFND p; PTR_LLND l; (yyval.symbol) = make_function((yyvsp[0].hash_entry), (yyvsp[-4].data_type), LOCAL); (yyval.symbol)->decl = YES; /* variable declaration has been seen. */ if((yyvsp[-3].ll_node)->variant == RECURSIVE_OP) (yyval.symbol)->attr = (yyval.symbol)->attr | RECURSIVE_BIT; l = make_llnd(fi, TYPE_OP, LLNULL, LLNULL, SMNULL); l->type = (yyvsp[-4].data_type); /* if (pred_bfnd != global_bfnd) err("Misplaced FUNCTION statement", 34);*/ p = get_bfnd(fi,FUNC_HEDR, (yyval.symbol), LLNULL, l, (yyvsp[-3].ll_node)); (yyval.symbol)->entry.func_decl.func_hedr = p; set_blobs(p, pred_bfnd, NEW_GROUP1); add_scope_level(p, NO); } #line 4897 "gram1.tab.c" /* yacc.c:1646 */ break; case 28: #line 1098 "gram1.y" /* yacc.c:1646 */ { PTR_BFND p; (yyval.symbol) = make_function((yyvsp[0].hash_entry), TYNULL, LOCAL); (yyval.symbol)->decl = YES; /* variable declaration has been seen. */ if((yyvsp[-3].ll_node)->variant == RECURSIVE_OP) (yyval.symbol)->attr = (yyval.symbol)->attr | RECURSIVE_BIT; /*if (pred_bfnd != global_bfnd) err("Misplaced FUNCTION statement",34);*/ p = get_bfnd(fi,FUNC_HEDR, (yyval.symbol), LLNULL, LLNULL, (yyvsp[-3].ll_node)); (yyval.symbol)->entry.func_decl.func_hedr = p; set_blobs(p, pred_bfnd, NEW_GROUP1); add_scope_level(p, NO); } #line 4915 "gram1.tab.c" /* yacc.c:1646 */ break; case 29: #line 1112 "gram1.y" /* yacc.c:1646 */ { PTR_BFND p; PTR_LLND l; (yyval.symbol) = make_function((yyvsp[0].hash_entry), (yyvsp[-3].data_type), LOCAL); (yyval.symbol)->decl = YES; /* variable declaration has been seen. */ if((yyvsp[-4].ll_node)->variant == RECURSIVE_OP) (yyval.symbol)->attr = (yyval.symbol)->attr | RECURSIVE_BIT; l = make_llnd(fi, TYPE_OP, LLNULL, LLNULL, SMNULL); l->type = (yyvsp[-3].data_type); /* if (pred_bfnd != global_bfnd) err("Misplaced FUNCTION statement",34);*/ p = get_bfnd(fi,FUNC_HEDR, (yyval.symbol), LLNULL, l, (yyvsp[-4].ll_node)); (yyval.symbol)->entry.func_decl.func_hedr = p; set_blobs(p, pred_bfnd, NEW_GROUP1); add_scope_level(p, NO); } #line 4935 "gram1.tab.c" /* yacc.c:1646 */ break; case 30: #line 1130 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = LLNULL; } #line 4941 "gram1.tab.c" /* yacc.c:1646 */ break; case 31: #line 1132 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; s = make_scalar((yyvsp[-1].hash_entry), TYNULL, LOCAL); (yyval.ll_node) = make_llnd(fi, VAR_REF, LLNULL, LLNULL, s); } #line 4950 "gram1.tab.c" /* yacc.c:1646 */ break; case 32: #line 1139 "gram1.y" /* yacc.c:1646 */ { (yyval.hash_entry) = look_up_sym(yytext); } #line 4956 "gram1.tab.c" /* yacc.c:1646 */ break; case 33: #line 1142 "gram1.y" /* yacc.c:1646 */ { (yyval.symbol) = make_program(look_up_sym("_MAIN")); } #line 4962 "gram1.tab.c" /* yacc.c:1646 */ break; case 34: #line 1144 "gram1.y" /* yacc.c:1646 */ { (yyval.symbol) = make_program((yyvsp[0].hash_entry)); (yyval.symbol)->decl = YES; /* variable declaration has been seen. */ } #line 4971 "gram1.tab.c" /* yacc.c:1646 */ break; case 35: #line 1150 "gram1.y" /* yacc.c:1646 */ { (yyval.symbol) = make_program(look_up_sym("_BLOCK")); } #line 4977 "gram1.tab.c" /* yacc.c:1646 */ break; case 36: #line 1152 "gram1.y" /* yacc.c:1646 */ { (yyval.symbol) = make_program((yyvsp[0].hash_entry)); (yyval.symbol)->decl = YES; /* variable declaration has been seen. */ } #line 4986 "gram1.tab.c" /* yacc.c:1646 */ break; case 37: #line 1159 "gram1.y" /* yacc.c:1646 */ { (yyval.symbol) = SMNULL; } #line 4992 "gram1.tab.c" /* yacc.c:1646 */ break; case 38: #line 1161 "gram1.y" /* yacc.c:1646 */ { (yyval.symbol) = SMNULL; } #line 4998 "gram1.tab.c" /* yacc.c:1646 */ break; case 39: #line 1163 "gram1.y" /* yacc.c:1646 */ { (yyval.symbol) = (yyvsp[-1].symbol); } #line 5004 "gram1.tab.c" /* yacc.c:1646 */ break; case 41: #line 1168 "gram1.y" /* yacc.c:1646 */ { (yyval.symbol) = set_id_list((yyvsp[-2].symbol), (yyvsp[0].symbol)); } #line 5010 "gram1.tab.c" /* yacc.c:1646 */ break; case 42: #line 1172 "gram1.y" /* yacc.c:1646 */ { (yyval.symbol) = make_scalar((yyvsp[0].hash_entry), TYNULL, IO); } #line 5018 "gram1.tab.c" /* yacc.c:1646 */ break; case 43: #line 1176 "gram1.y" /* yacc.c:1646 */ { (yyval.symbol) = make_scalar(look_up_sym("*"), TYNULL, IO); } #line 5024 "gram1.tab.c" /* yacc.c:1646 */ break; case 44: #line 1182 "gram1.y" /* yacc.c:1646 */ { char *s; s = copyn(yyleng+1, yytext); s[yyleng] = '\0'; (yyval.charp) = s; } #line 5035 "gram1.tab.c" /* yacc.c:1646 */ break; case 45: #line 1191 "gram1.y" /* yacc.c:1646 */ { needkwd = 1; } #line 5041 "gram1.tab.c" /* yacc.c:1646 */ break; case 46: #line 1195 "gram1.y" /* yacc.c:1646 */ { needkwd = NO; } #line 5047 "gram1.tab.c" /* yacc.c:1646 */ break; case 47: #line 1200 "gram1.y" /* yacc.c:1646 */ { colon_flag = YES; } #line 5053 "gram1.tab.c" /* yacc.c:1646 */ break; case 62: #line 1222 "gram1.y" /* yacc.c:1646 */ { saveall = YES; (yyval.bf_node) = get_bfnd(fi,SAVE_DECL, SMNULL, LLNULL, LLNULL, LLNULL); } #line 5062 "gram1.tab.c" /* yacc.c:1646 */ break; case 63: #line 1227 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,SAVE_DECL, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL); } #line 5070 "gram1.tab.c" /* yacc.c:1646 */ break; case 64: #line 1232 "gram1.y" /* yacc.c:1646 */ { PTR_LLND p; p = make_llnd(fi,STMT_STR, LLNULL, LLNULL, SMNULL); p->entry.string_val = copys(stmtbuf); (yyval.bf_node) = get_bfnd(fi,FORMAT_STAT, SMNULL, p, LLNULL, LLNULL); } #line 5081 "gram1.tab.c" /* yacc.c:1646 */ break; case 65: #line 1239 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,PARAM_DECL, SMNULL, (yyvsp[-1].ll_node), LLNULL, LLNULL); } #line 5087 "gram1.tab.c" /* yacc.c:1646 */ break; case 78: #line 1255 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi, INTERFACE_STMT, SMNULL, LLNULL, LLNULL, LLNULL); add_scope_level((yyval.bf_node), NO); } #line 5095 "gram1.tab.c" /* yacc.c:1646 */ break; case 79: #line 1259 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; s = make_procedure((yyvsp[0].hash_entry), LOCAL); s->variant = INTERFACE_NAME; (yyval.bf_node) = get_bfnd(fi, INTERFACE_STMT, s, LLNULL, LLNULL, LLNULL); add_scope_level((yyval.bf_node), NO); } #line 5107 "gram1.tab.c" /* yacc.c:1646 */ break; case 80: #line 1267 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; s = make_function((yyvsp[-1].hash_entry), global_default, LOCAL); s->variant = INTERFACE_NAME; (yyval.bf_node) = get_bfnd(fi, INTERFACE_OPERATOR, s, LLNULL, LLNULL, LLNULL); add_scope_level((yyval.bf_node), NO); } #line 5119 "gram1.tab.c" /* yacc.c:1646 */ break; case 81: #line 1275 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; s = make_procedure(look_up_sym("="), LOCAL); s->variant = INTERFACE_NAME; (yyval.bf_node) = get_bfnd(fi, INTERFACE_ASSIGNMENT, s, LLNULL, LLNULL, LLNULL); add_scope_level((yyval.bf_node), NO); } #line 5132 "gram1.tab.c" /* yacc.c:1646 */ break; case 82: #line 1284 "gram1.y" /* yacc.c:1646 */ { parstate = INDCL; (yyval.bf_node) = get_bfnd(fi, CONTROL_END, SMNULL, LLNULL, LLNULL, LLNULL); /*process_interface($$);*/ /*podd 01.02.03*/ delete_beyond_scope_level(pred_bfnd); } #line 5142 "gram1.tab.c" /* yacc.c:1646 */ break; case 83: #line 1292 "gram1.y" /* yacc.c:1646 */ { (yyval.hash_entry) = look_up_sym(yytext); } #line 5148 "gram1.tab.c" /* yacc.c:1646 */ break; case 84: #line 1296 "gram1.y" /* yacc.c:1646 */ { (yyval.hash_entry) = (yyvsp[0].hash_entry); } #line 5154 "gram1.tab.c" /* yacc.c:1646 */ break; case 85: #line 1298 "gram1.y" /* yacc.c:1646 */ { (yyval.hash_entry) = (yyvsp[0].hash_entry); } #line 5160 "gram1.tab.c" /* yacc.c:1646 */ break; case 86: #line 1302 "gram1.y" /* yacc.c:1646 */ { (yyval.hash_entry) = look_up_op(PLUS); } #line 5166 "gram1.tab.c" /* yacc.c:1646 */ break; case 87: #line 1304 "gram1.y" /* yacc.c:1646 */ { (yyval.hash_entry) = look_up_op(MINUS); } #line 5172 "gram1.tab.c" /* yacc.c:1646 */ break; case 88: #line 1306 "gram1.y" /* yacc.c:1646 */ { (yyval.hash_entry) = look_up_op(ASTER); } #line 5178 "gram1.tab.c" /* yacc.c:1646 */ break; case 89: #line 1308 "gram1.y" /* yacc.c:1646 */ { (yyval.hash_entry) = look_up_op(DASTER); } #line 5184 "gram1.tab.c" /* yacc.c:1646 */ break; case 90: #line 1310 "gram1.y" /* yacc.c:1646 */ { (yyval.hash_entry) = look_up_op(SLASH); } #line 5190 "gram1.tab.c" /* yacc.c:1646 */ break; case 91: #line 1312 "gram1.y" /* yacc.c:1646 */ { (yyval.hash_entry) = look_up_op(DSLASH); } #line 5196 "gram1.tab.c" /* yacc.c:1646 */ break; case 92: #line 1314 "gram1.y" /* yacc.c:1646 */ { (yyval.hash_entry) = look_up_op(AND); } #line 5202 "gram1.tab.c" /* yacc.c:1646 */ break; case 93: #line 1316 "gram1.y" /* yacc.c:1646 */ { (yyval.hash_entry) = look_up_op(OR); } #line 5208 "gram1.tab.c" /* yacc.c:1646 */ break; case 94: #line 1318 "gram1.y" /* yacc.c:1646 */ { (yyval.hash_entry) = look_up_op(XOR); } #line 5214 "gram1.tab.c" /* yacc.c:1646 */ break; case 95: #line 1320 "gram1.y" /* yacc.c:1646 */ { (yyval.hash_entry) = look_up_op(NOT); } #line 5220 "gram1.tab.c" /* yacc.c:1646 */ break; case 96: #line 1322 "gram1.y" /* yacc.c:1646 */ { (yyval.hash_entry) = look_up_op(EQ); } #line 5226 "gram1.tab.c" /* yacc.c:1646 */ break; case 97: #line 1324 "gram1.y" /* yacc.c:1646 */ { (yyval.hash_entry) = look_up_op(NE); } #line 5232 "gram1.tab.c" /* yacc.c:1646 */ break; case 98: #line 1326 "gram1.y" /* yacc.c:1646 */ { (yyval.hash_entry) = look_up_op(GT); } #line 5238 "gram1.tab.c" /* yacc.c:1646 */ break; case 99: #line 1328 "gram1.y" /* yacc.c:1646 */ { (yyval.hash_entry) = look_up_op(GE); } #line 5244 "gram1.tab.c" /* yacc.c:1646 */ break; case 100: #line 1330 "gram1.y" /* yacc.c:1646 */ { (yyval.hash_entry) = look_up_op(LT); } #line 5250 "gram1.tab.c" /* yacc.c:1646 */ break; case 101: #line 1332 "gram1.y" /* yacc.c:1646 */ { (yyval.hash_entry) = look_up_op(LE); } #line 5256 "gram1.tab.c" /* yacc.c:1646 */ break; case 102: #line 1334 "gram1.y" /* yacc.c:1646 */ { (yyval.hash_entry) = look_up_op(NEQV); } #line 5262 "gram1.tab.c" /* yacc.c:1646 */ break; case 103: #line 1336 "gram1.y" /* yacc.c:1646 */ { (yyval.hash_entry) = look_up_op(EQV); } #line 5268 "gram1.tab.c" /* yacc.c:1646 */ break; case 104: #line 1341 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; type_var = s = make_derived_type((yyvsp[0].hash_entry), TYNULL, LOCAL); (yyval.bf_node) = get_bfnd(fi, STRUCT_DECL, s, LLNULL, LLNULL, LLNULL); add_scope_level((yyval.bf_node), NO); } #line 5280 "gram1.tab.c" /* yacc.c:1646 */ break; case 105: #line 1350 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; type_var = s = make_derived_type((yyvsp[0].hash_entry), TYNULL, LOCAL); s->attr = s->attr | type_opt; (yyval.bf_node) = get_bfnd(fi, STRUCT_DECL, s, (yyvsp[-2].ll_node), LLNULL, LLNULL); add_scope_level((yyval.bf_node), NO); } #line 5292 "gram1.tab.c" /* yacc.c:1646 */ break; case 106: #line 1360 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi, CONTROL_END, SMNULL, LLNULL, LLNULL, LLNULL); if (type_var != SMNULL) process_type(type_var, (yyval.bf_node)); type_var = SMNULL; delete_beyond_scope_level(pred_bfnd); } #line 5304 "gram1.tab.c" /* yacc.c:1646 */ break; case 107: #line 1368 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi, CONTROL_END, SMNULL, LLNULL, LLNULL, LLNULL); if (type_var != SMNULL) process_type(type_var, (yyval.bf_node)); type_var = SMNULL; delete_beyond_scope_level(pred_bfnd); } #line 5316 "gram1.tab.c" /* yacc.c:1646 */ break; case 108: #line 1378 "gram1.y" /* yacc.c:1646 */ { PTR_LLND q, r, l; /* PTR_SYMB s;*/ PTR_TYPE t; int type_opts; vartype = (yyvsp[-6].data_type); if((yyvsp[-1].ll_node) && vartype->variant != T_STRING) errstr("Non character entity %s has length specification",(yyvsp[-4].hash_entry)->ident,41); t = make_type_node(vartype, (yyvsp[-1].ll_node)); type_opts = type_options; if ((yyvsp[-2].ll_node)) type_opts = type_opts | DIMENSION_BIT; if ((yyvsp[-2].ll_node)) q = deal_with_options((yyvsp[-4].hash_entry), t, type_opts, (yyvsp[-2].ll_node), ndim, (yyvsp[0].ll_node), (yyvsp[-2].ll_node)); else q = deal_with_options((yyvsp[-4].hash_entry), t, type_opts, attr_dims, attr_ndim, (yyvsp[0].ll_node), (yyvsp[-2].ll_node)); r = make_llnd(fi, EXPR_LIST, q, LLNULL, SMNULL); l = make_llnd(fi, TYPE_OP, LLNULL, LLNULL, SMNULL); l->type = vartype; (yyval.bf_node) = get_bfnd(fi,VAR_DECL, SMNULL, r, l, (yyvsp[-5].ll_node)); } #line 5341 "gram1.tab.c" /* yacc.c:1646 */ break; case 109: #line 1399 "gram1.y" /* yacc.c:1646 */ { PTR_LLND q, r; /* PTR_SYMB s;*/ PTR_TYPE t; int type_opts; if((yyvsp[-1].ll_node) && vartype->variant != T_STRING) errstr("Non character entity %s has length specification",(yyvsp[-3].hash_entry)->ident,41); t = make_type_node(vartype, (yyvsp[-1].ll_node)); type_opts = type_options; if ((yyvsp[-2].ll_node)) type_opts = type_opts | DIMENSION_BIT; if ((yyvsp[-2].ll_node)) q = deal_with_options((yyvsp[-3].hash_entry), t, type_opts, (yyvsp[-2].ll_node), ndim, (yyvsp[0].ll_node), (yyvsp[-2].ll_node)); else q = deal_with_options((yyvsp[-3].hash_entry), t, type_opts, attr_dims, attr_ndim, (yyvsp[0].ll_node), (yyvsp[-2].ll_node)); r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL); add_to_lowLevelList(r, (yyvsp[-5].bf_node)->entry.Template.ll_ptr1); } #line 5362 "gram1.tab.c" /* yacc.c:1646 */ break; case 110: #line 1418 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = LLNULL; } #line 5368 "gram1.tab.c" /* yacc.c:1646 */ break; case 111: #line 1420 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = LLNULL; } #line 5374 "gram1.tab.c" /* yacc.c:1646 */ break; case 112: #line 1422 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[-2].ll_node); } #line 5380 "gram1.tab.c" /* yacc.c:1646 */ break; case 113: #line 1426 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); } #line 5386 "gram1.tab.c" /* yacc.c:1646 */ break; case 114: #line 1428 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-3].ll_node), (yyvsp[0].ll_node), EXPR_LIST); } #line 5392 "gram1.tab.c" /* yacc.c:1646 */ break; case 115: #line 1432 "gram1.y" /* yacc.c:1646 */ { type_options = type_options | PARAMETER_BIT; (yyval.ll_node) = make_llnd(fi, PARAMETER_OP, LLNULL, LLNULL, SMNULL); } #line 5400 "gram1.tab.c" /* yacc.c:1646 */ break; case 116: #line 1436 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node); } #line 5406 "gram1.tab.c" /* yacc.c:1646 */ break; case 117: #line 1438 "gram1.y" /* yacc.c:1646 */ { type_options = type_options | ALLOCATABLE_BIT; (yyval.ll_node) = make_llnd(fi, ALLOCATABLE_OP, LLNULL, LLNULL, SMNULL); } #line 5414 "gram1.tab.c" /* yacc.c:1646 */ break; case 118: #line 1442 "gram1.y" /* yacc.c:1646 */ { type_options = type_options | DIMENSION_BIT; attr_ndim = ndim; attr_dims = (yyvsp[0].ll_node); (yyval.ll_node) = make_llnd(fi, DIMENSION_OP, (yyvsp[0].ll_node), LLNULL, SMNULL); } #line 5424 "gram1.tab.c" /* yacc.c:1646 */ break; case 119: #line 1448 "gram1.y" /* yacc.c:1646 */ { type_options = type_options | EXTERNAL_BIT; (yyval.ll_node) = make_llnd(fi, EXTERNAL_OP, LLNULL, LLNULL, SMNULL); } #line 5432 "gram1.tab.c" /* yacc.c:1646 */ break; case 120: #line 1452 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[-1].ll_node); } #line 5438 "gram1.tab.c" /* yacc.c:1646 */ break; case 121: #line 1454 "gram1.y" /* yacc.c:1646 */ { type_options = type_options | INTRINSIC_BIT; (yyval.ll_node) = make_llnd(fi, INTRINSIC_OP, LLNULL, LLNULL, SMNULL); } #line 5446 "gram1.tab.c" /* yacc.c:1646 */ break; case 122: #line 1458 "gram1.y" /* yacc.c:1646 */ { type_options = type_options | OPTIONAL_BIT; (yyval.ll_node) = make_llnd(fi, OPTIONAL_OP, LLNULL, LLNULL, SMNULL); } #line 5454 "gram1.tab.c" /* yacc.c:1646 */ break; case 123: #line 1462 "gram1.y" /* yacc.c:1646 */ { type_options = type_options | POINTER_BIT; (yyval.ll_node) = make_llnd(fi, POINTER_OP, LLNULL, LLNULL, SMNULL); } #line 5462 "gram1.tab.c" /* yacc.c:1646 */ break; case 124: #line 1466 "gram1.y" /* yacc.c:1646 */ { type_options = type_options | SAVE_BIT; (yyval.ll_node) = make_llnd(fi, SAVE_OP, LLNULL, LLNULL, SMNULL); } #line 5470 "gram1.tab.c" /* yacc.c:1646 */ break; case 125: #line 1470 "gram1.y" /* yacc.c:1646 */ { type_options = type_options | SAVE_BIT; (yyval.ll_node) = make_llnd(fi, STATIC_OP, LLNULL, LLNULL, SMNULL); } #line 5478 "gram1.tab.c" /* yacc.c:1646 */ break; case 126: #line 1474 "gram1.y" /* yacc.c:1646 */ { type_options = type_options | TARGET_BIT; (yyval.ll_node) = make_llnd(fi, TARGET_OP, LLNULL, LLNULL, SMNULL); } #line 5486 "gram1.tab.c" /* yacc.c:1646 */ break; case 127: #line 1480 "gram1.y" /* yacc.c:1646 */ { type_options = type_options | IN_BIT; type_opt = IN_BIT; (yyval.ll_node) = make_llnd(fi, IN_OP, LLNULL, LLNULL, SMNULL); } #line 5494 "gram1.tab.c" /* yacc.c:1646 */ break; case 128: #line 1484 "gram1.y" /* yacc.c:1646 */ { type_options = type_options | OUT_BIT; type_opt = OUT_BIT; (yyval.ll_node) = make_llnd(fi, OUT_OP, LLNULL, LLNULL, SMNULL); } #line 5502 "gram1.tab.c" /* yacc.c:1646 */ break; case 129: #line 1488 "gram1.y" /* yacc.c:1646 */ { type_options = type_options | INOUT_BIT; type_opt = INOUT_BIT; (yyval.ll_node) = make_llnd(fi, INOUT_OP, LLNULL, LLNULL, SMNULL); } #line 5510 "gram1.tab.c" /* yacc.c:1646 */ break; case 130: #line 1494 "gram1.y" /* yacc.c:1646 */ { type_options = type_options | PUBLIC_BIT; type_opt = PUBLIC_BIT; (yyval.ll_node) = make_llnd(fi, PUBLIC_OP, LLNULL, LLNULL, SMNULL); } #line 5519 "gram1.tab.c" /* yacc.c:1646 */ break; case 131: #line 1499 "gram1.y" /* yacc.c:1646 */ { type_options = type_options | PRIVATE_BIT; type_opt = PRIVATE_BIT; (yyval.ll_node) = make_llnd(fi, PRIVATE_OP, LLNULL, LLNULL, SMNULL); } #line 5528 "gram1.tab.c" /* yacc.c:1646 */ break; case 132: #line 1506 "gram1.y" /* yacc.c:1646 */ { PTR_LLND q, r; PTR_SYMB s; s = make_scalar((yyvsp[0].hash_entry), TYNULL, LOCAL); s->attr = s->attr | type_opt; q = make_llnd(fi,VAR_REF, LLNULL, LLNULL, s); r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL); (yyval.bf_node) = get_bfnd(fi, INTENT_STMT, SMNULL, r, (yyvsp[-3].ll_node), LLNULL); } #line 5543 "gram1.tab.c" /* yacc.c:1646 */ break; case 133: #line 1517 "gram1.y" /* yacc.c:1646 */ { PTR_LLND q, r; PTR_SYMB s; s = make_scalar((yyvsp[0].hash_entry), TYNULL, LOCAL); s->attr = s->attr | type_opt; q = make_llnd(fi,VAR_REF, LLNULL, LLNULL, s); r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL); add_to_lowLevelList(r, (yyvsp[-2].bf_node)->entry.Template.ll_ptr1); } #line 5558 "gram1.tab.c" /* yacc.c:1646 */ break; case 134: #line 1530 "gram1.y" /* yacc.c:1646 */ { PTR_LLND q, r; PTR_SYMB s; s = make_scalar((yyvsp[0].hash_entry), TYNULL, LOCAL); s->attr = s->attr | OPTIONAL_BIT; q = make_llnd(fi,VAR_REF, LLNULL, LLNULL, s); r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL); (yyval.bf_node) = get_bfnd(fi, OPTIONAL_STMT, SMNULL, r, LLNULL, LLNULL); } #line 5573 "gram1.tab.c" /* yacc.c:1646 */ break; case 135: #line 1541 "gram1.y" /* yacc.c:1646 */ { PTR_LLND q, r; PTR_SYMB s; s = make_scalar((yyvsp[0].hash_entry), TYNULL, LOCAL); s->attr = s->attr | OPTIONAL_BIT; q = make_llnd(fi,VAR_REF, LLNULL, LLNULL, s); r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL); add_to_lowLevelList(r, (yyvsp[-2].bf_node)->entry.Template.ll_ptr1); } #line 5588 "gram1.tab.c" /* yacc.c:1646 */ break; case 136: #line 1554 "gram1.y" /* yacc.c:1646 */ { PTR_LLND r; PTR_SYMB s; s = (yyvsp[0].ll_node)->entry.Template.symbol; s->attr = s->attr | SAVE_BIT; r = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL); (yyval.bf_node) = get_bfnd(fi, STATIC_STMT, SMNULL, r, LLNULL, LLNULL); } #line 5602 "gram1.tab.c" /* yacc.c:1646 */ break; case 137: #line 1564 "gram1.y" /* yacc.c:1646 */ { PTR_LLND r; PTR_SYMB s; s = (yyvsp[0].ll_node)->entry.Template.symbol; s->attr = s->attr | SAVE_BIT; r = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL); add_to_lowLevelList(r, (yyvsp[-2].bf_node)->entry.Template.ll_ptr1); } #line 5616 "gram1.tab.c" /* yacc.c:1646 */ break; case 138: #line 1577 "gram1.y" /* yacc.c:1646 */ { privateall = 1; (yyval.bf_node) = get_bfnd(fi, PRIVATE_STMT, SMNULL, LLNULL, LLNULL, LLNULL); } #line 5625 "gram1.tab.c" /* yacc.c:1646 */ break; case 139: #line 1582 "gram1.y" /* yacc.c:1646 */ { /*type_options = type_options | PRIVATE_BIT;*/ (yyval.bf_node) = get_bfnd(fi, PRIVATE_STMT, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL); } #line 5634 "gram1.tab.c" /* yacc.c:1646 */ break; case 140: #line 1588 "gram1.y" /* yacc.c:1646 */ {type_opt = PRIVATE_BIT;} #line 5640 "gram1.tab.c" /* yacc.c:1646 */ break; case 141: #line 1592 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi, SEQUENCE_STMT, SMNULL, LLNULL, LLNULL, LLNULL); } #line 5648 "gram1.tab.c" /* yacc.c:1646 */ break; case 142: #line 1597 "gram1.y" /* yacc.c:1646 */ { /*saveall = YES;*/ /*14.03.03*/ (yyval.bf_node) = get_bfnd(fi, PUBLIC_STMT, SMNULL, LLNULL, LLNULL, LLNULL); } #line 5657 "gram1.tab.c" /* yacc.c:1646 */ break; case 143: #line 1602 "gram1.y" /* yacc.c:1646 */ { /*type_options = type_options | PUBLIC_BIT;*/ (yyval.bf_node) = get_bfnd(fi, PUBLIC_STMT, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL); } #line 5666 "gram1.tab.c" /* yacc.c:1646 */ break; case 144: #line 1608 "gram1.y" /* yacc.c:1646 */ {type_opt = PUBLIC_BIT;} #line 5672 "gram1.tab.c" /* yacc.c:1646 */ break; case 145: #line 1612 "gram1.y" /* yacc.c:1646 */ { type_options = 0; /* following block added by dbg */ ndim = 0; attr_ndim = 0; attr_dims = LLNULL; /* end section added by dbg */ (yyval.data_type) = make_type_node((yyvsp[-3].data_type), (yyvsp[-1].ll_node)); } #line 5686 "gram1.tab.c" /* yacc.c:1646 */ break; case 146: #line 1622 "gram1.y" /* yacc.c:1646 */ { PTR_TYPE t; type_options = 0; ndim = 0; attr_ndim = 0; attr_dims = LLNULL; t = lookup_type((yyvsp[-2].hash_entry)); vartype = t; (yyval.data_type) = make_type_node(t, LLNULL); } #line 5701 "gram1.tab.c" /* yacc.c:1646 */ break; case 147: #line 1635 "gram1.y" /* yacc.c:1646 */ {opt_kwd_hedr = YES;} #line 5707 "gram1.tab.c" /* yacc.c:1646 */ break; case 148: #line 1640 "gram1.y" /* yacc.c:1646 */ { PTR_TYPE p; PTR_LLND q; PTR_SYMB s; s = (yyvsp[0].hash_entry)->id_attr; if (s) s->attr = (yyvsp[-1].token); else { p = undeftype ? global_unknown : impltype[*(yyvsp[0].hash_entry)->ident - 'a']; s = install_entry((yyvsp[0].hash_entry), SOFT); s->attr = (yyvsp[-1].token); set_type(s, p, LOCAL); } q = make_llnd(fi,VAR_REF, LLNULL, LLNULL, (yyvsp[0].hash_entry)->id_attr); q = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL); (yyval.bf_node) = get_bfnd(fi,ATTR_DECL, SMNULL, q, LLNULL, LLNULL); } #line 5728 "gram1.tab.c" /* yacc.c:1646 */ break; case 149: #line 1659 "gram1.y" /* yacc.c:1646 */ { PTR_TYPE p; PTR_LLND q, r; PTR_SYMB s; int att; att = (yyvsp[-2].bf_node)->entry.Template.ll_ptr1->entry.Template.ll_ptr1-> entry.Template.symbol->attr; s = (yyvsp[0].hash_entry)->id_attr; if (s) s->attr = att; else { p = undeftype ? global_unknown : impltype[*(yyvsp[0].hash_entry)->ident - 'a']; s = install_entry((yyvsp[0].hash_entry), SOFT); s->attr = att; set_type(s, p, LOCAL); } q = make_llnd(fi,VAR_REF, LLNULL, LLNULL, (yyvsp[0].hash_entry)->id_attr); for (r = (yyvsp[-2].bf_node)->entry.Template.ll_ptr1; r->entry.list.next; r = r->entry.list.next) ; r->entry.list.next = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL); } #line 5756 "gram1.tab.c" /* yacc.c:1646 */ break; case 150: #line 1685 "gram1.y" /* yacc.c:1646 */ { (yyval.token) = ATT_GLOBAL; } #line 5762 "gram1.tab.c" /* yacc.c:1646 */ break; case 151: #line 1687 "gram1.y" /* yacc.c:1646 */ { (yyval.token) = ATT_CLUSTER; } #line 5768 "gram1.tab.c" /* yacc.c:1646 */ break; case 152: #line 1699 "gram1.y" /* yacc.c:1646 */ { /* varleng = ($1<0 || $1==TYLONG ? 0 : typesize[$1]); */ vartype = (yyvsp[0].data_type); } #line 5777 "gram1.tab.c" /* yacc.c:1646 */ break; case 153: #line 1706 "gram1.y" /* yacc.c:1646 */ { (yyval.data_type) = global_int; } #line 5783 "gram1.tab.c" /* yacc.c:1646 */ break; case 154: #line 1707 "gram1.y" /* yacc.c:1646 */ { (yyval.data_type) = global_float; } #line 5789 "gram1.tab.c" /* yacc.c:1646 */ break; case 155: #line 1708 "gram1.y" /* yacc.c:1646 */ { (yyval.data_type) = global_complex; } #line 5795 "gram1.tab.c" /* yacc.c:1646 */ break; case 156: #line 1709 "gram1.y" /* yacc.c:1646 */ { (yyval.data_type) = global_double; } #line 5801 "gram1.tab.c" /* yacc.c:1646 */ break; case 157: #line 1710 "gram1.y" /* yacc.c:1646 */ { (yyval.data_type) = global_dcomplex; } #line 5807 "gram1.tab.c" /* yacc.c:1646 */ break; case 158: #line 1711 "gram1.y" /* yacc.c:1646 */ { (yyval.data_type) = global_bool; } #line 5813 "gram1.tab.c" /* yacc.c:1646 */ break; case 159: #line 1712 "gram1.y" /* yacc.c:1646 */ { (yyval.data_type) = global_string; } #line 5819 "gram1.tab.c" /* yacc.c:1646 */ break; case 160: #line 1717 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = LLNULL; } #line 5825 "gram1.tab.c" /* yacc.c:1646 */ break; case 161: #line 1719 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node); } #line 5831 "gram1.tab.c" /* yacc.c:1646 */ break; case 162: #line 1723 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi, LEN_OP, (yyvsp[-2].ll_node), LLNULL, SMNULL); } #line 5837 "gram1.tab.c" /* yacc.c:1646 */ break; case 163: #line 1725 "gram1.y" /* yacc.c:1646 */ { PTR_LLND l; l = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL); l->entry.string_val = (char *)"*"; (yyval.ll_node) = make_llnd(fi, LEN_OP, l,l, SMNULL); } #line 5848 "gram1.tab.c" /* yacc.c:1646 */ break; case 164: #line 1732 "gram1.y" /* yacc.c:1646 */ {(yyval.ll_node) = make_llnd(fi, LEN_OP, (yyvsp[-1].ll_node), (yyvsp[-1].ll_node), SMNULL);} #line 5854 "gram1.tab.c" /* yacc.c:1646 */ break; case 165: #line 1736 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = LLNULL; } #line 5860 "gram1.tab.c" /* yacc.c:1646 */ break; case 166: #line 1738 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node); } #line 5866 "gram1.tab.c" /* yacc.c:1646 */ break; case 167: #line 1740 "gram1.y" /* yacc.c:1646 */ { /*$$ = make_llnd(fi, PAREN_OP, $2, LLNULL, SMNULL);*/ (yyval.ll_node) = (yyvsp[-2].ll_node); } #line 5872 "gram1.tab.c" /* yacc.c:1646 */ break; case 168: #line 1748 "gram1.y" /* yacc.c:1646 */ { if((yyvsp[-2].ll_node)->variant==LENGTH_OP && (yyvsp[-6].ll_node)->variant==(yyvsp[-2].ll_node)->variant) (yyvsp[-2].ll_node)->variant=KIND_OP; (yyval.ll_node) = make_llnd(fi, CONS, (yyvsp[-6].ll_node), (yyvsp[-2].ll_node), SMNULL); } #line 5881 "gram1.tab.c" /* yacc.c:1646 */ break; case 169: #line 1755 "gram1.y" /* yacc.c:1646 */ { if(vartype->variant == T_STRING) (yyval.ll_node) = make_llnd(fi,LENGTH_OP,(yyvsp[0].ll_node),LLNULL,SMNULL); else (yyval.ll_node) = make_llnd(fi,KIND_OP,(yyvsp[0].ll_node),LLNULL,SMNULL); } #line 5891 "gram1.tab.c" /* yacc.c:1646 */ break; case 170: #line 1761 "gram1.y" /* yacc.c:1646 */ { PTR_LLND l; l = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL); l->entry.string_val = (char *)"*"; (yyval.ll_node) = make_llnd(fi,LENGTH_OP,l,LLNULL,SMNULL); } #line 5901 "gram1.tab.c" /* yacc.c:1646 */ break; case 171: #line 1767 "gram1.y" /* yacc.c:1646 */ { /* $$ = make_llnd(fi, SPEC_PAIR, $2, LLNULL, SMNULL); */ char *q; q = (yyvsp[-1].ll_node)->entry.string_val; if (strcmp(q, "len") == 0) (yyval.ll_node) = make_llnd(fi,LENGTH_OP,(yyvsp[0].ll_node),LLNULL,SMNULL); else (yyval.ll_node) = make_llnd(fi,KIND_OP,(yyvsp[0].ll_node),LLNULL,SMNULL); } #line 5914 "gram1.tab.c" /* yacc.c:1646 */ break; case 172: #line 1776 "gram1.y" /* yacc.c:1646 */ { PTR_LLND l; l = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL); l->entry.string_val = (char *)"*"; (yyval.ll_node) = make_llnd(fi,LENGTH_OP,l,LLNULL,SMNULL); } #line 5924 "gram1.tab.c" /* yacc.c:1646 */ break; case 173: #line 1784 "gram1.y" /* yacc.c:1646 */ {endioctl();} #line 5930 "gram1.tab.c" /* yacc.c:1646 */ break; case 174: #line 1797 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = LLNULL; } #line 5936 "gram1.tab.c" /* yacc.c:1646 */ break; case 175: #line 1799 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node); } #line 5942 "gram1.tab.c" /* yacc.c:1646 */ break; case 176: #line 1802 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi, POINTST_OP, LLNULL, (yyvsp[0].ll_node), SMNULL); } #line 5948 "gram1.tab.c" /* yacc.c:1646 */ break; case 177: #line 1806 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; PTR_LLND q, r; if(! (yyvsp[0].ll_node)) { err("No dimensions in DIMENSION statement", 42); } if(statement_kind == 1) /*DVM-directive*/ err("No shape specification", 65); s = make_array((yyvsp[-1].hash_entry), TYNULL, (yyvsp[0].ll_node), ndim, LOCAL); s->attr = s->attr | DIMENSION_BIT; q = make_llnd(fi,ARRAY_REF, (yyvsp[0].ll_node), LLNULL, s); s->type->entry.ar_decl.ranges = (yyvsp[0].ll_node); r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL); (yyval.bf_node) = get_bfnd(fi,DIM_STAT, SMNULL, r, LLNULL, LLNULL); } #line 5967 "gram1.tab.c" /* yacc.c:1646 */ break; case 178: #line 1821 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; PTR_LLND q, r; if(! (yyvsp[0].ll_node)) { err("No dimensions in DIMENSION statement", 42); } s = make_array((yyvsp[-1].hash_entry), TYNULL, (yyvsp[0].ll_node), ndim, LOCAL); s->attr = s->attr | DIMENSION_BIT; q = make_llnd(fi,ARRAY_REF, (yyvsp[0].ll_node), LLNULL, s); s->type->entry.ar_decl.ranges = (yyvsp[0].ll_node); r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL); add_to_lowLevelList(r, (yyvsp[-3].bf_node)->entry.Template.ll_ptr1); } #line 5984 "gram1.tab.c" /* yacc.c:1646 */ break; case 179: #line 1837 "gram1.y" /* yacc.c:1646 */ {/* PTR_SYMB s;*/ PTR_LLND r; /*if(!$5) { err("No dimensions in ALLOCATABLE statement",305); } s = make_array($4, TYNULL, $5, ndim, LOCAL); s->attr = s->attr | ALLOCATABLE_BIT; q = make_llnd(fi,ARRAY_REF, $5, LLNULL, s); s->type->entry.ar_decl.ranges = $5; r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL); */ (yyvsp[0].ll_node)->entry.Template.symbol->attr = (yyvsp[0].ll_node)->entry.Template.symbol->attr | ALLOCATABLE_BIT; r = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL); (yyval.bf_node) = get_bfnd(fi, ALLOCATABLE_STMT, SMNULL, r, LLNULL, LLNULL); } #line 6005 "gram1.tab.c" /* yacc.c:1646 */ break; case 180: #line 1855 "gram1.y" /* yacc.c:1646 */ { /*PTR_SYMB s;*/ PTR_LLND r; /* if(! $4) { err("No dimensions in ALLOCATABLE statement",305); } s = make_array($3, TYNULL, $4, ndim, LOCAL); s->attr = s->attr | ALLOCATABLE_BIT; q = make_llnd(fi,ARRAY_REF, $4, LLNULL, s); s->type->entry.ar_decl.ranges = $4; r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL); */ (yyvsp[0].ll_node)->entry.Template.symbol->attr = (yyvsp[0].ll_node)->entry.Template.symbol->attr | ALLOCATABLE_BIT; r = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL); add_to_lowLevelList(r, (yyvsp[-2].bf_node)->entry.Template.ll_ptr1); } #line 6027 "gram1.tab.c" /* yacc.c:1646 */ break; case 181: #line 1875 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; PTR_LLND r; /* if(! $5) { err("No dimensions in POINTER statement",306); } s = make_array($4, TYNULL, $5, ndim, LOCAL); s->attr = s->attr | POINTER_BIT; q = make_llnd(fi,ARRAY_REF, $5, LLNULL, s); s->type->entry.ar_decl.ranges = $5; */ /*s = make_pointer( $4->entry.Template.symbol->parent, TYNULL, LOCAL);*/ /*17.02.03*/ /*$4->entry.Template.symbol->attr = $4->entry.Template.symbol->attr | POINTER_BIT;*/ s = (yyvsp[0].ll_node)->entry.Template.symbol; /*17.02.03*/ s->attr = s->attr | POINTER_BIT; r = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL); (yyval.bf_node) = get_bfnd(fi, POINTER_STMT, SMNULL, r, LLNULL, LLNULL); } #line 6051 "gram1.tab.c" /* yacc.c:1646 */ break; case 182: #line 1895 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; PTR_LLND r; /* if(! $4) { err("No dimensions in POINTER statement",306); } s = make_array($3, TYNULL, $4, ndim, LOCAL); s->attr = s->attr | POINTER_BIT; q = make_llnd(fi,ARRAY_REF, $4, LLNULL, s); s->type->entry.ar_decl.ranges = $4; */ /*s = make_pointer( $3->entry.Template.symbol->parent, TYNULL, LOCAL);*/ /*17.02.03*/ /*$3->entry.Template.symbol->attr = $3->entry.Template.symbol->attr | POINTER_BIT;*/ s = (yyvsp[0].ll_node)->entry.Template.symbol; /*17.02.03*/ s->attr = s->attr | POINTER_BIT; r = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL); add_to_lowLevelList(r, (yyvsp[-2].bf_node)->entry.Template.ll_ptr1); } #line 6075 "gram1.tab.c" /* yacc.c:1646 */ break; case 183: #line 1917 "gram1.y" /* yacc.c:1646 */ {/* PTR_SYMB s;*/ PTR_LLND r; /* if(! $5) { err("No dimensions in TARGET statement",307); } s = make_array($4, TYNULL, $5, ndim, LOCAL); s->attr = s->attr | TARGET_BIT; q = make_llnd(fi,ARRAY_REF, $5, LLNULL, s); s->type->entry.ar_decl.ranges = $5; */ (yyvsp[0].ll_node)->entry.Template.symbol->attr = (yyvsp[0].ll_node)->entry.Template.symbol->attr | TARGET_BIT; r = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL); (yyval.bf_node) = get_bfnd(fi, TARGET_STMT, SMNULL, r, LLNULL, LLNULL); } #line 6096 "gram1.tab.c" /* yacc.c:1646 */ break; case 184: #line 1934 "gram1.y" /* yacc.c:1646 */ { /*PTR_SYMB s;*/ PTR_LLND r; /* if(! $4) { err("No dimensions in TARGET statement",307); } s = make_array($3, TYNULL, $4, ndim, LOCAL); s->attr = s->attr | TARGET_BIT; q = make_llnd(fi,ARRAY_REF, $4, LLNULL, s); s->type->entry.ar_decl.ranges = $4; */ (yyvsp[0].ll_node)->entry.Template.symbol->attr = (yyvsp[0].ll_node)->entry.Template.symbol->attr | TARGET_BIT; r = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL); add_to_lowLevelList(r, (yyvsp[-2].bf_node)->entry.Template.ll_ptr1); } #line 6116 "gram1.tab.c" /* yacc.c:1646 */ break; case 185: #line 1952 "gram1.y" /* yacc.c:1646 */ { PTR_LLND p, q; p = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL); q = make_llnd(fi,COMM_LIST, p, LLNULL, SMNULL); (yyval.bf_node) = get_bfnd(fi,COMM_STAT, SMNULL, q, LLNULL, LLNULL); } #line 6127 "gram1.tab.c" /* yacc.c:1646 */ break; case 186: #line 1959 "gram1.y" /* yacc.c:1646 */ { PTR_LLND p, q; p = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL); q = make_llnd(fi,COMM_LIST, p, LLNULL, (yyvsp[-1].symbol)); (yyval.bf_node) = get_bfnd(fi,COMM_STAT, SMNULL, q, LLNULL, LLNULL); } #line 6138 "gram1.tab.c" /* yacc.c:1646 */ break; case 187: #line 1966 "gram1.y" /* yacc.c:1646 */ { PTR_LLND p, q; p = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL); q = make_llnd(fi,COMM_LIST, p, LLNULL, (yyvsp[-2].symbol)); add_to_lowList(q, (yyvsp[-4].bf_node)->entry.Template.ll_ptr1); } #line 6149 "gram1.tab.c" /* yacc.c:1646 */ break; case 188: #line 1973 "gram1.y" /* yacc.c:1646 */ { PTR_LLND p, r; p = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL); /*q = make_llnd(fi,COMM_LIST, p, LLNULL, SMNULL);*/ for (r = (yyvsp[-2].bf_node)->entry.Template.ll_ptr1; r->entry.list.next; r = r->entry.list.next); add_to_lowLevelList(p, r->entry.Template.ll_ptr1); } #line 6163 "gram1.tab.c" /* yacc.c:1646 */ break; case 189: #line 1986 "gram1.y" /* yacc.c:1646 */ { PTR_LLND q, r; q = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL); r = make_llnd(fi,NAMELIST_LIST, q, LLNULL, (yyvsp[-1].symbol)); (yyval.bf_node) = get_bfnd(fi,NAMELIST_STAT, SMNULL, r, LLNULL, LLNULL); } #line 6174 "gram1.tab.c" /* yacc.c:1646 */ break; case 190: #line 1993 "gram1.y" /* yacc.c:1646 */ { PTR_LLND q, r; q = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL); r = make_llnd(fi,NAMELIST_LIST, q, LLNULL, (yyvsp[-2].symbol)); add_to_lowList(r, (yyvsp[-4].bf_node)->entry.Template.ll_ptr1); } #line 6185 "gram1.tab.c" /* yacc.c:1646 */ break; case 191: #line 2000 "gram1.y" /* yacc.c:1646 */ { PTR_LLND q, r; q = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL); for (r = (yyvsp[-2].bf_node)->entry.Template.ll_ptr1; r->entry.list.next; r = r->entry.list.next); add_to_lowLevelList(q, r->entry.Template.ll_ptr1); } #line 6198 "gram1.tab.c" /* yacc.c:1646 */ break; case 192: #line 2011 "gram1.y" /* yacc.c:1646 */ { (yyval.symbol) = make_local_entity((yyvsp[-1].hash_entry), NAMELIST_NAME,global_default,LOCAL); } #line 6204 "gram1.tab.c" /* yacc.c:1646 */ break; case 193: #line 2015 "gram1.y" /* yacc.c:1646 */ { (yyval.symbol) = NULL; /*make_common(look_up_sym("*"));*/ } #line 6210 "gram1.tab.c" /* yacc.c:1646 */ break; case 194: #line 2017 "gram1.y" /* yacc.c:1646 */ { (yyval.symbol) = make_common((yyvsp[-1].hash_entry)); } #line 6216 "gram1.tab.c" /* yacc.c:1646 */ break; case 195: #line 2022 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; if((yyvsp[0].ll_node)) { s = make_array((yyvsp[-1].hash_entry), TYNULL, (yyvsp[0].ll_node), ndim, LOCAL); s->attr = s->attr | DIMENSION_BIT; s->type->entry.ar_decl.ranges = (yyvsp[0].ll_node); (yyval.ll_node) = make_llnd(fi,ARRAY_REF, (yyvsp[0].ll_node), LLNULL, s); } else { s = make_scalar((yyvsp[-1].hash_entry), TYNULL, LOCAL); (yyval.ll_node) = make_llnd(fi,VAR_REF, LLNULL, LLNULL, s); } } #line 6235 "gram1.tab.c" /* yacc.c:1646 */ break; case 196: #line 2040 "gram1.y" /* yacc.c:1646 */ { PTR_LLND p, q; PTR_SYMB s; s = make_external((yyvsp[0].hash_entry), TYNULL); s->attr = s->attr | EXTERNAL_BIT; q = make_llnd(fi, VAR_REF, LLNULL, LLNULL, s); p = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL); (yyval.bf_node) = get_bfnd(fi,EXTERN_STAT, SMNULL, p, LLNULL, LLNULL); } #line 6249 "gram1.tab.c" /* yacc.c:1646 */ break; case 197: #line 2051 "gram1.y" /* yacc.c:1646 */ { PTR_LLND p, q; PTR_SYMB s; s = make_external((yyvsp[0].hash_entry), TYNULL); s->attr = s->attr | EXTERNAL_BIT; p = make_llnd(fi, VAR_REF, LLNULL, LLNULL, s); q = make_llnd(fi,EXPR_LIST, p, LLNULL, SMNULL); add_to_lowLevelList(q, (yyvsp[-2].bf_node)->entry.Template.ll_ptr1); } #line 6263 "gram1.tab.c" /* yacc.c:1646 */ break; case 198: #line 2063 "gram1.y" /* yacc.c:1646 */ { PTR_LLND p, q; PTR_SYMB s; s = make_intrinsic((yyvsp[0].hash_entry), TYNULL); /*make_function($3, TYNULL, NO);*/ s->attr = s->attr | INTRINSIC_BIT; q = make_llnd(fi, VAR_REF, LLNULL, LLNULL, s); p = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL); (yyval.bf_node) = get_bfnd(fi,INTRIN_STAT, SMNULL, p, LLNULL, LLNULL); } #line 6278 "gram1.tab.c" /* yacc.c:1646 */ break; case 199: #line 2075 "gram1.y" /* yacc.c:1646 */ { PTR_LLND p, q; PTR_SYMB s; s = make_intrinsic((yyvsp[0].hash_entry), TYNULL); /* make_function($3, TYNULL, NO);*/ s->attr = s->attr | INTRINSIC_BIT; p = make_llnd(fi, VAR_REF, LLNULL, LLNULL, s); q = make_llnd(fi,EXPR_LIST, p, LLNULL, SMNULL); add_to_lowLevelList(q, (yyvsp[-2].bf_node)->entry.Template.ll_ptr1); } #line 6292 "gram1.tab.c" /* yacc.c:1646 */ break; case 200: #line 2089 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,EQUI_STAT, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL); } #line 6301 "gram1.tab.c" /* yacc.c:1646 */ break; case 201: #line 2095 "gram1.y" /* yacc.c:1646 */ { add_to_lowLevelList((yyvsp[0].ll_node), (yyvsp[-2].bf_node)->entry.Template.ll_ptr1); } #line 6309 "gram1.tab.c" /* yacc.c:1646 */ break; case 202: #line 2102 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,EQUI_LIST, (yyvsp[-1].ll_node), LLNULL, SMNULL); } #line 6317 "gram1.tab.c" /* yacc.c:1646 */ break; case 203: #line 2108 "gram1.y" /* yacc.c:1646 */ { PTR_LLND p; p = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL); (yyval.ll_node) = make_llnd(fi,EXPR_LIST, (yyvsp[-2].ll_node), p, SMNULL); } #line 6326 "gram1.tab.c" /* yacc.c:1646 */ break; case 204: #line 2114 "gram1.y" /* yacc.c:1646 */ { PTR_LLND p; p = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL); add_to_lowLevelList(p, (yyvsp[-2].ll_node)); } #line 6336 "gram1.tab.c" /* yacc.c:1646 */ break; case 205: #line 2122 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; s=make_scalar((yyvsp[0].hash_entry),TYNULL,LOCAL); (yyval.ll_node) = make_llnd(fi,VAR_REF, LLNULL, LLNULL, s); s->attr = s->attr | EQUIVALENCE_BIT; /*$$=$1; $$->entry.Template.symbol->attr = $$->entry.Template.symbol->attr | EQUIVALENCE_BIT; */ } #line 6347 "gram1.tab.c" /* yacc.c:1646 */ break; case 206: #line 2129 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; s=make_array((yyvsp[-3].hash_entry),TYNULL,LLNULL,0,LOCAL); (yyval.ll_node) = make_llnd(fi,ARRAY_REF, (yyvsp[-1].ll_node), LLNULL, s); s->attr = s->attr | EQUIVALENCE_BIT; /*$$->entry.Template.symbol->attr = $$->entry.Template.symbol->attr | EQUIVALENCE_BIT; */ } #line 6358 "gram1.tab.c" /* yacc.c:1646 */ break; case 208: #line 2148 "gram1.y" /* yacc.c:1646 */ { PTR_LLND p; data_stat = NO; p = make_llnd(fi,STMT_STR, LLNULL, LLNULL, SMNULL); p->entry.string_val = copys(stmtbuf); (yyval.bf_node) = get_bfnd(fi,DATA_DECL, SMNULL, p, LLNULL, LLNULL); } #line 6370 "gram1.tab.c" /* yacc.c:1646 */ break; case 211: #line 2162 "gram1.y" /* yacc.c:1646 */ {data_stat = YES;} #line 6376 "gram1.tab.c" /* yacc.c:1646 */ break; case 212: #line 2166 "gram1.y" /* yacc.c:1646 */ { if (parstate == OUTSIDE) { PTR_BFND p; p = get_bfnd(fi,PROG_HEDR, make_program(look_up_sym("_MAIN")), LLNULL, LLNULL, LLNULL); set_blobs(p, global_bfnd, NEW_GROUP1); add_scope_level(p, NO); position = IN_PROC; /*parstate = INDCL;*/ } if(parstate < INDCL) { /* enddcl();*/ parstate = INDCL; } } #line 6399 "gram1.tab.c" /* yacc.c:1646 */ break; case 223: #line 2211 "gram1.y" /* yacc.c:1646 */ {;} #line 6405 "gram1.tab.c" /* yacc.c:1646 */ break; case 224: #line 2215 "gram1.y" /* yacc.c:1646 */ { (yyval.symbol)= make_scalar((yyvsp[0].hash_entry), TYNULL, LOCAL);} #line 6411 "gram1.tab.c" /* yacc.c:1646 */ break; case 225: #line 2219 "gram1.y" /* yacc.c:1646 */ { (yyval.symbol)= make_scalar((yyvsp[0].hash_entry), TYNULL, LOCAL); (yyval.symbol)->attr = (yyval.symbol)->attr | DATA_BIT; } #line 6419 "gram1.tab.c" /* yacc.c:1646 */ break; case 226: #line 2225 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi, DATA_SUBS, (yyvsp[-1].ll_node), LLNULL, SMNULL); } #line 6425 "gram1.tab.c" /* yacc.c:1646 */ break; case 227: #line 2229 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi, DATA_RANGE, (yyvsp[-3].ll_node), (yyvsp[-1].ll_node), SMNULL); } #line 6431 "gram1.tab.c" /* yacc.c:1646 */ break; case 228: #line 2233 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node); } #line 6437 "gram1.tab.c" /* yacc.c:1646 */ break; case 229: #line 2235 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = add_to_lowLevelList((yyvsp[0].ll_node), (yyvsp[-2].ll_node)); } #line 6443 "gram1.tab.c" /* yacc.c:1646 */ break; case 230: #line 2239 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = LLNULL; } #line 6449 "gram1.tab.c" /* yacc.c:1646 */ break; case 231: #line 2241 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node); } #line 6455 "gram1.tab.c" /* yacc.c:1646 */ break; case 232: #line 2245 "gram1.y" /* yacc.c:1646 */ {(yyval.ll_node)= make_llnd(fi, DATA_IMPL_DO, (yyvsp[-5].ll_node), (yyvsp[-1].ll_node), (yyvsp[-3].symbol)); } #line 6461 "gram1.tab.c" /* yacc.c:1646 */ break; case 233: #line 2249 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node); } #line 6467 "gram1.tab.c" /* yacc.c:1646 */ break; case 234: #line 2251 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = add_to_lowLevelList((yyvsp[0].ll_node), (yyvsp[-2].ll_node)); } #line 6473 "gram1.tab.c" /* yacc.c:1646 */ break; case 235: #line 2255 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi, DATA_ELT, (yyvsp[0].ll_node), LLNULL, (yyvsp[-1].symbol)); } #line 6479 "gram1.tab.c" /* yacc.c:1646 */ break; case 236: #line 2257 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi, DATA_ELT, (yyvsp[0].ll_node), LLNULL, (yyvsp[-1].symbol)); } #line 6485 "gram1.tab.c" /* yacc.c:1646 */ break; case 237: #line 2259 "gram1.y" /* yacc.c:1646 */ { (yyvsp[-1].ll_node)->entry.Template.ll_ptr2 = (yyvsp[0].ll_node); (yyval.ll_node) = make_llnd(fi, DATA_ELT, (yyvsp[-1].ll_node), LLNULL, (yyvsp[-2].symbol)); } #line 6494 "gram1.tab.c" /* yacc.c:1646 */ break; case 238: #line 2264 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi, DATA_ELT, (yyvsp[0].ll_node), LLNULL, SMNULL); } #line 6500 "gram1.tab.c" /* yacc.c:1646 */ break; case 252: #line 2288 "gram1.y" /* yacc.c:1646 */ {if((yyvsp[-4].ll_node)->entry.Template.symbol->variant != TYPE_NAME) errstr("Undefined type %s",(yyvsp[-4].ll_node)->entry.Template.symbol->ident,319); } #line 6508 "gram1.tab.c" /* yacc.c:1646 */ break; case 269: #line 2333 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,ICON_EXPR, (yyvsp[0].ll_node), LLNULL, SMNULL); } #line 6514 "gram1.tab.c" /* yacc.c:1646 */ break; case 270: #line 2335 "gram1.y" /* yacc.c:1646 */ { PTR_LLND p; p = intrinsic_op_node("+", UNARY_ADD_OP, (yyvsp[0].ll_node), LLNULL); (yyval.ll_node) = make_llnd(fi,ICON_EXPR, p, LLNULL, SMNULL); } #line 6525 "gram1.tab.c" /* yacc.c:1646 */ break; case 271: #line 2342 "gram1.y" /* yacc.c:1646 */ { PTR_LLND p; p = intrinsic_op_node("-", MINUS_OP, (yyvsp[0].ll_node), LLNULL); (yyval.ll_node) = make_llnd(fi,ICON_EXPR, p, LLNULL, SMNULL); } #line 6536 "gram1.tab.c" /* yacc.c:1646 */ break; case 272: #line 2349 "gram1.y" /* yacc.c:1646 */ { PTR_LLND p; p = intrinsic_op_node("+", ADD_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); (yyval.ll_node) = make_llnd(fi,ICON_EXPR, p, LLNULL, SMNULL); } #line 6547 "gram1.tab.c" /* yacc.c:1646 */ break; case 273: #line 2356 "gram1.y" /* yacc.c:1646 */ { PTR_LLND p; p = intrinsic_op_node("-", SUBT_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); (yyval.ll_node) = make_llnd(fi,ICON_EXPR, p, LLNULL, SMNULL); } #line 6558 "gram1.tab.c" /* yacc.c:1646 */ break; case 274: #line 2365 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node); } #line 6564 "gram1.tab.c" /* yacc.c:1646 */ break; case 275: #line 2367 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = intrinsic_op_node("*", MULT_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); } #line 6570 "gram1.tab.c" /* yacc.c:1646 */ break; case 276: #line 2369 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = intrinsic_op_node("/", DIV_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); } #line 6576 "gram1.tab.c" /* yacc.c:1646 */ break; case 277: #line 2373 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node); } #line 6582 "gram1.tab.c" /* yacc.c:1646 */ break; case 278: #line 2375 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = intrinsic_op_node("**", EXP_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); } #line 6588 "gram1.tab.c" /* yacc.c:1646 */ break; case 279: #line 2379 "gram1.y" /* yacc.c:1646 */ { PTR_LLND p; p = make_llnd(fi,INT_VAL, LLNULL, LLNULL, SMNULL); p->entry.ival = atoi(yytext); p->type = global_int; (yyval.ll_node) = make_llnd(fi,EXPR_LIST, p, LLNULL, SMNULL); } #line 6601 "gram1.tab.c" /* yacc.c:1646 */ break; case 280: #line 2388 "gram1.y" /* yacc.c:1646 */ { PTR_LLND p; p = make_llnd(fi,VAR_REF, LLNULL, LLNULL, (yyvsp[0].symbol)); (yyval.ll_node) = make_llnd(fi,EXPR_LIST, p, LLNULL, SMNULL); } #line 6612 "gram1.tab.c" /* yacc.c:1646 */ break; case 281: #line 2395 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,EXPR_LIST, (yyvsp[-1].ll_node), LLNULL, SMNULL); } #line 6620 "gram1.tab.c" /* yacc.c:1646 */ break; case 282: #line 2402 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL); } #line 6626 "gram1.tab.c" /* yacc.c:1646 */ break; case 283: #line 2404 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); } #line 6632 "gram1.tab.c" /* yacc.c:1646 */ break; case 284: #line 2408 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node); (yyval.ll_node)->entry.Template.symbol->attr = (yyval.ll_node)->entry.Template.symbol->attr | SAVE_BIT; } #line 6640 "gram1.tab.c" /* yacc.c:1646 */ break; case 285: #line 2412 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,COMM_LIST, LLNULL, LLNULL, (yyvsp[0].symbol)); (yyval.ll_node)->entry.Template.symbol->attr = (yyval.ll_node)->entry.Template.symbol->attr | SAVE_BIT; } #line 6648 "gram1.tab.c" /* yacc.c:1646 */ break; case 286: #line 2418 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node), LLNULL, EXPR_LIST); } #line 6654 "gram1.tab.c" /* yacc.c:1646 */ break; case 287: #line 2420 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-4].ll_node), (yyvsp[-1].ll_node), EXPR_LIST); } #line 6660 "gram1.tab.c" /* yacc.c:1646 */ break; case 288: #line 2424 "gram1.y" /* yacc.c:1646 */ { as_op_kwd_ = YES; } #line 6666 "gram1.tab.c" /* yacc.c:1646 */ break; case 289: #line 2428 "gram1.y" /* yacc.c:1646 */ { as_op_kwd_ = NO; } #line 6672 "gram1.tab.c" /* yacc.c:1646 */ break; case 290: #line 2433 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; s = make_scalar((yyvsp[0].hash_entry), TYNULL, LOCAL); s->attr = s->attr | type_opt; (yyval.ll_node) = make_llnd(fi,VAR_REF, LLNULL, LLNULL, s); } #line 6683 "gram1.tab.c" /* yacc.c:1646 */ break; case 291: #line 2440 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; s = make_function((yyvsp[-1].hash_entry), global_default, LOCAL); s->variant = INTERFACE_NAME; s->attr = s->attr | type_opt; (yyval.ll_node) = make_llnd(fi,OPERATOR_OP, LLNULL, LLNULL, s); } #line 6694 "gram1.tab.c" /* yacc.c:1646 */ break; case 292: #line 2447 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; s = make_procedure(look_up_sym("="), LOCAL); s->variant = INTERFACE_NAME; s->attr = s->attr | type_opt; (yyval.ll_node) = make_llnd(fi,ASSIGNMENT_OP, LLNULL, LLNULL, s); } #line 6705 "gram1.tab.c" /* yacc.c:1646 */ break; case 293: #line 2457 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); } #line 6711 "gram1.tab.c" /* yacc.c:1646 */ break; case 294: #line 2459 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); } #line 6717 "gram1.tab.c" /* yacc.c:1646 */ break; case 295: #line 2463 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB p; /* The check if name and expr have compatible types has not been done yet. */ p = make_constant((yyvsp[-2].hash_entry), TYNULL); p->attr = p->attr | PARAMETER_BIT; p->entry.const_value = (yyvsp[0].ll_node); (yyval.ll_node) = make_llnd(fi,CONST_REF, LLNULL, LLNULL, p); } #line 6731 "gram1.tab.c" /* yacc.c:1646 */ break; case 296: #line 2475 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi, MODULE_PROC_STMT, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL); } #line 6737 "gram1.tab.c" /* yacc.c:1646 */ break; case 297: #line 2478 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; PTR_LLND q; s = make_function((yyvsp[0].hash_entry), TYNULL, LOCAL); s->variant = ROUTINE_NAME; q = make_llnd(fi, VAR_REF, LLNULL, LLNULL, s); (yyval.ll_node) = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL); } #line 6750 "gram1.tab.c" /* yacc.c:1646 */ break; case 298: #line 2487 "gram1.y" /* yacc.c:1646 */ { PTR_LLND p, q; PTR_SYMB s; s = make_function((yyvsp[0].hash_entry), TYNULL, LOCAL); s->variant = ROUTINE_NAME; p = make_llnd(fi, VAR_REF, LLNULL, LLNULL, s); q = make_llnd(fi,EXPR_LIST, p, LLNULL, SMNULL); add_to_lowLevelList(q, (yyvsp[-2].ll_node)); } #line 6764 "gram1.tab.c" /* yacc.c:1646 */ break; case 299: #line 2500 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi, USE_STMT, (yyvsp[0].symbol), LLNULL, LLNULL, LLNULL); /*add_scope_level($3->entry.Template.func_hedr, YES);*/ /*17.06.01*/ copy_module_scope((yyvsp[0].symbol),LLNULL); /*17.03.03*/ colon_flag = NO; } #line 6774 "gram1.tab.c" /* yacc.c:1646 */ break; case 300: #line 2506 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi, USE_STMT, (yyvsp[-3].symbol), (yyvsp[0].ll_node), LLNULL, LLNULL); /*add_scope_level(module_scope, YES); *//* 17.06.01*/ copy_module_scope((yyvsp[-3].symbol),(yyvsp[0].ll_node)); /*17.03.03 */ colon_flag = NO; } #line 6784 "gram1.tab.c" /* yacc.c:1646 */ break; case 301: #line 2512 "gram1.y" /* yacc.c:1646 */ { PTR_LLND l; l = make_llnd(fi, ONLY_NODE, LLNULL, LLNULL, SMNULL); (yyval.bf_node) = get_bfnd(fi, USE_STMT, (yyvsp[-3].symbol), l, LLNULL, LLNULL); } #line 6794 "gram1.tab.c" /* yacc.c:1646 */ break; case 302: #line 2518 "gram1.y" /* yacc.c:1646 */ { PTR_LLND l; l = make_llnd(fi, ONLY_NODE, (yyvsp[0].ll_node), LLNULL, SMNULL); (yyval.bf_node) = get_bfnd(fi, USE_STMT, (yyvsp[-4].symbol), l, LLNULL, LLNULL); } #line 6804 "gram1.tab.c" /* yacc.c:1646 */ break; case 303: #line 2526 "gram1.y" /* yacc.c:1646 */ { if ((yyvsp[0].hash_entry)->id_attr == SMNULL) warn1("Unknown module %s", (yyvsp[0].hash_entry)->ident,308); (yyval.symbol) = make_global_entity((yyvsp[0].hash_entry), MODULE_NAME, global_default, NO); module_scope = (yyval.symbol)->entry.Template.func_hedr; } #line 6816 "gram1.tab.c" /* yacc.c:1646 */ break; case 304: #line 2536 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); } #line 6822 "gram1.tab.c" /* yacc.c:1646 */ break; case 305: #line 2538 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); } #line 6828 "gram1.tab.c" /* yacc.c:1646 */ break; case 306: #line 2542 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node); } #line 6834 "gram1.tab.c" /* yacc.c:1646 */ break; case 307: #line 2544 "gram1.y" /* yacc.c:1646 */ { PTR_HASH oldhash,copyhash; PTR_SYMB oldsym, newsym; PTR_LLND m; oldhash = just_look_up_sym_in_scope(module_scope, (yyvsp[0].hash_entry)->ident); if (oldhash == HSNULL) { errstr("Unknown identifier %s.", (yyvsp[0].hash_entry)->ident,309); (yyval.ll_node)= LLNULL; } else { oldsym = oldhash->id_attr; copyhash=just_look_up_sym_in_scope(cur_scope(), (yyvsp[0].hash_entry)->ident); if( copyhash && copyhash->id_attr && copyhash->id_attr->entry.Template.tag==module_scope->id) { newsym = copyhash->id_attr; newsym->entry.Template.tag = 0; } else { newsym = make_local_entity((yyvsp[0].hash_entry), oldsym->variant, oldsym->type,LOCAL); /* copies data in entry.Template structure and attr */ copy_sym_data(oldsym, newsym); /*newsym->entry.Template.base_name = oldsym;*//*19.03.03*/ } /* l = make_llnd(fi, VAR_REF, LLNULL, LLNULL, oldsym);*/ m = make_llnd(fi, VAR_REF, LLNULL, LLNULL, newsym); (yyval.ll_node) = make_llnd(fi, RENAME_NODE, m, LLNULL, oldsym); } } #line 6868 "gram1.tab.c" /* yacc.c:1646 */ break; case 308: #line 2577 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); } #line 6874 "gram1.tab.c" /* yacc.c:1646 */ break; case 309: #line 2579 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); } #line 6880 "gram1.tab.c" /* yacc.c:1646 */ break; case 310: #line 2583 "gram1.y" /* yacc.c:1646 */ { PTR_HASH oldhash,copyhash; PTR_SYMB oldsym, newsym; PTR_LLND l, m; oldhash = just_look_up_sym_in_scope(module_scope, (yyvsp[0].hash_entry)->ident); if (oldhash == HSNULL) { errstr("Unknown identifier %s", (yyvsp[0].hash_entry)->ident,309); (yyval.ll_node)= LLNULL; } else { oldsym = oldhash->id_attr; copyhash = just_look_up_sym_in_scope(cur_scope(), (yyvsp[0].hash_entry)->ident); if(copyhash && copyhash->id_attr && copyhash->id_attr->entry.Template.tag==module_scope->id) { delete_symbol(copyhash->id_attr); copyhash->id_attr = SMNULL; } newsym = make_local_entity((yyvsp[-2].hash_entry), oldsym->variant, oldsym->type, LOCAL); /* copies data in entry.Template structure and attr */ copy_sym_data(oldsym, newsym); /*newsym->entry.Template.base_name = oldsym;*//*19.03.03*/ l = make_llnd(fi, VAR_REF, LLNULL, LLNULL, oldsym); m = make_llnd(fi, VAR_REF, LLNULL, LLNULL, newsym); (yyval.ll_node) = make_llnd(fi, RENAME_NODE, m, l, SMNULL); } } #line 6912 "gram1.tab.c" /* yacc.c:1646 */ break; case 311: #line 2621 "gram1.y" /* yacc.c:1646 */ { ndim = 0; explicit_shape = 1; (yyval.ll_node) = LLNULL; } #line 6918 "gram1.tab.c" /* yacc.c:1646 */ break; case 312: #line 2623 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[-1].ll_node); } #line 6924 "gram1.tab.c" /* yacc.c:1646 */ break; case 313: #line 2626 "gram1.y" /* yacc.c:1646 */ { ndim = 0; explicit_shape = 1;} #line 6930 "gram1.tab.c" /* yacc.c:1646 */ break; case 314: #line 2627 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL); (yyval.ll_node)->type = global_default; } #line 6939 "gram1.tab.c" /* yacc.c:1646 */ break; case 315: #line 2632 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); } #line 6945 "gram1.tab.c" /* yacc.c:1646 */ break; case 316: #line 2636 "gram1.y" /* yacc.c:1646 */ { if(ndim == maxdim) err("Too many dimensions", 43); else if(ndim < maxdim) (yyval.ll_node) = (yyvsp[0].ll_node); ++ndim; } #line 6957 "gram1.tab.c" /* yacc.c:1646 */ break; case 317: #line 2644 "gram1.y" /* yacc.c:1646 */ { if(ndim == maxdim) err("Too many dimensions", 43); else if(ndim < maxdim) (yyval.ll_node) = make_llnd(fi, DDOT, LLNULL, LLNULL, SMNULL); ++ndim; explicit_shape = 0; } #line 6970 "gram1.tab.c" /* yacc.c:1646 */ break; case 318: #line 2653 "gram1.y" /* yacc.c:1646 */ { if(ndim == maxdim) err("Too many dimensions", 43); else if(ndim < maxdim) (yyval.ll_node) = make_llnd(fi,DDOT, (yyvsp[-1].ll_node), LLNULL, SMNULL); ++ndim; explicit_shape = 0; } #line 6983 "gram1.tab.c" /* yacc.c:1646 */ break; case 319: #line 2662 "gram1.y" /* yacc.c:1646 */ { if(ndim == maxdim) err("Too many dimensions", 43); else if(ndim < maxdim) (yyval.ll_node) = make_llnd(fi,DDOT, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), SMNULL); ++ndim; } #line 6995 "gram1.tab.c" /* yacc.c:1646 */ break; case 320: #line 2672 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,STAR_RANGE, LLNULL, LLNULL, SMNULL); (yyval.ll_node)->type = global_default; explicit_shape = 0; } #line 7005 "gram1.tab.c" /* yacc.c:1646 */ break; case 322: #line 2681 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); } #line 7011 "gram1.tab.c" /* yacc.c:1646 */ break; case 323: #line 2683 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); } #line 7017 "gram1.tab.c" /* yacc.c:1646 */ break; case 324: #line 2687 "gram1.y" /* yacc.c:1646 */ {PTR_LABEL p; p = make_label_node(fi,convci(yyleng, yytext)); p->scope = cur_scope(); (yyval.ll_node) = make_llnd_label(fi,LABEL_REF, p); } #line 7027 "gram1.tab.c" /* yacc.c:1646 */ break; case 325: #line 2695 "gram1.y" /* yacc.c:1646 */ { /*PTR_LLND l;*/ /* l = make_llnd(fi, EXPR_LIST, $3, LLNULL, SMNULL);*/ (yyval.bf_node) = get_bfnd(fi,IMPL_DECL, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL); redefine_func_arg_type(); } #line 7038 "gram1.tab.c" /* yacc.c:1646 */ break; case 326: #line 2710 "gram1.y" /* yacc.c:1646 */ { /*undeftype = YES; setimpl(TYNULL, (int)'a', (int)'z'); FB COMMENTED---> NOT QUITE RIGHT BUT AVOID PB WITH COMMON*/ (yyval.bf_node) = get_bfnd(fi,IMPL_DECL, SMNULL, LLNULL, LLNULL, LLNULL); } #line 7047 "gram1.tab.c" /* yacc.c:1646 */ break; case 327: #line 2717 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); } #line 7053 "gram1.tab.c" /* yacc.c:1646 */ break; case 328: #line 2719 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); } #line 7059 "gram1.tab.c" /* yacc.c:1646 */ break; case 329: #line 2723 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi, IMPL_TYPE, (yyvsp[-1].ll_node), LLNULL, SMNULL); (yyval.ll_node)->type = vartype; } #line 7069 "gram1.tab.c" /* yacc.c:1646 */ break; case 330: #line 2738 "gram1.y" /* yacc.c:1646 */ { implkwd = YES; } #line 7075 "gram1.tab.c" /* yacc.c:1646 */ break; case 331: #line 2739 "gram1.y" /* yacc.c:1646 */ { vartype = (yyvsp[0].data_type); } #line 7081 "gram1.tab.c" /* yacc.c:1646 */ break; case 332: #line 2743 "gram1.y" /* yacc.c:1646 */ { (yyval.data_type) = (yyvsp[0].data_type); } #line 7087 "gram1.tab.c" /* yacc.c:1646 */ break; case 333: #line 2745 "gram1.y" /* yacc.c:1646 */ { (yyval.data_type) = (yyvsp[0].data_type);} #line 7093 "gram1.tab.c" /* yacc.c:1646 */ break; case 334: #line 2757 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); } #line 7099 "gram1.tab.c" /* yacc.c:1646 */ break; case 335: #line 2759 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); } #line 7105 "gram1.tab.c" /* yacc.c:1646 */ break; case 336: #line 2763 "gram1.y" /* yacc.c:1646 */ { setimpl(vartype, (int)(yyvsp[0].charv), (int)(yyvsp[0].charv)); (yyval.ll_node) = make_llnd(fi,CHAR_VAL, LLNULL, LLNULL, SMNULL); (yyval.ll_node)->entry.cval = (yyvsp[0].charv); } #line 7115 "gram1.tab.c" /* yacc.c:1646 */ break; case 337: #line 2769 "gram1.y" /* yacc.c:1646 */ { PTR_LLND p,q; setimpl(vartype, (int)(yyvsp[-2].charv), (int)(yyvsp[0].charv)); p = make_llnd(fi,CHAR_VAL, LLNULL, LLNULL, SMNULL); p->entry.cval = (yyvsp[-2].charv); q = make_llnd(fi,CHAR_VAL, LLNULL, LLNULL, SMNULL); q->entry.cval = (yyvsp[0].charv); (yyval.ll_node)= make_llnd(fi,DDOT, p, q, SMNULL); } #line 7129 "gram1.tab.c" /* yacc.c:1646 */ break; case 338: #line 2781 "gram1.y" /* yacc.c:1646 */ { if(yyleng!=1 || yytext[0]<'a' || yytext[0]>'z') { err("IMPLICIT item must be single letter", 37); (yyval.charv) = '\0'; } else (yyval.charv) = yytext[0]; } #line 7142 "gram1.tab.c" /* yacc.c:1646 */ break; case 339: #line 2792 "gram1.y" /* yacc.c:1646 */ { if (parstate == OUTSIDE) { PTR_BFND p; p = get_bfnd(fi,PROG_HEDR, make_program(look_up_sym("_MAIN")), LLNULL, LLNULL, LLNULL); set_blobs(p, global_bfnd, NEW_GROUP1); add_scope_level(p, NO); position = IN_PROC; parstate = INSIDE; } } #line 7161 "gram1.tab.c" /* yacc.c:1646 */ break; case 340: #line 2809 "gram1.y" /* yacc.c:1646 */ { switch(parstate) { case OUTSIDE: { PTR_BFND p; p = get_bfnd(fi,PROG_HEDR, make_program(look_up_sym("_MAIN")), LLNULL, LLNULL, LLNULL); set_blobs(p, global_bfnd, NEW_GROUP1); add_scope_level(p, NO); position = IN_PROC; parstate = INDCL; } break; case INSIDE: parstate = INDCL; case INDCL: break; case INDATA: /* err( "Statement order error: declaration after DATA or function statement", 29);*/ break; default: err("Declaration among executables", 30); } } #line 7192 "gram1.tab.c" /* yacc.c:1646 */ break; case 343: #line 2847 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = LLNULL; endioctl(); } #line 7198 "gram1.tab.c" /* yacc.c:1646 */ break; case 344: #line 2849 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node); endioctl();} #line 7204 "gram1.tab.c" /* yacc.c:1646 */ break; case 345: #line 2853 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node); } #line 7210 "gram1.tab.c" /* yacc.c:1646 */ break; case 346: #line 2855 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node); } #line 7216 "gram1.tab.c" /* yacc.c:1646 */ break; case 347: #line 2857 "gram1.y" /* yacc.c:1646 */ { PTR_LLND l; l = make_llnd(fi, KEYWORD_ARG, (yyvsp[-1].ll_node), (yyvsp[0].ll_node), SMNULL); l->type = (yyvsp[0].ll_node)->type; (yyval.ll_node) = l; } #line 7226 "gram1.tab.c" /* yacc.c:1646 */ break; case 348: #line 2868 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); endioctl(); } #line 7234 "gram1.tab.c" /* yacc.c:1646 */ break; case 349: #line 2872 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-3].ll_node), (yyvsp[0].ll_node), EXPR_LIST); endioctl(); } #line 7242 "gram1.tab.c" /* yacc.c:1646 */ break; case 350: #line 2878 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); } #line 7248 "gram1.tab.c" /* yacc.c:1646 */ break; case 351: #line 2880 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); } #line 7254 "gram1.tab.c" /* yacc.c:1646 */ break; case 352: #line 2884 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node); } #line 7260 "gram1.tab.c" /* yacc.c:1646 */ break; case 353: #line 2886 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[-1].ll_node); } #line 7266 "gram1.tab.c" /* yacc.c:1646 */ break; case 354: #line 2888 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node); } #line 7272 "gram1.tab.c" /* yacc.c:1646 */ break; case 355: #line 2892 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node); } #line 7278 "gram1.tab.c" /* yacc.c:1646 */ break; case 356: #line 2894 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node); } #line 7284 "gram1.tab.c" /* yacc.c:1646 */ break; case 357: #line 2898 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node); } #line 7290 "gram1.tab.c" /* yacc.c:1646 */ break; case 358: #line 2900 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = intrinsic_op_node("+", ADD_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); } #line 7296 "gram1.tab.c" /* yacc.c:1646 */ break; case 359: #line 2902 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = intrinsic_op_node("-", SUBT_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); } #line 7302 "gram1.tab.c" /* yacc.c:1646 */ break; case 360: #line 2904 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = intrinsic_op_node("*", MULT_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); } #line 7308 "gram1.tab.c" /* yacc.c:1646 */ break; case 361: #line 2906 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = intrinsic_op_node("/", DIV_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); } #line 7314 "gram1.tab.c" /* yacc.c:1646 */ break; case 362: #line 2908 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = intrinsic_op_node("**", EXP_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); } #line 7320 "gram1.tab.c" /* yacc.c:1646 */ break; case 363: #line 2910 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = defined_op_node((yyvsp[-1].hash_entry), (yyvsp[0].ll_node), LLNULL); } #line 7326 "gram1.tab.c" /* yacc.c:1646 */ break; case 364: #line 2912 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = intrinsic_op_node("+", UNARY_ADD_OP, (yyvsp[0].ll_node), LLNULL); } #line 7332 "gram1.tab.c" /* yacc.c:1646 */ break; case 365: #line 2914 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = intrinsic_op_node("-", MINUS_OP, (yyvsp[0].ll_node), LLNULL); } #line 7338 "gram1.tab.c" /* yacc.c:1646 */ break; case 366: #line 2916 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = intrinsic_op_node(".eq.", EQ_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); } #line 7344 "gram1.tab.c" /* yacc.c:1646 */ break; case 367: #line 2918 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = intrinsic_op_node(".gt.", GT_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); } #line 7350 "gram1.tab.c" /* yacc.c:1646 */ break; case 368: #line 2920 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = intrinsic_op_node(".lt.", LT_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); } #line 7356 "gram1.tab.c" /* yacc.c:1646 */ break; case 369: #line 2922 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = intrinsic_op_node(".ge.", GTEQL_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); } #line 7362 "gram1.tab.c" /* yacc.c:1646 */ break; case 370: #line 2924 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = intrinsic_op_node(".ge.", LTEQL_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); } #line 7368 "gram1.tab.c" /* yacc.c:1646 */ break; case 371: #line 2926 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = intrinsic_op_node(".ne.", NOTEQL_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); } #line 7374 "gram1.tab.c" /* yacc.c:1646 */ break; case 372: #line 2928 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = intrinsic_op_node(".eqv.", EQV_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); } #line 7380 "gram1.tab.c" /* yacc.c:1646 */ break; case 373: #line 2930 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = intrinsic_op_node(".neqv.", NEQV_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); } #line 7386 "gram1.tab.c" /* yacc.c:1646 */ break; case 374: #line 2932 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = intrinsic_op_node(".xor.", XOR_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); } #line 7392 "gram1.tab.c" /* yacc.c:1646 */ break; case 375: #line 2934 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = intrinsic_op_node(".or.", OR_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); } #line 7398 "gram1.tab.c" /* yacc.c:1646 */ break; case 376: #line 2936 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = intrinsic_op_node(".and.", AND_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); } #line 7404 "gram1.tab.c" /* yacc.c:1646 */ break; case 377: #line 2938 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = intrinsic_op_node(".not.", NOT_OP, (yyvsp[0].ll_node), LLNULL); } #line 7410 "gram1.tab.c" /* yacc.c:1646 */ break; case 378: #line 2940 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = intrinsic_op_node("//", CONCAT_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); } #line 7416 "gram1.tab.c" /* yacc.c:1646 */ break; case 379: #line 2942 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = defined_op_node((yyvsp[-1].hash_entry), (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); } #line 7422 "gram1.tab.c" /* yacc.c:1646 */ break; case 380: #line 2945 "gram1.y" /* yacc.c:1646 */ { (yyval.token) = ADD_OP; } #line 7428 "gram1.tab.c" /* yacc.c:1646 */ break; case 381: #line 2946 "gram1.y" /* yacc.c:1646 */ { (yyval.token) = SUBT_OP; } #line 7434 "gram1.tab.c" /* yacc.c:1646 */ break; case 382: #line 2958 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; PTR_TYPE t; /* PTR_LLND l;*/ if (!(s = (yyvsp[0].hash_entry)->id_attr)) { s = make_scalar((yyvsp[0].hash_entry), TYNULL, LOCAL); s->decl = SOFT; } switch (s->variant) { case CONST_NAME: (yyval.ll_node) = make_llnd(fi,CONST_REF,LLNULL,LLNULL, s); t = s->type; if ((t != TYNULL) && ((t->variant == T_ARRAY) || (t->variant == T_STRING) )) (yyval.ll_node)->variant = ARRAY_REF; (yyval.ll_node)->type = t; break; case DEFAULT: /* if common region with same name has been declared. */ s = make_scalar((yyvsp[0].hash_entry), TYNULL, LOCAL); s->decl = SOFT; case VARIABLE_NAME: (yyval.ll_node) = make_llnd(fi,VAR_REF,LLNULL,LLNULL, s); t = s->type; if (t != TYNULL) { if ((t->variant == T_ARRAY) || (t->variant == T_STRING) || ((t->variant == T_POINTER) && (t->entry.Template.base_type->variant == T_ARRAY) ) ) (yyval.ll_node)->variant = ARRAY_REF; /* if (t->variant == T_DERIVED_TYPE) $$->variant = RECORD_REF; */ } (yyval.ll_node)->type = t; break; case TYPE_NAME: (yyval.ll_node) = make_llnd(fi,TYPE_REF,LLNULL,LLNULL, s); (yyval.ll_node)->type = s->type; break; case INTERFACE_NAME: (yyval.ll_node) = make_llnd(fi, INTERFACE_REF,LLNULL,LLNULL, s); (yyval.ll_node)->type = s->type; break; case FUNCTION_NAME: if(isResultVar(s)) { (yyval.ll_node) = make_llnd(fi,VAR_REF,LLNULL,LLNULL, s); t = s->type; if (t != TYNULL) { if ((t->variant == T_ARRAY) || (t->variant == T_STRING) || ((t->variant == T_POINTER) && (t->entry.Template.base_type->variant == T_ARRAY) ) ) (yyval.ll_node)->variant = ARRAY_REF; } (yyval.ll_node)->type = t; break; } default: (yyval.ll_node) = make_llnd(fi,VAR_REF,LLNULL,LLNULL, s); (yyval.ll_node)->type = s->type; break; } /* if ($$->variant == T_POINTER) { l = $$; $$ = make_llnd(fi, DEREF_OP, l, LLNULL, SMNULL); $$->type = l->type->entry.Template.base_type; } */ /*11.02.03*/ } #line 7510 "gram1.tab.c" /* yacc.c:1646 */ break; case 383: #line 3032 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; (yyval.ll_node) = (yyvsp[0].ll_node); s= (yyval.ll_node)->entry.Template.symbol; if ((((yyvsp[0].ll_node)->variant == VAR_REF) || ((yyvsp[0].ll_node)->variant == ARRAY_REF)) && (s->scope !=cur_scope())) /*global_bfnd*/ { if(((s->variant == FUNCTION_NAME) && (!isResultVar(s))) || (s->variant == PROCEDURE_NAME) || (s->variant == ROUTINE_NAME)) { s = (yyval.ll_node)->entry.Template.symbol = make_scalar(s->parent, TYNULL, LOCAL); (yyval.ll_node)->type = s->type; } } } #line 7526 "gram1.tab.c" /* yacc.c:1646 */ break; case 384: #line 3044 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node); } #line 7532 "gram1.tab.c" /* yacc.c:1646 */ break; case 385: #line 3046 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node); } #line 7538 "gram1.tab.c" /* yacc.c:1646 */ break; case 386: #line 3050 "gram1.y" /* yacc.c:1646 */ { int num_triplets; PTR_SYMB s; /*, sym;*/ /* PTR_LLND l; */ PTR_TYPE tp; /* l = $1; */ s = (yyvsp[-4].ll_node)->entry.Template.symbol; /* Handle variable to function conversion. */ if (((yyvsp[-4].ll_node)->variant == VAR_REF) && (((s->variant == VARIABLE_NAME) && (s->type) && (s->type->variant != T_ARRAY)) || (s->variant == ROUTINE_NAME))) { s = (yyvsp[-4].ll_node)->entry.Template.symbol = make_function(s->parent, TYNULL, LOCAL); (yyvsp[-4].ll_node)->variant = FUNC_CALL; } if (((yyvsp[-4].ll_node)->variant == VAR_REF) && (s->variant == FUNCTION_NAME)) { if(isResultVar(s)) (yyvsp[-4].ll_node)->variant = ARRAY_REF; else (yyvsp[-4].ll_node)->variant = FUNC_CALL; } if (((yyvsp[-4].ll_node)->variant == VAR_REF) && (s->variant == PROGRAM_NAME)) { errstr("The name '%s' is invalid in this context",s->ident,285); (yyvsp[-4].ll_node)->variant = FUNC_CALL; } /* l = $1; */ num_triplets = is_array_section_ref((yyvsp[-1].ll_node)); switch ((yyvsp[-4].ll_node)->variant) { case TYPE_REF: (yyvsp[-4].ll_node)->variant = STRUCTURE_CONSTRUCTOR; (yyvsp[-4].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node); (yyval.ll_node) = (yyvsp[-4].ll_node); (yyval.ll_node)->type = lookup_type(s->parent); /* $$ = make_llnd(fi, STRUCTURE_CONSTRUCTOR, $1, $4, SMNULL); $$->type = $1->type;*//*18.02.03*/ break; case INTERFACE_REF: /* sym = resolve_overloading(s, $4); if (sym != SMNULL) { l = make_llnd(fi, FUNC_CALL, $4, LLNULL, sym); l->type = sym->type; $$ = $1; $$->variant = OVERLOADED_CALL; $$->entry.Template.ll_ptr1 = l; $$->type = sym->type; } else { errstr("can't resolve call %s", s->ident,310); } break; */ /*podd 01.02.03*/ (yyvsp[-4].ll_node)->variant = FUNC_CALL; case FUNC_CALL: (yyvsp[-4].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node); (yyval.ll_node) = (yyvsp[-4].ll_node); if(s->type) (yyval.ll_node)->type = s->type; else (yyval.ll_node)->type = global_default; /*late_bind_if_needed($$);*/ /*podd 02.02.23*/ break; case DEREF_OP: case ARRAY_REF: /* array element */ if (num_triplets == 0) { if ((yyvsp[-1].ll_node) == LLNULL) { s = (yyvsp[-4].ll_node)->entry.Template.symbol = make_function(s->parent, TYNULL, LOCAL); s->entry.func_decl.num_output = 1; (yyvsp[-4].ll_node)->variant = FUNC_CALL; (yyval.ll_node) = (yyvsp[-4].ll_node); } else if ((yyvsp[-4].ll_node)->type->variant == T_STRING) { PTR_LLND temp = (yyvsp[-1].ll_node); int num_input = 0; while (temp) { ++num_input; temp = temp->entry.Template.ll_ptr2; } (yyvsp[-4].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node); s = (yyvsp[-4].ll_node)->entry.Template.symbol = make_function(s->parent, TYNULL, LOCAL); s->entry.func_decl.num_output = 1; s->entry.func_decl.num_input = num_input; (yyvsp[-4].ll_node)->variant = FUNC_CALL; (yyval.ll_node) = (yyvsp[-4].ll_node); } else { (yyvsp[-4].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node); (yyval.ll_node) = (yyvsp[-4].ll_node); (yyval.ll_node)->type = (yyvsp[-4].ll_node)->type->entry.ar_decl.base_type; } } /* substring */ else if ((num_triplets == 1) && ((yyvsp[-4].ll_node)->type->variant == T_STRING)) { /* $1->entry.Template.ll_ptr1 = $4; $$ = $1; $$->type = global_string; */ (yyval.ll_node) = make_llnd(fi, ARRAY_OP, LLNULL, LLNULL, SMNULL); (yyval.ll_node)->entry.Template.ll_ptr1 = (yyvsp[-4].ll_node); (yyval.ll_node)->entry.Template.ll_ptr2 = (yyvsp[-1].ll_node)->entry.Template.ll_ptr1; (yyval.ll_node)->type = global_string; } /* array section */ else { (yyvsp[-4].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node); (yyval.ll_node) = (yyvsp[-4].ll_node); tp = make_type(fi, T_ARRAY); /**18.03.17*/ tp->entry.ar_decl.base_type = (yyvsp[-4].ll_node)->type->entry.ar_decl.base_type; /**18.03.17 $1->type */ tp->entry.ar_decl.num_dimensions = num_triplets; (yyval.ll_node)->type = tp; } break; default: if((yyvsp[-4].ll_node)->entry.Template.symbol) errstr("Can't subscript %s",(yyvsp[-4].ll_node)->entry.Template.symbol->ident, 44); else err("Can't subscript",44); } /*if ($$->variant == T_POINTER) { l = $$; $$ = make_llnd(fi, DEREF_OP, l, LLNULL, SMNULL); $$->type = l->type->entry.Template.base_type; } */ /*11.02.03*/ endioctl(); } #line 7673 "gram1.tab.c" /* yacc.c:1646 */ break; case 387: #line 3181 "gram1.y" /* yacc.c:1646 */ { int num_triplets; PTR_SYMB s; PTR_LLND l; s = (yyvsp[-5].ll_node)->entry.Template.symbol; /* if ($1->type->variant == T_POINTER) { l = $1; $1 = make_llnd(fi, DEREF_OP, l, LLNULL, SMNULL); $1->type = l->type->entry.Template.base_type; } */ if (((yyvsp[-5].ll_node)->type->variant != T_ARRAY) || ((yyvsp[-5].ll_node)->type->entry.ar_decl.base_type->variant != T_STRING)) { errstr("Can't take substring of %s", s->ident, 45); } else { num_triplets = is_array_section_ref((yyvsp[-2].ll_node)); /* array element */ if (num_triplets == 0) { (yyvsp[-5].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-2].ll_node); /* $1->entry.Template.ll_ptr2 = $6;*/ /* $$ = $1;*/ l=(yyvsp[-5].ll_node); /*$$->type = $1->type->entry.ar_decl.base_type;*/ l->type = global_string; /**18.03.17* $1->type->entry.ar_decl.base_type;*/ } /* array section */ else { (yyvsp[-5].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-2].ll_node); /*$1->entry.Template.ll_ptr2 = $6; $$ = $1; $$->type = make_type(fi, T_ARRAY); $$->type->entry.ar_decl.base_type = $1->type; $$->type->entry.ar_decl.num_dimensions = num_triplets; */ l = (yyvsp[-5].ll_node); l->type = make_type(fi, T_ARRAY); l->type->entry.ar_decl.base_type = global_string; /**18.03.17* $1->type*/ l->type->entry.ar_decl.num_dimensions = num_triplets; } (yyval.ll_node) = make_llnd(fi, ARRAY_OP, l, (yyvsp[0].ll_node), SMNULL); (yyval.ll_node)->type = l->type; /* if ($$->variant == T_POINTER) { l = $$; $$ = make_llnd(fi, DEREF_OP, l, LLNULL, SMNULL); $$->type = l->type->entry.Template.base_type; } */ /*11.02.03*/ } endioctl(); } #line 7727 "gram1.tab.c" /* yacc.c:1646 */ break; case 388: #line 3231 "gram1.y" /* yacc.c:1646 */ { int num_triplets; PTR_LLND l,l1,l2; PTR_TYPE tp; /* if ($1->variant == T_POINTER) { l = $1; $1 = make_llnd(fi, DEREF_OP, l, LLNULL, SMNULL); $1->type = l->type->entry.Template.base_type; } */ num_triplets = is_array_section_ref((yyvsp[-1].ll_node)); (yyval.ll_node) = (yyvsp[-3].ll_node); l2 = (yyvsp[-3].ll_node)->entry.Template.ll_ptr2; l1 = (yyvsp[-3].ll_node)->entry.Template.ll_ptr1; if(l2 && l2->type->variant == T_STRING)/*substring*/ if(num_triplets == 1){ l = make_llnd(fi, ARRAY_OP, LLNULL, LLNULL, SMNULL); l->entry.Template.ll_ptr1 = l2; l->entry.Template.ll_ptr2 = (yyvsp[-1].ll_node)->entry.Template.ll_ptr1; l->type = global_string; (yyval.ll_node)->entry.Template.ll_ptr2 = l; } else err("Can't subscript",44); else if (l2 && l2->type->variant == T_ARRAY) { if(num_triplets > 0) { /*array section*/ tp = make_type(fi,T_ARRAY); tp->entry.ar_decl.base_type = (yyvsp[-3].ll_node)->type->entry.ar_decl.base_type; tp->entry.ar_decl.num_dimensions = num_triplets; (yyval.ll_node)->type = tp; l2->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node); l2->type = (yyval.ll_node)->type; } else { /*array element*/ l2->type = l2->type->entry.ar_decl.base_type; l2->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node); if(l1->type->variant != T_ARRAY) (yyval.ll_node)->type = l2->type; } } else {err("Can't subscript",44); /*fprintf(stderr,"%d %d",$1->variant,l2);*/} /*errstr("Can't subscript %s",l2->entry.Template.symbol->ident,441);*/ } #line 7774 "gram1.tab.c" /* yacc.c:1646 */ break; case 389: #line 3275 "gram1.y" /* yacc.c:1646 */ { int num_triplets; PTR_LLND l,q; /* if ($1->variant == T_POINTER) { l = $1; $1 = make_llnd(fi, DEREF_OP, l, LLNULL, SMNULL); $1->type = l->type->entry.Template.base_type; } */ (yyval.ll_node) = (yyvsp[-4].ll_node); if (((yyvsp[-4].ll_node)->type->variant != T_ARRAY) && ((yyvsp[-4].ll_node)->type->entry.ar_decl.base_type->variant != T_STRING)) { err("Can't take substring",45); } else { num_triplets = is_array_section_ref((yyvsp[-2].ll_node)); l = (yyvsp[-4].ll_node)->entry.Template.ll_ptr2; if(l) { /* array element */ if (num_triplets == 0) { l->entry.Template.ll_ptr1 = (yyvsp[-2].ll_node); l->type = global_string; } /* array section */ else { l->entry.Template.ll_ptr1 = (yyvsp[-2].ll_node); l->type = make_type(fi, T_ARRAY); l->type->entry.ar_decl.base_type = global_string; l->type->entry.ar_decl.num_dimensions = num_triplets; } q = make_llnd(fi, ARRAY_OP, l, (yyvsp[0].ll_node), SMNULL); q->type = l->type; (yyval.ll_node)->entry.Template.ll_ptr2 = q; if((yyvsp[-4].ll_node)->entry.Template.ll_ptr1->type->variant != T_ARRAY) (yyval.ll_node)->type = q->type; } } } #line 7817 "gram1.tab.c" /* yacc.c:1646 */ break; case 390: #line 3317 "gram1.y" /* yacc.c:1646 */ { PTR_TYPE t; PTR_SYMB field; /* PTR_BFND at_scope;*/ PTR_LLND l; /* if ($1->variant == T_POINTER) { l = $1; $1 = make_llnd(fi, DEREF_OP, l, LLNULL, SMNULL); $1->type = l->type->entry.Template.base_type; } */ t = (yyvsp[-2].ll_node)->type; if (( ( ((yyvsp[-2].ll_node)->variant == VAR_REF) || ((yyvsp[-2].ll_node)->variant == CONST_REF) || ((yyvsp[-2].ll_node)->variant == ARRAY_REF) || ((yyvsp[-2].ll_node)->variant == RECORD_REF)) && (t->variant == T_DERIVED_TYPE)) ||((((yyvsp[-2].ll_node)->variant == ARRAY_REF) || ((yyvsp[-2].ll_node)->variant == RECORD_REF)) && (t->variant == T_ARRAY) && (t = t->entry.ar_decl.base_type) && (t->variant == T_DERIVED_TYPE))) { t->name = lookup_type_symbol(t->name); if ((field = component(t->name, yytext))) { l = make_llnd(fi, VAR_REF, LLNULL, LLNULL, field); l->type = field->type; if(field->type->variant == T_ARRAY || field->type->variant == T_STRING) l->variant = ARRAY_REF; (yyval.ll_node) = make_llnd(fi, RECORD_REF, (yyvsp[-2].ll_node), l, SMNULL); if((yyvsp[-2].ll_node)->type->variant != T_ARRAY) (yyval.ll_node)->type = field->type; else { (yyval.ll_node)->type = make_type(fi,T_ARRAY); if(field->type->variant != T_ARRAY) (yyval.ll_node)->type->entry.ar_decl.base_type = field->type; else (yyval.ll_node)->type->entry.ar_decl.base_type = field->type->entry.ar_decl.base_type; (yyval.ll_node)->type->entry.ar_decl.num_dimensions = t->entry.ar_decl.num_dimensions; } } else errstr("Illegal component %s", yytext,311); } else errstr("Can't take component %s", yytext,311); } #line 7867 "gram1.tab.c" /* yacc.c:1646 */ break; case 391: #line 3375 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node);} #line 7873 "gram1.tab.c" /* yacc.c:1646 */ break; case 392: #line 3377 "gram1.y" /* yacc.c:1646 */ {(yyval.ll_node) = (yyvsp[0].ll_node);} #line 7879 "gram1.tab.c" /* yacc.c:1646 */ break; case 393: #line 3379 "gram1.y" /* yacc.c:1646 */ { int num_triplets; PTR_TYPE tp; /* PTR_LLND l;*/ if ((yyvsp[-4].ll_node)->type->variant == T_ARRAY) { num_triplets = is_array_section_ref((yyvsp[-1].ll_node)); /* array element */ if (num_triplets == 0) { (yyvsp[-4].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node); (yyval.ll_node) = (yyvsp[-4].ll_node); (yyval.ll_node)->type = (yyvsp[-4].ll_node)->type->entry.ar_decl.base_type; } /* substring */ /* else if ((num_triplets == 1) && ($1->type->variant == T_STRING)) { $1->entry.Template.ll_ptr1 = $4; $$ = $1; $$->type = global_string; } */ /*podd*/ /* array section */ else { (yyvsp[-4].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node); (yyval.ll_node) = (yyvsp[-4].ll_node); tp = make_type(fi, T_ARRAY); tp->entry.ar_decl.base_type = (yyvsp[-4].ll_node)->type->entry.ar_decl.base_type; /**18.03.17* $1->type */ tp->entry.ar_decl.num_dimensions = num_triplets; (yyval.ll_node)->type = tp; } } else err("can't subscript",44); /* if ($$->variant == T_POINTER) { l = $$; $$ = make_llnd(fi, DEREF_OP, l, LLNULL, SMNULL); $$->type = l->type->entry.Template.base_type; } */ /*11.02.03*/ endioctl(); } #line 7922 "gram1.tab.c" /* yacc.c:1646 */ break; case 394: #line 3419 "gram1.y" /* yacc.c:1646 */ { int num_triplets; PTR_LLND l,l1,l2; /* if ($1->variant == T_POINTER) { l = $1; $1 = make_llnd(fi, DEREF_OP, l, LLNULL, SMNULL); $1->type = l->type->entry.Template.base_type; } */ num_triplets = is_array_section_ref((yyvsp[-1].ll_node)); (yyval.ll_node) = (yyvsp[-3].ll_node); l2 = (yyvsp[-3].ll_node)->entry.Template.ll_ptr2; l1 = (yyvsp[-3].ll_node)->entry.Template.ll_ptr1; if(l2 && l2->type->variant == T_STRING)/*substring*/ if(num_triplets == 1){ l = make_llnd(fi, ARRAY_OP, LLNULL, LLNULL, SMNULL); l->entry.Template.ll_ptr1 = l2; l->entry.Template.ll_ptr2 = (yyvsp[-1].ll_node)->entry.Template.ll_ptr1; l->type = global_string; (yyval.ll_node)->entry.Template.ll_ptr2 = l; } else err("Can't subscript",44); else if (l2 && l2->type->variant == T_ARRAY) { if(num_triplets > 0) { /*array section*/ (yyval.ll_node)->type = make_type(fi,T_ARRAY); (yyval.ll_node)->type->entry.ar_decl.base_type = l2->type->entry.ar_decl.base_type; (yyval.ll_node)->type->entry.ar_decl.num_dimensions = num_triplets; l2->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node); l2->type = (yyval.ll_node)->type; } else { /*array element*/ l2->type = l2->type->entry.ar_decl.base_type; l2->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node); if(l1->type->variant != T_ARRAY) (yyval.ll_node)->type = l2->type; } } else err("Can't subscript",44); } #line 7966 "gram1.tab.c" /* yacc.c:1646 */ break; case 395: #line 3461 "gram1.y" /* yacc.c:1646 */ { if ((yyvsp[-1].ll_node)->type->variant == T_STRING) { (yyvsp[-1].ll_node)->entry.Template.ll_ptr1 = (yyvsp[0].ll_node); (yyval.ll_node) = (yyvsp[-1].ll_node); (yyval.ll_node)->type = global_string; } else errstr("can't subscript of %s", (yyvsp[-1].ll_node)->entry.Template.symbol->ident,44); } #line 7978 "gram1.tab.c" /* yacc.c:1646 */ break; case 396: #line 3471 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = LLNULL; } #line 7984 "gram1.tab.c" /* yacc.c:1646 */ break; case 397: #line 3473 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node); } #line 7990 "gram1.tab.c" /* yacc.c:1646 */ break; case 398: #line 3477 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi, DDOT, (yyvsp[-3].ll_node), (yyvsp[-1].ll_node), SMNULL); } #line 7996 "gram1.tab.c" /* yacc.c:1646 */ break; case 399: #line 3481 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = LLNULL; } #line 8002 "gram1.tab.c" /* yacc.c:1646 */ break; case 400: #line 3483 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node); } #line 8008 "gram1.tab.c" /* yacc.c:1646 */ break; case 401: #line 3487 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node);} #line 8014 "gram1.tab.c" /* yacc.c:1646 */ break; case 402: #line 3489 "gram1.y" /* yacc.c:1646 */ { PTR_TYPE t; t = make_type_node((yyvsp[-2].ll_node)->type, (yyvsp[0].ll_node)); (yyval.ll_node) = (yyvsp[-2].ll_node); (yyval.ll_node)->type = t; } #line 8024 "gram1.tab.c" /* yacc.c:1646 */ break; case 403: #line 3495 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node); } #line 8030 "gram1.tab.c" /* yacc.c:1646 */ break; case 404: #line 3497 "gram1.y" /* yacc.c:1646 */ { PTR_TYPE t; t = make_type_node((yyvsp[-2].ll_node)->type, (yyvsp[0].ll_node)); (yyval.ll_node) = (yyvsp[-2].ll_node); (yyval.ll_node)->type = t; } #line 8040 "gram1.tab.c" /* yacc.c:1646 */ break; case 405: #line 3503 "gram1.y" /* yacc.c:1646 */ { if ((yyvsp[0].ll_node) != LLNULL) { (yyval.ll_node) = make_llnd(fi, ARRAY_OP, (yyvsp[-1].ll_node), (yyvsp[0].ll_node), SMNULL); (yyval.ll_node)->type = global_string; } else (yyval.ll_node) = (yyvsp[-1].ll_node); } #line 8054 "gram1.tab.c" /* yacc.c:1646 */ break; case 406: #line 3516 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,BOOL_VAL, LLNULL, LLNULL, SMNULL); (yyval.ll_node)->entry.bval = 1; (yyval.ll_node)->type = global_bool; } #line 8064 "gram1.tab.c" /* yacc.c:1646 */ break; case 407: #line 3522 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,BOOL_VAL, LLNULL, LLNULL, SMNULL); (yyval.ll_node)->entry.bval = 0; (yyval.ll_node)->type = global_bool; } #line 8074 "gram1.tab.c" /* yacc.c:1646 */ break; case 408: #line 3529 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,FLOAT_VAL, LLNULL, LLNULL, SMNULL); (yyval.ll_node)->entry.string_val = copys(yytext); (yyval.ll_node)->type = global_float; } #line 8084 "gram1.tab.c" /* yacc.c:1646 */ break; case 409: #line 3535 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,DOUBLE_VAL, LLNULL, LLNULL, SMNULL); (yyval.ll_node)->entry.string_val = copys(yytext); (yyval.ll_node)->type = global_double; } #line 8094 "gram1.tab.c" /* yacc.c:1646 */ break; case 410: #line 3543 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,INT_VAL, LLNULL, LLNULL, SMNULL); (yyval.ll_node)->entry.ival = atoi(yytext); (yyval.ll_node)->type = global_int; } #line 8104 "gram1.tab.c" /* yacc.c:1646 */ break; case 411: #line 3551 "gram1.y" /* yacc.c:1646 */ { PTR_TYPE t; PTR_LLND p,q; (yyval.ll_node) = make_llnd(fi,STRING_VAL, LLNULL, LLNULL, SMNULL); (yyval.ll_node)->entry.string_val = copys(yytext); if(yyquote=='\"') t = global_string_2; else t = global_string; p = make_llnd(fi,INT_VAL, LLNULL, LLNULL, SMNULL); p->entry.ival = yyleng; p->type = global_int; q = make_llnd(fi, LEN_OP, p, LLNULL, SMNULL); (yyval.ll_node)->type = make_type_node(t, q); } #line 8124 "gram1.tab.c" /* yacc.c:1646 */ break; case 412: #line 3567 "gram1.y" /* yacc.c:1646 */ { PTR_TYPE t; (yyval.ll_node) = make_llnd(fi,STRING_VAL, LLNULL, LLNULL, SMNULL); (yyval.ll_node)->entry.string_val = copys(yytext); if(yyquote=='\"') t = global_string_2; else t = global_string; (yyval.ll_node)->type = make_type_node(t, (yyvsp[-2].ll_node)); } #line 8138 "gram1.tab.c" /* yacc.c:1646 */ break; case 413: #line 3577 "gram1.y" /* yacc.c:1646 */ { PTR_TYPE t; (yyval.ll_node) = make_llnd(fi,STRING_VAL, LLNULL, LLNULL, SMNULL); (yyval.ll_node)->entry.string_val = copys(yytext); if(yyquote=='\"') t = global_string_2; else t = global_string; (yyval.ll_node)->type = make_type_node(t, (yyvsp[-2].ll_node)); } #line 8152 "gram1.tab.c" /* yacc.c:1646 */ break; case 414: #line 3590 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,COMPLEX_VAL, (yyvsp[-3].ll_node), (yyvsp[-1].ll_node), SMNULL); (yyval.ll_node)->type = global_complex; } #line 8161 "gram1.tab.c" /* yacc.c:1646 */ break; case 415: #line 3597 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node);} #line 8167 "gram1.tab.c" /* yacc.c:1646 */ break; case 416: #line 3599 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node); } #line 8173 "gram1.tab.c" /* yacc.c:1646 */ break; case 417: #line 3622 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,DDOT,(yyvsp[-2].ll_node),(yyvsp[0].ll_node),SMNULL); } #line 8179 "gram1.tab.c" /* yacc.c:1646 */ break; case 418: #line 3624 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,DDOT,(yyvsp[-1].ll_node),LLNULL,SMNULL); } #line 8185 "gram1.tab.c" /* yacc.c:1646 */ break; case 419: #line 3626 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,DDOT,make_llnd(fi,DDOT,(yyvsp[-4].ll_node),(yyvsp[-2].ll_node),SMNULL),(yyvsp[0].ll_node),SMNULL); } #line 8191 "gram1.tab.c" /* yacc.c:1646 */ break; case 420: #line 3628 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,DDOT,make_llnd(fi,DDOT,(yyvsp[-3].ll_node),LLNULL,SMNULL),(yyvsp[0].ll_node),SMNULL); } #line 8197 "gram1.tab.c" /* yacc.c:1646 */ break; case 421: #line 3630 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,DDOT, make_llnd(fi,DDOT,LLNULL,(yyvsp[-2].ll_node),SMNULL),(yyvsp[0].ll_node),SMNULL); } #line 8203 "gram1.tab.c" /* yacc.c:1646 */ break; case 422: #line 3632 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,DDOT,make_llnd(fi,DDOT,LLNULL,LLNULL,SMNULL),(yyvsp[0].ll_node),SMNULL); } #line 8209 "gram1.tab.c" /* yacc.c:1646 */ break; case 423: #line 3634 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,DDOT,LLNULL,(yyvsp[0].ll_node),SMNULL); } #line 8215 "gram1.tab.c" /* yacc.c:1646 */ break; case 424: #line 3636 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,DDOT,LLNULL,LLNULL,SMNULL); } #line 8221 "gram1.tab.c" /* yacc.c:1646 */ break; case 425: #line 3639 "gram1.y" /* yacc.c:1646 */ {in_vec=YES;} #line 8227 "gram1.tab.c" /* yacc.c:1646 */ break; case 426: #line 3639 "gram1.y" /* yacc.c:1646 */ {in_vec=NO;} #line 8233 "gram1.tab.c" /* yacc.c:1646 */ break; case 427: #line 3640 "gram1.y" /* yacc.c:1646 */ { PTR_TYPE array_type; (yyval.ll_node) = make_llnd (fi,CONSTRUCTOR_REF,(yyvsp[-2].ll_node),LLNULL,SMNULL); /*$$->type = $2->type;*/ /*28.02.03*/ array_type = make_type(fi, T_ARRAY); array_type->entry.ar_decl.num_dimensions = 1; if((yyvsp[-2].ll_node)->type->variant == T_ARRAY) array_type->entry.ar_decl.base_type = (yyvsp[-2].ll_node)->type->entry.ar_decl.base_type; else array_type->entry.ar_decl.base_type = (yyvsp[-2].ll_node)->type; (yyval.ll_node)->type = array_type; } #line 8249 "gram1.tab.c" /* yacc.c:1646 */ break; case 428: #line 3654 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node); } #line 8255 "gram1.tab.c" /* yacc.c:1646 */ break; case 429: #line 3656 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node); } #line 8261 "gram1.tab.c" /* yacc.c:1646 */ break; case 430: #line 3679 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); } #line 8267 "gram1.tab.c" /* yacc.c:1646 */ break; case 431: #line 3681 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-3].ll_node), (yyvsp[0].ll_node), EXPR_LIST); endioctl(); } #line 8273 "gram1.tab.c" /* yacc.c:1646 */ break; case 432: #line 3683 "gram1.y" /* yacc.c:1646 */ { stat_alloc = make_llnd(fi, SPEC_PAIR, (yyvsp[-1].ll_node), (yyvsp[0].ll_node), SMNULL); endioctl(); } #line 8281 "gram1.tab.c" /* yacc.c:1646 */ break; case 433: #line 3699 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); } #line 8287 "gram1.tab.c" /* yacc.c:1646 */ break; case 434: #line 3701 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-3].ll_node), (yyvsp[0].ll_node), EXPR_LIST); endioctl(); } #line 8293 "gram1.tab.c" /* yacc.c:1646 */ break; case 435: #line 3703 "gram1.y" /* yacc.c:1646 */ { stat_alloc = make_llnd(fi, SPEC_PAIR, (yyvsp[-1].ll_node), (yyvsp[0].ll_node), SMNULL); endioctl(); } #line 8301 "gram1.tab.c" /* yacc.c:1646 */ break; case 436: #line 3716 "gram1.y" /* yacc.c:1646 */ {stat_alloc = LLNULL;} #line 8307 "gram1.tab.c" /* yacc.c:1646 */ break; case 437: #line 3720 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); } #line 8313 "gram1.tab.c" /* yacc.c:1646 */ break; case 438: #line 3722 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); } #line 8319 "gram1.tab.c" /* yacc.c:1646 */ break; case 439: #line 3730 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = (yyvsp[0].bf_node); } #line 8325 "gram1.tab.c" /* yacc.c:1646 */ break; case 440: #line 3732 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = (yyvsp[0].bf_node); } #line 8331 "gram1.tab.c" /* yacc.c:1646 */ break; case 441: #line 3734 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = (yyvsp[0].bf_node); } #line 8337 "gram1.tab.c" /* yacc.c:1646 */ break; case 442: #line 3736 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = (yyvsp[0].bf_node); (yyval.bf_node)->entry.Template.ll_ptr3 = (yyvsp[-1].ll_node); } #line 8346 "gram1.tab.c" /* yacc.c:1646 */ break; case 443: #line 3790 "gram1.y" /* yacc.c:1646 */ { PTR_BFND biff; (yyval.bf_node) = get_bfnd(fi,CONTROL_END, SMNULL, LLNULL, LLNULL, LLNULL); bind(); biff = cur_scope(); if ((biff->variant == FUNC_HEDR) || (biff->variant == PROC_HEDR) || (biff->variant == PROS_HEDR) || (biff->variant == PROG_HEDR) || (biff->variant == BLOCK_DATA)) { if(biff->control_parent == global_bfnd) position = IN_OUTSIDE; else if(!is_interface_stat(biff->control_parent)) position++; } else if (biff->variant == MODULE_STMT) position = IN_OUTSIDE; else err("Unexpected END statement read", 52); /* FB ADDED set the control parent so the empty function unparse right*/ if ((yyval.bf_node)) (yyval.bf_node)->control_parent = biff; delete_beyond_scope_level(pred_bfnd); } #line 8370 "gram1.tab.c" /* yacc.c:1646 */ break; case 444: #line 3812 "gram1.y" /* yacc.c:1646 */ { make_extend((yyvsp[0].symbol)); (yyval.bf_node) = BFNULL; /* delete_beyond_scope_level(pred_bfnd); */ } #line 8380 "gram1.tab.c" /* yacc.c:1646 */ break; case 445: #line 3825 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,CONTROL_END, SMNULL, LLNULL, LLNULL, LLNULL); bind(); delete_beyond_scope_level(pred_bfnd); position = IN_OUTSIDE; } #line 8390 "gram1.tab.c" /* yacc.c:1646 */ break; case 446: #line 3834 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = (yyvsp[0].bf_node); } #line 8396 "gram1.tab.c" /* yacc.c:1646 */ break; case 447: #line 3837 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = (yyvsp[0].bf_node); (yyval.bf_node)->entry.Template.ll_ptr3 = (yyvsp[-1].ll_node); } #line 8405 "gram1.tab.c" /* yacc.c:1646 */ break; case 448: #line 3887 "gram1.y" /* yacc.c:1646 */ { thiswasbranch = NO; (yyvsp[-1].bf_node)->variant = LOGIF_NODE; (yyval.bf_node) = make_logif((yyvsp[-1].bf_node), (yyvsp[0].bf_node)); set_blobs((yyvsp[-1].bf_node), pred_bfnd, SAME_GROUP); } #line 8415 "gram1.tab.c" /* yacc.c:1646 */ break; case 449: #line 3893 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = (yyvsp[-1].bf_node); set_blobs((yyval.bf_node), pred_bfnd, NEW_GROUP1); } #line 8424 "gram1.tab.c" /* yacc.c:1646 */ break; case 450: #line 3898 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = (yyvsp[-1].bf_node); (yyval.bf_node)->entry.Template.ll_ptr3 = (yyvsp[-2].ll_node); set_blobs((yyval.bf_node), pred_bfnd, NEW_GROUP1); } #line 8434 "gram1.tab.c" /* yacc.c:1646 */ break; case 451: #line 3916 "gram1.y" /* yacc.c:1646 */ { make_elseif((yyvsp[-3].ll_node),(yyvsp[0].symbol)); lastwasbranch = NO; (yyval.bf_node) = BFNULL;} #line 8440 "gram1.tab.c" /* yacc.c:1646 */ break; case 452: #line 3918 "gram1.y" /* yacc.c:1646 */ { make_else((yyvsp[0].symbol)); lastwasbranch = NO; (yyval.bf_node) = BFNULL; } #line 8446 "gram1.tab.c" /* yacc.c:1646 */ break; case 453: #line 3920 "gram1.y" /* yacc.c:1646 */ { make_endif((yyvsp[0].symbol)); (yyval.bf_node) = BFNULL; } #line 8452 "gram1.tab.c" /* yacc.c:1646 */ break; case 454: #line 3922 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = (yyvsp[0].bf_node); } #line 8458 "gram1.tab.c" /* yacc.c:1646 */ break; case 455: #line 3924 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi, CONTAINS_STMT, SMNULL, LLNULL, LLNULL, LLNULL); } #line 8464 "gram1.tab.c" /* yacc.c:1646 */ break; case 456: #line 3927 "gram1.y" /* yacc.c:1646 */ { thiswasbranch = NO; (yyvsp[-1].bf_node)->variant = FORALL_STAT; (yyval.bf_node) = make_logif((yyvsp[-1].bf_node), (yyvsp[0].bf_node)); set_blobs((yyvsp[-1].bf_node), pred_bfnd, SAME_GROUP); } #line 8474 "gram1.tab.c" /* yacc.c:1646 */ break; case 457: #line 3933 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = (yyvsp[0].bf_node); } #line 8480 "gram1.tab.c" /* yacc.c:1646 */ break; case 458: #line 3935 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = (yyvsp[0].bf_node); (yyval.bf_node)->entry.Template.ll_ptr3 = (yyvsp[-1].ll_node);} #line 8486 "gram1.tab.c" /* yacc.c:1646 */ break; case 459: #line 3937 "gram1.y" /* yacc.c:1646 */ { make_endforall((yyvsp[0].symbol)); (yyval.bf_node) = BFNULL; } #line 8492 "gram1.tab.c" /* yacc.c:1646 */ break; case 460: #line 3940 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = (yyvsp[0].bf_node); } #line 8498 "gram1.tab.c" /* yacc.c:1646 */ break; case 461: #line 3942 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = (yyvsp[0].bf_node); } #line 8504 "gram1.tab.c" /* yacc.c:1646 */ break; case 462: #line 3944 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = (yyvsp[0].bf_node); } #line 8510 "gram1.tab.c" /* yacc.c:1646 */ break; case 463: #line 3971 "gram1.y" /* yacc.c:1646 */ { /* if($5 && $5->labdefined) execerr("no backward DO loops", (char *)NULL); */ (yyval.bf_node) = make_do(WHILE_NODE, LBNULL, SMNULL, (yyvsp[-1].ll_node), LLNULL, LLNULL); /*$$->entry.Template.ll_ptr3 = $1;*/ } #line 8521 "gram1.tab.c" /* yacc.c:1646 */ break; case 464: #line 3980 "gram1.y" /* yacc.c:1646 */ { if( (yyvsp[-3].label) && (yyvsp[-3].label)->labdefined) err("No backward DO loops", 46); (yyval.bf_node) = make_do(WHILE_NODE, (yyvsp[-3].label), SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL); } #line 8531 "gram1.tab.c" /* yacc.c:1646 */ break; case 465: #line 3988 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = LLNULL; } #line 8537 "gram1.tab.c" /* yacc.c:1646 */ break; case 466: #line 3990 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[-1].ll_node);} #line 8543 "gram1.tab.c" /* yacc.c:1646 */ break; case 467: #line 3992 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[-1].ll_node);} #line 8549 "gram1.tab.c" /* yacc.c:1646 */ break; case 468: #line 3997 "gram1.y" /* yacc.c:1646 */ { if( (yyvsp[-7].label) && (yyvsp[-7].label)->labdefined) err("No backward DO loops", 46); (yyval.bf_node) = make_do(FOR_NODE, (yyvsp[-7].label), (yyvsp[-4].symbol), (yyvsp[-2].ll_node), (yyvsp[0].ll_node), LLNULL); } #line 8559 "gram1.tab.c" /* yacc.c:1646 */ break; case 469: #line 4004 "gram1.y" /* yacc.c:1646 */ { if( (yyvsp[-9].label) && (yyvsp[-9].label)->labdefined) err("No backward DO loops", 46); (yyval.bf_node) = make_do(FOR_NODE, (yyvsp[-9].label), (yyvsp[-6].symbol), (yyvsp[-4].ll_node), (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); } #line 8569 "gram1.tab.c" /* yacc.c:1646 */ break; case 470: #line 4012 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi, CASE_NODE, (yyvsp[0].symbol), (yyvsp[-1].ll_node), LLNULL, LLNULL); } #line 8575 "gram1.tab.c" /* yacc.c:1646 */ break; case 471: #line 4014 "gram1.y" /* yacc.c:1646 */ { /*PTR_LLND p;*/ /* p = make_llnd(fi, DEFAULT, LLNULL, LLNULL, SMNULL); */ (yyval.bf_node) = get_bfnd(fi, DEFAULT_NODE, (yyvsp[0].symbol), LLNULL, LLNULL, LLNULL); } #line 8583 "gram1.tab.c" /* yacc.c:1646 */ break; case 472: #line 4018 "gram1.y" /* yacc.c:1646 */ { make_endselect((yyvsp[0].symbol)); (yyval.bf_node) = BFNULL; } #line 8589 "gram1.tab.c" /* yacc.c:1646 */ break; case 473: #line 4021 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi, SWITCH_NODE, SMNULL, (yyvsp[-1].ll_node), LLNULL, LLNULL) ; } #line 8595 "gram1.tab.c" /* yacc.c:1646 */ break; case 474: #line 4023 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi, SWITCH_NODE, SMNULL, (yyvsp[-1].ll_node), LLNULL, (yyvsp[-7].ll_node)) ; } #line 8601 "gram1.tab.c" /* yacc.c:1646 */ break; case 475: #line 4027 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[-1].ll_node); } #line 8607 "gram1.tab.c" /* yacc.c:1646 */ break; case 476: #line 4033 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node); } #line 8613 "gram1.tab.c" /* yacc.c:1646 */ break; case 477: #line 4035 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi, DDOT, (yyvsp[-1].ll_node), LLNULL, SMNULL); } #line 8619 "gram1.tab.c" /* yacc.c:1646 */ break; case 478: #line 4037 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi, DDOT, LLNULL, (yyvsp[0].ll_node), SMNULL); } #line 8625 "gram1.tab.c" /* yacc.c:1646 */ break; case 479: #line 4039 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi, DDOT, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), SMNULL); } #line 8631 "gram1.tab.c" /* yacc.c:1646 */ break; case 480: #line 4043 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi, EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL); } #line 8637 "gram1.tab.c" /* yacc.c:1646 */ break; case 481: #line 4045 "gram1.y" /* yacc.c:1646 */ { PTR_LLND p; p = make_llnd(fi, EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL); add_to_lowLevelList(p, (yyvsp[-2].ll_node)); } #line 8647 "gram1.tab.c" /* yacc.c:1646 */ break; case 482: #line 4053 "gram1.y" /* yacc.c:1646 */ { (yyval.symbol) = SMNULL; } #line 8653 "gram1.tab.c" /* yacc.c:1646 */ break; case 483: #line 4055 "gram1.y" /* yacc.c:1646 */ { (yyval.symbol) = make_local_entity((yyvsp[0].hash_entry), CONSTRUCT_NAME, global_default, LOCAL); } #line 8660 "gram1.tab.c" /* yacc.c:1646 */ break; case 484: #line 4061 "gram1.y" /* yacc.c:1646 */ {(yyval.hash_entry) = HSNULL;} #line 8666 "gram1.tab.c" /* yacc.c:1646 */ break; case 485: #line 4063 "gram1.y" /* yacc.c:1646 */ { (yyval.hash_entry) = (yyvsp[0].hash_entry);} #line 8672 "gram1.tab.c" /* yacc.c:1646 */ break; case 486: #line 4067 "gram1.y" /* yacc.c:1646 */ {(yyval.hash_entry) = look_up_sym(yytext);} #line 8678 "gram1.tab.c" /* yacc.c:1646 */ break; case 487: #line 4071 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; s = make_local_entity( (yyvsp[-1].hash_entry), CONSTRUCT_NAME, global_default, LOCAL); (yyval.ll_node) = make_llnd(fi, VAR_REF, LLNULL, LLNULL, s); } #line 8687 "gram1.tab.c" /* yacc.c:1646 */ break; case 488: #line 4092 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = make_if((yyvsp[-1].ll_node)); } #line 8693 "gram1.tab.c" /* yacc.c:1646 */ break; case 489: #line 4095 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = make_forall((yyvsp[-2].ll_node),(yyvsp[-1].ll_node)); } #line 8699 "gram1.tab.c" /* yacc.c:1646 */ break; case 490: #line 4099 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi, EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL); } #line 8705 "gram1.tab.c" /* yacc.c:1646 */ break; case 491: #line 4101 "gram1.y" /* yacc.c:1646 */ { PTR_LLND p; p = make_llnd(fi, EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL); add_to_lowLevelList(p, (yyvsp[-2].ll_node)); } #line 8714 "gram1.tab.c" /* yacc.c:1646 */ break; case 492: #line 4108 "gram1.y" /* yacc.c:1646 */ {(yyval.ll_node) = make_llnd(fi, FORALL_OP, (yyvsp[0].ll_node), LLNULL, (yyvsp[-2].symbol)); } #line 8720 "gram1.tab.c" /* yacc.c:1646 */ break; case 493: #line 4112 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node)=LLNULL;} #line 8726 "gram1.tab.c" /* yacc.c:1646 */ break; case 494: #line 4114 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node)=(yyvsp[0].ll_node);} #line 8732 "gram1.tab.c" /* yacc.c:1646 */ break; case 495: #line 4125 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; s = (yyvsp[0].hash_entry)->id_attr; if (!s || s->variant == DEFAULT) { s = make_scalar((yyvsp[0].hash_entry), TYNULL, LOCAL); s->decl = SOFT; } (yyval.symbol) = s; } #line 8746 "gram1.tab.c" /* yacc.c:1646 */ break; case 496: #line 4138 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; PTR_LLND l; int vrnt; /* s = make_scalar($1, TYNULL, LOCAL);*/ /*16.02.03*/ s = (yyvsp[-4].symbol); if (s->variant != CONST_NAME) { if(in_vec) vrnt=SEQ; else vrnt=DDOT; l = make_llnd(fi, SEQ, make_llnd(fi, vrnt, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), SMNULL), LLNULL, SMNULL); (yyval.ll_node) = make_llnd(fi,IOACCESS, LLNULL, l, s); do_name_err = NO; } else { err("Symbolic constant not allowed as DO variable", 47); do_name_err = YES; } } #line 8772 "gram1.tab.c" /* yacc.c:1646 */ break; case 497: #line 4161 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; PTR_LLND l; int vrnt; /*s = make_scalar($1, TYNULL, LOCAL);*/ /*16.02.03*/ s = (yyvsp[-6].symbol); if( s->variant != CONST_NAME ) { if(in_vec) vrnt=SEQ; else vrnt=DDOT; l = make_llnd(fi, SEQ, make_llnd(fi, vrnt, (yyvsp[-4].ll_node), (yyvsp[-2].ll_node), SMNULL), (yyvsp[0].ll_node), SMNULL); (yyval.ll_node) = make_llnd(fi,IOACCESS, LLNULL, l, s); do_name_err = NO; } else { err("Symbolic constant not allowed as DO variable", 47); do_name_err = YES; } } #line 8797 "gram1.tab.c" /* yacc.c:1646 */ break; case 498: #line 4184 "gram1.y" /* yacc.c:1646 */ { (yyval.label) = LBNULL; } #line 8803 "gram1.tab.c" /* yacc.c:1646 */ break; case 499: #line 4186 "gram1.y" /* yacc.c:1646 */ { (yyval.label) = make_label_node(fi,convci(yyleng, yytext)); (yyval.label)->scope = cur_scope(); } #line 8812 "gram1.tab.c" /* yacc.c:1646 */ break; case 500: #line 4193 "gram1.y" /* yacc.c:1646 */ { make_endwhere((yyvsp[0].symbol)); (yyval.bf_node) = BFNULL; } #line 8818 "gram1.tab.c" /* yacc.c:1646 */ break; case 501: #line 4195 "gram1.y" /* yacc.c:1646 */ { make_elsewhere((yyvsp[0].symbol)); lastwasbranch = NO; (yyval.bf_node) = BFNULL; } #line 8824 "gram1.tab.c" /* yacc.c:1646 */ break; case 502: #line 4197 "gram1.y" /* yacc.c:1646 */ { make_elsewhere_mask((yyvsp[-2].ll_node),(yyvsp[0].symbol)); lastwasbranch = NO; (yyval.bf_node) = BFNULL; } #line 8830 "gram1.tab.c" /* yacc.c:1646 */ break; case 503: #line 4199 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi, WHERE_BLOCK_STMT, SMNULL, (yyvsp[-1].ll_node), LLNULL, LLNULL); } #line 8836 "gram1.tab.c" /* yacc.c:1646 */ break; case 504: #line 4201 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi, WHERE_BLOCK_STMT, SMNULL, (yyvsp[-1].ll_node), LLNULL, (yyvsp[-5].ll_node)); } #line 8842 "gram1.tab.c" /* yacc.c:1646 */ break; case 505: #line 4206 "gram1.y" /* yacc.c:1646 */ { PTR_LLND p, r; PTR_SYMB s1, s2 = SMNULL, s3, arg_list; PTR_HASH hash_entry; /* if (just_look_up_sym("=") != HSNULL) { p = intrinsic_op_node("=", EQUAL, $2, $4); $$ = get_bfnd(fi, OVERLOADED_ASSIGN_STAT, SMNULL, p, $2, $4); } else */ if ((yyvsp[-2].ll_node)->variant == FUNC_CALL) { if(parstate==INEXEC){ err("Declaration among executables", 30); /* $$=BFNULL;*/ (yyval.bf_node) = get_bfnd(fi,STMTFN_STAT, SMNULL, (yyvsp[-2].ll_node), LLNULL, LLNULL); } else { (yyvsp[-2].ll_node)->variant = STMTFN_DECL; /* $2->entry.Template.ll_ptr2 = $4; */ if( (yyvsp[-2].ll_node)->entry.Template.ll_ptr1) { r = (yyvsp[-2].ll_node)->entry.Template.ll_ptr1->entry.Template.ll_ptr1; if(r->variant != VAR_REF && r->variant != ARRAY_REF){ err("A dummy argument of a statement function must be a scalar identifier", 333); s1 = SMNULL; } else s1 = r ->entry.Template.symbol; } else s1 = SMNULL; if (s1) s1->scope = cur_scope(); (yyval.bf_node) = get_bfnd(fi,STMTFN_STAT, SMNULL, (yyvsp[-2].ll_node), LLNULL, LLNULL); add_scope_level((yyval.bf_node), NO); arg_list = SMNULL; if (s1) { /*arg_list = SMNULL;*/ p = (yyvsp[-2].ll_node)->entry.Template.ll_ptr1; while (p != LLNULL) { /* if (p->entry.Template.ll_ptr1->variant != VAR_REF) { errstr("cftn.gram:1: illegal statement function %s.", $2->entry.Template.symbol->ident); break; } */ r = p->entry.Template.ll_ptr1; if(r->variant != VAR_REF && r->variant != ARRAY_REF){ err("A dummy argument of a statement function must be a scalar identifier", 333); break; } hash_entry = look_up_sym(r->entry.Template.symbol->parent->ident); s3 = make_scalar(hash_entry, s1->type, IO); replace_symbol_in_expr(s3,(yyvsp[0].ll_node)); if (arg_list == SMNULL) s2 = arg_list = s3; else { s2->id_list = s3; s2 = s3; } p = p->entry.Template.ll_ptr2; } } (yyvsp[-2].ll_node)->entry.Template.ll_ptr1 = (yyvsp[0].ll_node); install_param_list((yyvsp[-2].ll_node)->entry.Template.symbol, arg_list, LLNULL, FUNCTION_NAME); delete_beyond_scope_level((yyval.bf_node)); /* else errstr("cftn.gram: Illegal statement function declaration %s.", $2->entry.Template.symbol->ident); */ } } else { (yyval.bf_node) = get_bfnd(fi,ASSIGN_STAT,SMNULL, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), LLNULL); parstate = INEXEC; } } #line 8922 "gram1.tab.c" /* yacc.c:1646 */ break; case 506: #line 4282 "gram1.y" /* yacc.c:1646 */ { /*PTR_SYMB s;*/ /*s = make_scalar($2, TYNULL, LOCAL);*/ (yyval.bf_node) = get_bfnd(fi, POINTER_ASSIGN_STAT, SMNULL, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), LLNULL); } #line 8932 "gram1.tab.c" /* yacc.c:1646 */ break; case 507: #line 4294 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB p; p = make_scalar((yyvsp[0].hash_entry), TYNULL, LOCAL); p->variant = LABEL_VAR; (yyval.bf_node) = get_bfnd(fi,ASSLAB_STAT, p, (yyvsp[-2].ll_node),LLNULL,LLNULL); } #line 8943 "gram1.tab.c" /* yacc.c:1646 */ break; case 508: #line 4301 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,CONT_STAT,SMNULL,LLNULL,LLNULL,LLNULL); } #line 8949 "gram1.tab.c" /* yacc.c:1646 */ break; case 510: #line 4304 "gram1.y" /* yacc.c:1646 */ { inioctl = NO; } #line 8955 "gram1.tab.c" /* yacc.c:1646 */ break; case 511: #line 4306 "gram1.y" /* yacc.c:1646 */ { PTR_LLND p; p = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL); p = make_llnd(fi,EXPR_LIST, (yyvsp[-2].ll_node), p, SMNULL); (yyval.bf_node)= get_bfnd(fi,ARITHIF_NODE, SMNULL, (yyvsp[-6].ll_node), make_llnd(fi,EXPR_LIST, (yyvsp[-4].ll_node), p, SMNULL), LLNULL); thiswasbranch = YES; } #line 8968 "gram1.tab.c" /* yacc.c:1646 */ break; case 512: #line 4315 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = subroutine_call((yyvsp[0].symbol), LLNULL, LLNULL, PLAIN); /* match_parameters($1, LLNULL); $$= get_bfnd(fi,PROC_STAT, $1, LLNULL, LLNULL, LLNULL); */ endioctl(); } #line 8979 "gram1.tab.c" /* yacc.c:1646 */ break; case 513: #line 4322 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = subroutine_call((yyvsp[-2].symbol), LLNULL, LLNULL, PLAIN); /* match_parameters($1, LLNULL); $$= get_bfnd(fi,PROC_STAT,$1,LLNULL,LLNULL,LLNULL); */ endioctl(); } #line 8990 "gram1.tab.c" /* yacc.c:1646 */ break; case 514: #line 4329 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = subroutine_call((yyvsp[-3].symbol), (yyvsp[-1].ll_node), LLNULL, PLAIN); /* match_parameters($1, $3); $$= get_bfnd(fi,PROC_STAT,$1,$3,LLNULL,LLNULL); */ endioctl(); } #line 9001 "gram1.tab.c" /* yacc.c:1646 */ break; case 515: #line 4337 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,RETURN_STAT,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL); thiswasbranch = YES; } #line 9010 "gram1.tab.c" /* yacc.c:1646 */ break; case 516: #line 4342 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,(yyvsp[-2].token),SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL); thiswasbranch = ((yyvsp[-2].token) == STOP_STAT); } #line 9019 "gram1.tab.c" /* yacc.c:1646 */ break; case 517: #line 4347 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi, CYCLE_STMT, (yyvsp[0].symbol), LLNULL, LLNULL, LLNULL); } #line 9025 "gram1.tab.c" /* yacc.c:1646 */ break; case 518: #line 4350 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi, EXIT_STMT, (yyvsp[0].symbol), LLNULL, LLNULL, LLNULL); } #line 9031 "gram1.tab.c" /* yacc.c:1646 */ break; case 519: #line 4353 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi, ALLOCATE_STMT, SMNULL, (yyvsp[-1].ll_node), stat_alloc, LLNULL); } #line 9037 "gram1.tab.c" /* yacc.c:1646 */ break; case 520: #line 4356 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi, DEALLOCATE_STMT, SMNULL, (yyvsp[-1].ll_node), stat_alloc , LLNULL); } #line 9043 "gram1.tab.c" /* yacc.c:1646 */ break; case 521: #line 4359 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi, NULLIFY_STMT, SMNULL, (yyvsp[-1].ll_node), LLNULL, LLNULL); } #line 9049 "gram1.tab.c" /* yacc.c:1646 */ break; case 522: #line 4362 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi, WHERE_NODE, SMNULL, (yyvsp[-4].ll_node), (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); } #line 9055 "gram1.tab.c" /* yacc.c:1646 */ break; case 523: #line 4380 "gram1.y" /* yacc.c:1646 */ {(yyval.ll_node) = LLNULL;} #line 9061 "gram1.tab.c" /* yacc.c:1646 */ break; case 524: #line 4384 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node)=get_bfnd(fi,GOTO_NODE,SMNULL,LLNULL,LLNULL,(PTR_LLND)(yyvsp[0].ll_node)); thiswasbranch = YES; } #line 9070 "gram1.tab.c" /* yacc.c:1646 */ break; case 525: #line 4389 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB p; if((yyvsp[0].hash_entry)->id_attr) p = (yyvsp[0].hash_entry)->id_attr; else { p = make_scalar((yyvsp[0].hash_entry), TYNULL, LOCAL); p->variant = LABEL_VAR; } if(p->variant == LABEL_VAR) { (yyval.bf_node) = get_bfnd(fi,ASSGOTO_NODE,p,LLNULL,LLNULL,LLNULL); thiswasbranch = YES; } else { err("Must go to assigned variable", 48); (yyval.bf_node) = BFNULL; } } #line 9093 "gram1.tab.c" /* yacc.c:1646 */ break; case 526: #line 4408 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB p; if((yyvsp[-4].hash_entry)->id_attr) p = (yyvsp[-4].hash_entry)->id_attr; else { p = make_scalar((yyvsp[-4].hash_entry), TYNULL, LOCAL); p->variant = LABEL_VAR; } if (p->variant == LABEL_VAR) { (yyval.bf_node) = get_bfnd(fi,ASSGOTO_NODE,p,(yyvsp[-1].ll_node),LLNULL,LLNULL); thiswasbranch = YES; } else { err("Must go to assigned variable",48); (yyval.bf_node) = BFNULL; } } #line 9116 "gram1.tab.c" /* yacc.c:1646 */ break; case 527: #line 4427 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,COMGOTO_NODE, SMNULL, (yyvsp[-3].ll_node), (yyvsp[0].ll_node), LLNULL); } #line 9122 "gram1.tab.c" /* yacc.c:1646 */ break; case 530: #line 4435 "gram1.y" /* yacc.c:1646 */ { (yyval.symbol) = make_procedure((yyvsp[-1].hash_entry), LOCAL); } #line 9128 "gram1.tab.c" /* yacc.c:1646 */ break; case 531: #line 4439 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); endioctl(); } #line 9137 "gram1.tab.c" /* yacc.c:1646 */ break; case 532: #line 4444 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-3].ll_node), (yyvsp[0].ll_node), EXPR_LIST); endioctl(); } #line 9146 "gram1.tab.c" /* yacc.c:1646 */ break; case 533: #line 4451 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node); } #line 9152 "gram1.tab.c" /* yacc.c:1646 */ break; case 534: #line 4453 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi, KEYWORD_ARG, (yyvsp[-1].ll_node), (yyvsp[0].ll_node), SMNULL); } #line 9158 "gram1.tab.c" /* yacc.c:1646 */ break; case 535: #line 4455 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,LABEL_ARG,(yyvsp[0].ll_node),LLNULL,SMNULL); } #line 9164 "gram1.tab.c" /* yacc.c:1646 */ break; case 536: #line 4458 "gram1.y" /* yacc.c:1646 */ { (yyval.token) = PAUSE_NODE; } #line 9170 "gram1.tab.c" /* yacc.c:1646 */ break; case 537: #line 4459 "gram1.y" /* yacc.c:1646 */ { (yyval.token) = STOP_STAT; } #line 9176 "gram1.tab.c" /* yacc.c:1646 */ break; case 538: #line 4470 "gram1.y" /* yacc.c:1646 */ { if(parstate == OUTSIDE) { PTR_BFND p; p = get_bfnd(fi,PROG_HEDR, make_program(look_up_sym("_MAIN")), LLNULL, LLNULL, LLNULL); set_blobs(p, global_bfnd, NEW_GROUP1); add_scope_level(p, NO); position = IN_PROC; } if(parstate < INDATA) enddcl(); parstate = INEXEC; yystno = 0; } #line 9193 "gram1.tab.c" /* yacc.c:1646 */ break; case 539: #line 4485 "gram1.y" /* yacc.c:1646 */ { intonly = YES; } #line 9199 "gram1.tab.c" /* yacc.c:1646 */ break; case 540: #line 4489 "gram1.y" /* yacc.c:1646 */ { intonly = NO; } #line 9205 "gram1.tab.c" /* yacc.c:1646 */ break; case 541: #line 4497 "gram1.y" /* yacc.c:1646 */ { (yyvsp[-1].bf_node)->entry.Template.ll_ptr2 = (yyvsp[0].ll_node); (yyval.bf_node) = (yyvsp[-1].bf_node); } #line 9212 "gram1.tab.c" /* yacc.c:1646 */ break; case 542: #line 4500 "gram1.y" /* yacc.c:1646 */ { PTR_LLND p, q = LLNULL; q = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL); q->entry.string_val = (char *)"unit"; q->type = global_string; p = make_llnd(fi, SPEC_PAIR, q, (yyvsp[0].ll_node), SMNULL); (yyvsp[-1].bf_node)->entry.Template.ll_ptr2 = p; endioctl(); (yyval.bf_node) = (yyvsp[-1].bf_node); } #line 9226 "gram1.tab.c" /* yacc.c:1646 */ break; case 543: #line 4510 "gram1.y" /* yacc.c:1646 */ { PTR_LLND p, q, r; p = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL); p->entry.string_val = (char *)"*"; p->type = global_string; q = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL); q->entry.string_val = (char *)"unit"; q->type = global_string; r = make_llnd(fi, SPEC_PAIR, p, q, SMNULL); (yyvsp[-1].bf_node)->entry.Template.ll_ptr2 = r; endioctl(); (yyval.bf_node) = (yyvsp[-1].bf_node); } #line 9243 "gram1.tab.c" /* yacc.c:1646 */ break; case 544: #line 4523 "gram1.y" /* yacc.c:1646 */ { PTR_LLND p, q, r; p = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL); p->entry.string_val = (char *)"**"; p->type = global_string; q = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL); q->entry.string_val = (char *)"unit"; q->type = global_string; r = make_llnd(fi, SPEC_PAIR, p, q, SMNULL); (yyvsp[-1].bf_node)->entry.Template.ll_ptr2 = r; endioctl(); (yyval.bf_node) = (yyvsp[-1].bf_node); } #line 9260 "gram1.tab.c" /* yacc.c:1646 */ break; case 545: #line 4536 "gram1.y" /* yacc.c:1646 */ { (yyvsp[-1].bf_node)->entry.Template.ll_ptr2 = (yyvsp[0].ll_node); (yyval.bf_node) = (yyvsp[-1].bf_node); } #line 9267 "gram1.tab.c" /* yacc.c:1646 */ break; case 546: #line 4539 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = (yyvsp[0].bf_node); } #line 9273 "gram1.tab.c" /* yacc.c:1646 */ break; case 547: #line 4541 "gram1.y" /* yacc.c:1646 */ { (yyvsp[-1].bf_node)->entry.Template.ll_ptr2 = (yyvsp[0].ll_node); (yyval.bf_node) = (yyvsp[-1].bf_node); } #line 9280 "gram1.tab.c" /* yacc.c:1646 */ break; case 548: #line 4544 "gram1.y" /* yacc.c:1646 */ { (yyvsp[-1].bf_node)->entry.Template.ll_ptr2 = (yyvsp[0].ll_node); (yyval.bf_node) = (yyvsp[-1].bf_node); } #line 9287 "gram1.tab.c" /* yacc.c:1646 */ break; case 549: #line 4547 "gram1.y" /* yacc.c:1646 */ { (yyvsp[-2].bf_node)->entry.Template.ll_ptr2 = (yyvsp[-1].ll_node); (yyvsp[-2].bf_node)->entry.Template.ll_ptr1 = (yyvsp[0].ll_node); (yyval.bf_node) = (yyvsp[-2].bf_node); } #line 9295 "gram1.tab.c" /* yacc.c:1646 */ break; case 550: #line 4551 "gram1.y" /* yacc.c:1646 */ { (yyvsp[-3].bf_node)->entry.Template.ll_ptr2 = (yyvsp[-2].ll_node); (yyvsp[-3].bf_node)->entry.Template.ll_ptr1 = (yyvsp[0].ll_node); (yyval.bf_node) = (yyvsp[-3].bf_node); } #line 9303 "gram1.tab.c" /* yacc.c:1646 */ break; case 551: #line 4560 "gram1.y" /* yacc.c:1646 */ { (yyvsp[-1].bf_node)->entry.Template.ll_ptr2 = (yyvsp[0].ll_node); (yyval.bf_node) = (yyvsp[-1].bf_node); } #line 9310 "gram1.tab.c" /* yacc.c:1646 */ break; case 552: #line 4563 "gram1.y" /* yacc.c:1646 */ { (yyvsp[-2].bf_node)->entry.Template.ll_ptr2 = (yyvsp[-1].ll_node); (yyvsp[-2].bf_node)->entry.Template.ll_ptr1 = (yyvsp[0].ll_node); (yyval.bf_node) = (yyvsp[-2].bf_node); } #line 9318 "gram1.tab.c" /* yacc.c:1646 */ break; case 553: #line 4567 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = (yyvsp[0].bf_node); } #line 9324 "gram1.tab.c" /* yacc.c:1646 */ break; case 554: #line 4569 "gram1.y" /* yacc.c:1646 */ { (yyvsp[-2].bf_node)->entry.Template.ll_ptr1 = (yyvsp[0].ll_node); (yyval.bf_node) = (yyvsp[-2].bf_node); } #line 9331 "gram1.tab.c" /* yacc.c:1646 */ break; case 555: #line 4575 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = (yyvsp[-2].bf_node); } #line 9337 "gram1.tab.c" /* yacc.c:1646 */ break; case 556: #line 4579 "gram1.y" /* yacc.c:1646 */ {(yyval.bf_node) = get_bfnd(fi, BACKSPACE_STAT, SMNULL, LLNULL, LLNULL, LLNULL);} #line 9343 "gram1.tab.c" /* yacc.c:1646 */ break; case 557: #line 4581 "gram1.y" /* yacc.c:1646 */ {(yyval.bf_node) = get_bfnd(fi, REWIND_STAT, SMNULL, LLNULL, LLNULL, LLNULL);} #line 9349 "gram1.tab.c" /* yacc.c:1646 */ break; case 558: #line 4583 "gram1.y" /* yacc.c:1646 */ {(yyval.bf_node) = get_bfnd(fi, ENDFILE_STAT, SMNULL, LLNULL, LLNULL, LLNULL);} #line 9355 "gram1.tab.c" /* yacc.c:1646 */ break; case 559: #line 4590 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = (yyvsp[-2].bf_node); } #line 9361 "gram1.tab.c" /* yacc.c:1646 */ break; case 560: #line 4594 "gram1.y" /* yacc.c:1646 */ {(yyval.bf_node) = get_bfnd(fi, OPEN_STAT, SMNULL, LLNULL, LLNULL, LLNULL);} #line 9367 "gram1.tab.c" /* yacc.c:1646 */ break; case 561: #line 4596 "gram1.y" /* yacc.c:1646 */ {(yyval.bf_node) = get_bfnd(fi, CLOSE_STAT, SMNULL, LLNULL, LLNULL, LLNULL);} #line 9373 "gram1.tab.c" /* yacc.c:1646 */ break; case 562: #line 4600 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi, INQUIRE_STAT, SMNULL, LLNULL, (yyvsp[0].ll_node), LLNULL);} #line 9379 "gram1.tab.c" /* yacc.c:1646 */ break; case 563: #line 4602 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi, INQUIRE_STAT, SMNULL, (yyvsp[0].ll_node), (yyvsp[-1].ll_node), LLNULL);} #line 9385 "gram1.tab.c" /* yacc.c:1646 */ break; case 564: #line 4606 "gram1.y" /* yacc.c:1646 */ { PTR_LLND p; PTR_LLND q = LLNULL; if ((yyvsp[0].ll_node)->variant == INT_VAL) { PTR_LABEL r; r = make_label_node(fi, (long) (yyvsp[0].ll_node)->entry.ival); r->scope = cur_scope(); p = make_llnd_label(fi, LABEL_REF, r); } else p = (yyvsp[0].ll_node); q = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL); q->entry.string_val = (char *)"fmt"; q->type = global_string; (yyval.ll_node) = make_llnd(fi, SPEC_PAIR, q, p, SMNULL); endioctl(); } #line 9408 "gram1.tab.c" /* yacc.c:1646 */ break; case 565: #line 4625 "gram1.y" /* yacc.c:1646 */ { PTR_LLND p; PTR_LLND q; p = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL); p->entry.string_val = (char *)"*"; p->type = global_string; q = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL); q->entry.string_val = (char *)"fmt"; q->type = global_string; (yyval.ll_node) = make_llnd(fi, SPEC_PAIR, q, p, SMNULL); endioctl(); } #line 9425 "gram1.tab.c" /* yacc.c:1646 */ break; case 566: #line 4641 "gram1.y" /* yacc.c:1646 */ { PTR_LLND p; p = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL); p->entry.string_val = (char *)"unit"; p->type = global_string; (yyval.ll_node) = make_llnd(fi, SPEC_PAIR, p, (yyvsp[-1].ll_node), SMNULL); endioctl(); } #line 9438 "gram1.tab.c" /* yacc.c:1646 */ break; case 567: #line 4652 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[-1].ll_node); endioctl(); } #line 9447 "gram1.tab.c" /* yacc.c:1646 */ break; case 568: #line 4659 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node); endioctl();} #line 9453 "gram1.tab.c" /* yacc.c:1646 */ break; case 569: #line 4661 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-3].ll_node), (yyvsp[0].ll_node), EXPR_LIST); endioctl();} #line 9459 "gram1.tab.c" /* yacc.c:1646 */ break; case 570: #line 4665 "gram1.y" /* yacc.c:1646 */ { PTR_LLND p; PTR_LLND q; nioctl++; if ((nioctl == 2) && ((yyvsp[0].ll_node)->variant == INT_VAL)) { PTR_LABEL r; r = make_label_node(fi, (long) (yyvsp[0].ll_node)->entry.ival); r->scope = cur_scope(); p = make_llnd_label(fi, LABEL_REF, r); } else p = (yyvsp[0].ll_node); q = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL); if (nioctl == 1) q->entry.string_val = (char *)"unit"; else { if(((yyvsp[0].ll_node)->variant == VAR_REF) && (yyvsp[0].ll_node)->entry.Template.symbol->variant == NAMELIST_NAME) q->entry.string_val = (char *)"nml"; else q->entry.string_val = (char *)"fmt"; } q->type = global_string; (yyval.ll_node) = make_llnd(fi, SPEC_PAIR, q, p, SMNULL); } #line 9489 "gram1.tab.c" /* yacc.c:1646 */ break; case 571: #line 4691 "gram1.y" /* yacc.c:1646 */ { PTR_LLND p; PTR_LLND q; nioctl++; p = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL); p->entry.string_val = (char *)"*"; p->type = global_string; q = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL); if (nioctl == 1) q->entry.string_val = (char *)"unit"; else q->entry.string_val = (char *)"fmt"; q->type = global_string; (yyval.ll_node) = make_llnd(fi, SPEC_PAIR, q, p, SMNULL); } #line 9508 "gram1.tab.c" /* yacc.c:1646 */ break; case 572: #line 4706 "gram1.y" /* yacc.c:1646 */ { PTR_LLND p; PTR_LLND q; nioctl++; p = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL); p->entry.string_val = (char *)"**"; p->type = global_string; q = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL); if (nioctl == 1) q->entry.string_val = (char *)"unit"; else q->entry.string_val = (char *)"fmt"; q->type = global_string; (yyval.ll_node) = make_llnd(fi, SPEC_PAIR, q, p, SMNULL); } #line 9527 "gram1.tab.c" /* yacc.c:1646 */ break; case 573: #line 4721 "gram1.y" /* yacc.c:1646 */ { PTR_LLND p; char *q; q = (yyvsp[-1].ll_node)->entry.string_val; if ((strcmp(q, "end") == 0) || (strcmp(q, "err") == 0) || (strcmp(q, "eor") == 0) || ((strcmp(q,"fmt") == 0) && ((yyvsp[0].ll_node)->variant == INT_VAL))) { PTR_LABEL r; r = make_label_node(fi, (long) (yyvsp[0].ll_node)->entry.ival); r->scope = cur_scope(); p = make_llnd_label(fi, LABEL_REF, r); } else p = (yyvsp[0].ll_node); (yyval.ll_node) = make_llnd(fi, SPEC_PAIR, (yyvsp[-1].ll_node), p, SMNULL); } #line 9548 "gram1.tab.c" /* yacc.c:1646 */ break; case 574: #line 4738 "gram1.y" /* yacc.c:1646 */ { PTR_LLND p; p = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL); p->entry.string_val = (char *)"*"; p->type = global_string; (yyval.ll_node) = make_llnd(fi, SPEC_PAIR, (yyvsp[-1].ll_node), p, SMNULL); } #line 9560 "gram1.tab.c" /* yacc.c:1646 */ break; case 575: #line 4746 "gram1.y" /* yacc.c:1646 */ { PTR_LLND p; p = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL); p->entry.string_val = (char *)"*"; p->type = global_string; (yyval.ll_node) = make_llnd(fi, SPEC_PAIR, (yyvsp[-1].ll_node), p, SMNULL); } #line 9571 "gram1.tab.c" /* yacc.c:1646 */ break; case 576: #line 4755 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL); (yyval.ll_node)->entry.string_val = copys(yytext); (yyval.ll_node)->type = global_string; } #line 9580 "gram1.tab.c" /* yacc.c:1646 */ break; case 577: #line 4763 "gram1.y" /* yacc.c:1646 */ {(yyval.bf_node) = get_bfnd(fi, READ_STAT, SMNULL, LLNULL, LLNULL, LLNULL);} #line 9586 "gram1.tab.c" /* yacc.c:1646 */ break; case 578: #line 4768 "gram1.y" /* yacc.c:1646 */ {(yyval.bf_node) = get_bfnd(fi, WRITE_STAT, SMNULL, LLNULL, LLNULL, LLNULL);} #line 9592 "gram1.tab.c" /* yacc.c:1646 */ break; case 579: #line 4773 "gram1.y" /* yacc.c:1646 */ { PTR_LLND p, q, l; if ((yyvsp[-1].ll_node)->variant == INT_VAL) { PTR_LABEL r; r = make_label_node(fi, (long) (yyvsp[-1].ll_node)->entry.ival); r->scope = cur_scope(); p = make_llnd_label(fi, LABEL_REF, r); } else p = (yyvsp[-1].ll_node); q = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL); q->entry.string_val = (char *)"fmt"; q->type = global_string; l = make_llnd(fi, SPEC_PAIR, q, p, SMNULL); (yyval.bf_node) = get_bfnd(fi, PRINT_STAT, SMNULL, LLNULL, l, LLNULL); endioctl(); } #line 9618 "gram1.tab.c" /* yacc.c:1646 */ break; case 580: #line 4795 "gram1.y" /* yacc.c:1646 */ { PTR_LLND p, q, r; p = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL); p->entry.string_val = (char *)"*"; p->type = global_string; q = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL); q->entry.string_val = (char *)"fmt"; q->type = global_string; r = make_llnd(fi, SPEC_PAIR, q, p, SMNULL); (yyval.bf_node) = get_bfnd(fi, PRINT_STAT, SMNULL, LLNULL, r, LLNULL); endioctl(); } #line 9635 "gram1.tab.c" /* yacc.c:1646 */ break; case 581: #line 4811 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST);} #line 9641 "gram1.tab.c" /* yacc.c:1646 */ break; case 582: #line 4813 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST);} #line 9647 "gram1.tab.c" /* yacc.c:1646 */ break; case 583: #line 4817 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node); } #line 9653 "gram1.tab.c" /* yacc.c:1646 */ break; case 584: #line 4819 "gram1.y" /* yacc.c:1646 */ { (yyvsp[-1].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-3].ll_node); (yyval.ll_node) = (yyvsp[-1].ll_node); } #line 9662 "gram1.tab.c" /* yacc.c:1646 */ break; case 585: #line 4826 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); (yyval.ll_node)->type = (yyvsp[0].ll_node)->type;} #line 9668 "gram1.tab.c" /* yacc.c:1646 */ break; case 586: #line 4828 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node); } #line 9674 "gram1.tab.c" /* yacc.c:1646 */ break; case 587: #line 4830 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node); } #line 9680 "gram1.tab.c" /* yacc.c:1646 */ break; case 588: #line 4834 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); (yyval.ll_node)->type = (yyvsp[-2].ll_node)->type;} #line 9686 "gram1.tab.c" /* yacc.c:1646 */ break; case 589: #line 4836 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); (yyval.ll_node)->type = (yyvsp[-2].ll_node)->type;} #line 9692 "gram1.tab.c" /* yacc.c:1646 */ break; case 590: #line 4838 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); (yyval.ll_node)->type = (yyvsp[-2].ll_node)->type;} #line 9698 "gram1.tab.c" /* yacc.c:1646 */ break; case 591: #line 4840 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); (yyval.ll_node)->type = (yyvsp[-2].ll_node)->type;} #line 9704 "gram1.tab.c" /* yacc.c:1646 */ break; case 592: #line 4842 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); (yyval.ll_node)->type = (yyvsp[-2].ll_node)->type;} #line 9710 "gram1.tab.c" /* yacc.c:1646 */ break; case 593: #line 4844 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); (yyval.ll_node)->type = (yyvsp[-2].ll_node)->type;} #line 9716 "gram1.tab.c" /* yacc.c:1646 */ break; case 594: #line 4848 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); (yyval.ll_node)->type = global_complex; } #line 9723 "gram1.tab.c" /* yacc.c:1646 */ break; case 595: #line 4851 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node), LLNULL, EXPR_LIST); (yyval.ll_node)->type = (yyvsp[-1].ll_node)->type; } #line 9730 "gram1.tab.c" /* yacc.c:1646 */ break; case 596: #line 4854 "gram1.y" /* yacc.c:1646 */ { (yyvsp[-1].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-3].ll_node); (yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node), LLNULL, EXPR_LIST); (yyval.ll_node)->type = (yyvsp[-3].ll_node)->type; } #line 9740 "gram1.tab.c" /* yacc.c:1646 */ break; case 597: #line 4860 "gram1.y" /* yacc.c:1646 */ { (yyvsp[-1].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-3].ll_node); (yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node), LLNULL, EXPR_LIST); (yyval.ll_node)->type = (yyvsp[-3].ll_node)->type; } #line 9750 "gram1.tab.c" /* yacc.c:1646 */ break; case 598: #line 4866 "gram1.y" /* yacc.c:1646 */ { (yyvsp[-1].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-3].ll_node); (yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node), LLNULL, EXPR_LIST); (yyval.ll_node)->type = (yyvsp[-3].ll_node)->type; } #line 9760 "gram1.tab.c" /* yacc.c:1646 */ break; case 599: #line 4874 "gram1.y" /* yacc.c:1646 */ { inioctl = YES; } #line 9766 "gram1.tab.c" /* yacc.c:1646 */ break; case 600: #line 4878 "gram1.y" /* yacc.c:1646 */ { startioctl();} #line 9772 "gram1.tab.c" /* yacc.c:1646 */ break; case 601: #line 4886 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node); } #line 9778 "gram1.tab.c" /* yacc.c:1646 */ break; case 602: #line 4888 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[-1].ll_node); } #line 9784 "gram1.tab.c" /* yacc.c:1646 */ break; case 603: #line 4892 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node); } #line 9790 "gram1.tab.c" /* yacc.c:1646 */ break; case 604: #line 4894 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node); } #line 9796 "gram1.tab.c" /* yacc.c:1646 */ break; case 605: #line 4896 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,(yyvsp[-1].token), (yyvsp[-2].ll_node), (yyvsp[0].ll_node), SMNULL); set_expr_type((yyval.ll_node)); } #line 9805 "gram1.tab.c" /* yacc.c:1646 */ break; case 606: #line 4901 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,MULT_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), SMNULL); set_expr_type((yyval.ll_node)); } #line 9814 "gram1.tab.c" /* yacc.c:1646 */ break; case 607: #line 4906 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,DIV_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), SMNULL); set_expr_type((yyval.ll_node)); } #line 9823 "gram1.tab.c" /* yacc.c:1646 */ break; case 608: #line 4911 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,EXP_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), SMNULL); set_expr_type((yyval.ll_node)); } #line 9832 "gram1.tab.c" /* yacc.c:1646 */ break; case 609: #line 4916 "gram1.y" /* yacc.c:1646 */ { if((yyvsp[-1].token) == SUBT_OP) { (yyval.ll_node) = make_llnd(fi,SUBT_OP, (yyvsp[0].ll_node), LLNULL, SMNULL); set_expr_type((yyval.ll_node)); } else (yyval.ll_node) = (yyvsp[0].ll_node); } #line 9845 "gram1.tab.c" /* yacc.c:1646 */ break; case 610: #line 4925 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,CONCAT_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), SMNULL); set_expr_type((yyval.ll_node)); } #line 9854 "gram1.tab.c" /* yacc.c:1646 */ break; case 611: #line 4930 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = LLNULL; } #line 9860 "gram1.tab.c" /* yacc.c:1646 */ break; case 612: #line 4935 "gram1.y" /* yacc.c:1646 */ { comments = cur_comment = CMNULL; } #line 9866 "gram1.tab.c" /* yacc.c:1646 */ break; case 613: #line 4937 "gram1.y" /* yacc.c:1646 */ { PTR_CMNT p; p = make_comment(fi,*commentbuf, HALF); if (cur_comment) cur_comment->next = p; else { if ((pred_bfnd->control_parent->variant == LOGIF_NODE) ||(pred_bfnd->control_parent->variant == FORALL_STAT)) pred_bfnd->control_parent->entry.Template.cmnt_ptr = p; else last_bfnd->entry.Template.cmnt_ptr = p; } comments = cur_comment = CMNULL; } #line 9884 "gram1.tab.c" /* yacc.c:1646 */ break; case 677: #line 5020 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,HPF_TEMPLATE_STAT, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL); } #line 9890 "gram1.tab.c" /* yacc.c:1646 */ break; case 678: #line 5022 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; if((yyvsp[-2].bf_node)->entry.Template.ll_ptr2) { s = (yyvsp[0].ll_node)->entry.Template.ll_ptr1->entry.Template.symbol; s->attr = s->attr | COMMON_BIT; } add_to_lowLevelList((yyvsp[0].ll_node), (yyvsp[-2].bf_node)->entry.Template.ll_ptr1); } #line 9903 "gram1.tab.c" /* yacc.c:1646 */ break; case 679: #line 5033 "gram1.y" /* yacc.c:1646 */ {PTR_SYMB s; PTR_LLND q; /* 27.06.18 if(! explicit_shape) err("Explicit shape specification is required", 50); */ s = make_array((yyvsp[-1].hash_entry), TYNULL, (yyvsp[0].ll_node), ndim, LOCAL); if(s->attr & TEMPLATE_BIT) errstr( "Multiple declaration of identifier %s ", s->ident, 73); if((s->attr & PROCESSORS_BIT) || (s->attr & TASK_BIT) || (s->attr & DVM_POINTER_BIT)) errstr( "Inconsistent declaration of identifier %s ", s->ident, 16); else s->attr = s->attr | TEMPLATE_BIT; if((yyvsp[0].ll_node)) s->attr = s->attr | DIMENSION_BIT; q = make_llnd(fi,ARRAY_REF, (yyvsp[0].ll_node), LLNULL, s); s->type->entry.ar_decl.ranges = (yyvsp[0].ll_node); (yyval.ll_node) = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL); } #line 9926 "gram1.tab.c" /* yacc.c:1646 */ break; case 680: #line 5054 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,DVM_DYNAMIC_DIR, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL);} #line 9932 "gram1.tab.c" /* yacc.c:1646 */ break; case 681: #line 5058 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); } #line 9938 "gram1.tab.c" /* yacc.c:1646 */ break; case 682: #line 5060 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); } #line 9944 "gram1.tab.c" /* yacc.c:1646 */ break; case 683: #line 5064 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; s = make_array((yyvsp[0].hash_entry), TYNULL, LLNULL, 0, LOCAL); if(s->attr & DYNAMIC_BIT) errstr( "Multiple declaration of identifier %s ", s->ident, 73); if((s->attr & PROCESSORS_BIT) || (s->attr & TASK_BIT) || (s->attr & HEAP_BIT)) errstr("Inconsistent declaration of identifier %s", s->ident, 16); else s->attr = s->attr | DYNAMIC_BIT; (yyval.ll_node) = make_llnd(fi,ARRAY_REF, LLNULL, LLNULL, s); } #line 9959 "gram1.tab.c" /* yacc.c:1646 */ break; case 684: #line 5077 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,DVM_INHERIT_DIR, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL);} #line 9965 "gram1.tab.c" /* yacc.c:1646 */ break; case 685: #line 5081 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); } #line 9971 "gram1.tab.c" /* yacc.c:1646 */ break; case 686: #line 5083 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); } #line 9977 "gram1.tab.c" /* yacc.c:1646 */ break; case 687: #line 5087 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; s = make_array((yyvsp[0].hash_entry), TYNULL, LLNULL, 0, LOCAL); if((s->attr & PROCESSORS_BIT) ||(s->attr & TASK_BIT) || (s->attr & TEMPLATE_BIT) || (s->attr & ALIGN_BIT) || (s->attr & DISTRIBUTE_BIT)) errstr("Inconsistent declaration of identifier %s", s->ident, 16); else s->attr = s->attr | INHERIT_BIT; (yyval.ll_node) = make_llnd(fi,ARRAY_REF, LLNULL, LLNULL, s); } #line 9990 "gram1.tab.c" /* yacc.c:1646 */ break; case 688: #line 5098 "gram1.y" /* yacc.c:1646 */ { PTR_LLND q; q = set_ll_list((yyvsp[-1].ll_node),LLNULL,EXPR_LIST); /* (void)fprintf(stderr,"hpf.gram: shadow\n");*/ (yyval.bf_node) = get_bfnd(fi,DVM_SHADOW_DIR,SMNULL,q,(yyvsp[0].ll_node),LLNULL); } #line 10000 "gram1.tab.c" /* yacc.c:1646 */ break; case 689: #line 5109 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[-1].ll_node);} #line 10006 "gram1.tab.c" /* yacc.c:1646 */ break; case 690: #line 5113 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); } #line 10012 "gram1.tab.c" /* yacc.c:1646 */ break; case 691: #line 5115 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); } #line 10018 "gram1.tab.c" /* yacc.c:1646 */ break; case 692: #line 5119 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node);} #line 10024 "gram1.tab.c" /* yacc.c:1646 */ break; case 693: #line 5121 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,DDOT, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), SMNULL);} #line 10030 "gram1.tab.c" /* yacc.c:1646 */ break; case 694: #line 5123 "gram1.y" /* yacc.c:1646 */ { if(parstate!=INEXEC) err("Illegal shadow width specification", 56); (yyval.ll_node) = make_llnd(fi,SHADOW_NAMES_OP, (yyvsp[-1].ll_node), LLNULL, SMNULL); } #line 10040 "gram1.tab.c" /* yacc.c:1646 */ break; case 695: #line 5138 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; s = make_array((yyvsp[0].hash_entry), TYNULL, LLNULL, 0, LOCAL); if(s->attr & SHADOW_BIT) errstr( "Multiple declaration of identifier %s ", s->ident, 73); if((s->attr & PROCESSORS_BIT) ||(s->attr & TASK_BIT) || (s->attr & TEMPLATE_BIT) || (s->attr & HEAP_BIT)) errstr( "Inconsistent declaration of identifier %s", s->ident, 16); else s->attr = s->attr | SHADOW_BIT; (yyval.ll_node) = make_llnd(fi,ARRAY_REF, LLNULL, LLNULL, s); } #line 10055 "gram1.tab.c" /* yacc.c:1646 */ break; case 696: #line 5150 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; PTR_LLND q, r; if(! explicit_shape) { err("Explicit shape specification is required", 50); /* $$ = BFNULL;*/ } s = make_array((yyvsp[-1].hash_entry), TYNULL, (yyvsp[0].ll_node), ndim, LOCAL); if(s->attr & PROCESSORS_BIT) errstr( "Multiple declaration of identifier %s ", s->ident, 73); if((s->attr & ALIGN_BIT) ||(s->attr & DISTRIBUTE_BIT) ||(s->attr & TEMPLATE_BIT) || (s->attr & DYNAMIC_BIT) ||(s->attr & SHADOW_BIT) || (s->attr & TASK_BIT) || (s->attr & DVM_POINTER_BIT) || (s->attr & INHERIT_BIT)) errstr("Inconsistent declaration of identifier %s", s->ident, 16); else s->attr = s->attr | PROCESSORS_BIT; if((yyvsp[0].ll_node)) s->attr = s->attr | DIMENSION_BIT; q = make_llnd(fi,ARRAY_REF, (yyvsp[0].ll_node), LLNULL, s); s->type->entry.ar_decl.ranges = (yyvsp[0].ll_node); r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL); (yyval.bf_node) = get_bfnd(fi,HPF_PROCESSORS_STAT, SMNULL, r, LLNULL, LLNULL); } #line 10079 "gram1.tab.c" /* yacc.c:1646 */ break; case 697: #line 5170 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; PTR_LLND q, r; if(! explicit_shape) { err("Explicit shape specification is required", 50); /* $$ = BFNULL;*/ } s = make_array((yyvsp[-1].hash_entry), TYNULL, (yyvsp[0].ll_node), ndim, LOCAL); if(s->attr & PROCESSORS_BIT) errstr( "Multiple declaration of identifier %s ", s->ident, 73); if((s->attr & ALIGN_BIT) ||(s->attr & DISTRIBUTE_BIT) ||(s->attr & TEMPLATE_BIT) || (s->attr & DYNAMIC_BIT) ||(s->attr & SHADOW_BIT) || (s->attr & TASK_BIT) || (s->attr & DVM_POINTER_BIT) || (s->attr & INHERIT_BIT)) errstr("Inconsistent declaration of identifier %s", s->ident, 16); else s->attr = s->attr | PROCESSORS_BIT; if((yyvsp[0].ll_node)) s->attr = s->attr | DIMENSION_BIT; q = make_llnd(fi,ARRAY_REF, (yyvsp[0].ll_node), LLNULL, s); s->type->entry.ar_decl.ranges = (yyvsp[0].ll_node); r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL); (yyval.bf_node) = get_bfnd(fi,HPF_PROCESSORS_STAT, SMNULL, r, LLNULL, LLNULL); } #line 10103 "gram1.tab.c" /* yacc.c:1646 */ break; case 698: #line 5190 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; PTR_LLND q, r; if(! explicit_shape) { err("Explicit shape specification is required", 50); /*$$ = BFNULL;*/ } s = make_array((yyvsp[-1].hash_entry), TYNULL, (yyvsp[0].ll_node), ndim, LOCAL); if(s->attr & PROCESSORS_BIT) errstr( "Multiple declaration of identifier %s ", s->ident, 73); if((s->attr & ALIGN_BIT) ||(s->attr & DISTRIBUTE_BIT) ||(s->attr & TEMPLATE_BIT) || (s->attr & DYNAMIC_BIT) ||(s->attr & SHADOW_BIT) || (s->attr & TASK_BIT) || (s->attr & DVM_POINTER_BIT) || (s->attr & INHERIT_BIT) ) errstr("Inconsistent declaration of identifier %s", s->ident, 16); else s->attr = s->attr | PROCESSORS_BIT; if((yyvsp[0].ll_node)) s->attr = s->attr | DIMENSION_BIT; q = make_llnd(fi,ARRAY_REF, (yyvsp[0].ll_node), LLNULL, s); s->type->entry.ar_decl.ranges = (yyvsp[0].ll_node); r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL); add_to_lowLevelList(r, (yyvsp[-3].bf_node)->entry.Template.ll_ptr1); } #line 10127 "gram1.tab.c" /* yacc.c:1646 */ break; case 699: #line 5212 "gram1.y" /* yacc.c:1646 */ { PTR_LLND q,r; q = make_llnd(fi,VAR_REF, LLNULL, LLNULL, (yyvsp[0].symbol)); r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL); (yyval.bf_node) = get_bfnd(fi,DVM_INDIRECT_GROUP_DIR, SMNULL, r, LLNULL, LLNULL); } #line 10137 "gram1.tab.c" /* yacc.c:1646 */ break; case 700: #line 5218 "gram1.y" /* yacc.c:1646 */ { PTR_LLND q,r; q = make_llnd(fi,VAR_REF, LLNULL, LLNULL, (yyvsp[0].symbol)); r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL); add_to_lowLevelList(r, (yyvsp[-2].bf_node)->entry.Template.ll_ptr1); ; } #line 10148 "gram1.tab.c" /* yacc.c:1646 */ break; case 701: #line 5227 "gram1.y" /* yacc.c:1646 */ {(yyval.symbol) = make_local_entity((yyvsp[0].hash_entry), REF_GROUP_NAME,global_default,LOCAL); if((yyval.symbol)->attr & INDIRECT_BIT) errstr( "Multiple declaration of identifier %s ", (yyval.symbol)->ident, 73); (yyval.symbol)->attr = (yyval.symbol)->attr | INDIRECT_BIT; } #line 10158 "gram1.tab.c" /* yacc.c:1646 */ break; case 702: #line 5235 "gram1.y" /* yacc.c:1646 */ { PTR_LLND q,r; q = make_llnd(fi,VAR_REF, LLNULL, LLNULL, (yyvsp[0].symbol)); r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL); (yyval.bf_node) = get_bfnd(fi,DVM_REMOTE_GROUP_DIR, SMNULL, r, LLNULL, LLNULL); } #line 10168 "gram1.tab.c" /* yacc.c:1646 */ break; case 703: #line 5241 "gram1.y" /* yacc.c:1646 */ { PTR_LLND q,r; q = make_llnd(fi,VAR_REF, LLNULL, LLNULL, (yyvsp[0].symbol)); r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL); add_to_lowLevelList(r, (yyvsp[-2].bf_node)->entry.Template.ll_ptr1); } #line 10178 "gram1.tab.c" /* yacc.c:1646 */ break; case 704: #line 5249 "gram1.y" /* yacc.c:1646 */ {(yyval.symbol) = make_local_entity((yyvsp[0].hash_entry), REF_GROUP_NAME,global_default,LOCAL); if((yyval.symbol)->attr & INDIRECT_BIT) errstr( "Inconsistent declaration of identifier %s ", (yyval.symbol)->ident, 16); } #line 10187 "gram1.tab.c" /* yacc.c:1646 */ break; case 705: #line 5256 "gram1.y" /* yacc.c:1646 */ { PTR_LLND q,r; q = make_llnd(fi,VAR_REF, LLNULL, LLNULL, (yyvsp[0].symbol)); r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL); (yyval.bf_node) = get_bfnd(fi,DVM_REDUCTION_GROUP_DIR, SMNULL, r, LLNULL, LLNULL); } #line 10197 "gram1.tab.c" /* yacc.c:1646 */ break; case 706: #line 5262 "gram1.y" /* yacc.c:1646 */ { PTR_LLND q,r; q = make_llnd(fi,VAR_REF, LLNULL, LLNULL, (yyvsp[0].symbol)); r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL); add_to_lowLevelList(r, (yyvsp[-2].bf_node)->entry.Template.ll_ptr1); ; } #line 10208 "gram1.tab.c" /* yacc.c:1646 */ break; case 707: #line 5271 "gram1.y" /* yacc.c:1646 */ {(yyval.symbol) = make_local_entity((yyvsp[0].hash_entry), REDUCTION_GROUP_NAME,global_default,LOCAL);} #line 10214 "gram1.tab.c" /* yacc.c:1646 */ break; case 708: #line 5275 "gram1.y" /* yacc.c:1646 */ { PTR_LLND q,r; q = make_llnd(fi,VAR_REF, LLNULL, LLNULL, (yyvsp[0].symbol)); r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL); (yyval.bf_node) = get_bfnd(fi,DVM_CONSISTENT_GROUP_DIR, SMNULL, r, LLNULL, LLNULL); } #line 10224 "gram1.tab.c" /* yacc.c:1646 */ break; case 709: #line 5281 "gram1.y" /* yacc.c:1646 */ { PTR_LLND q,r; q = make_llnd(fi,VAR_REF, LLNULL, LLNULL, (yyvsp[0].symbol)); r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL); add_to_lowLevelList(r, (yyvsp[-2].bf_node)->entry.Template.ll_ptr1); } #line 10234 "gram1.tab.c" /* yacc.c:1646 */ break; case 710: #line 5289 "gram1.y" /* yacc.c:1646 */ {(yyval.symbol) = make_local_entity((yyvsp[0].hash_entry), CONSISTENT_GROUP_NAME,global_default,LOCAL);} #line 10240 "gram1.tab.c" /* yacc.c:1646 */ break; case 711: #line 5303 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; if(parstate == INEXEC){ if (!(s = (yyvsp[-1].hash_entry)->id_attr)) { s = make_array((yyvsp[-1].hash_entry), TYNULL, LLNULL, 0, LOCAL); s->decl = SOFT; } } else s = make_array((yyvsp[-1].hash_entry), TYNULL, LLNULL, 0, LOCAL); (yyval.ll_node) = make_llnd(fi,ARRAY_REF, (yyvsp[0].ll_node), LLNULL, s); } #line 10257 "gram1.tab.c" /* yacc.c:1646 */ break; case 712: #line 5316 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = LLNULL; opt_kwd_ = NO;} #line 10263 "gram1.tab.c" /* yacc.c:1646 */ break; case 713: #line 5322 "gram1.y" /* yacc.c:1646 */ { PTR_LLND q; if(!(yyvsp[-1].ll_node)) err("Distribution format list is omitted", 51); /* if($6) err("NEW_VALUE specification in DISTRIBUTE directive");*/ q = set_ll_list((yyvsp[-2].ll_node),LLNULL,EXPR_LIST); (yyval.bf_node) = get_bfnd(fi,DVM_DISTRIBUTE_DIR,SMNULL,q,(yyvsp[-1].ll_node),(yyvsp[0].ll_node)); } #line 10276 "gram1.tab.c" /* yacc.c:1646 */ break; case 714: #line 5338 "gram1.y" /* yacc.c:1646 */ { PTR_LLND q; /* if(!$4) {err("Distribution format is omitted", 51); errcnt--;} */ q = set_ll_list((yyvsp[-3].ll_node),LLNULL,EXPR_LIST); /* r = LLNULL; if($6){ r = set_ll_list($6,LLNULL,EXPR_LIST); if($7) r = set_ll_list(r,$7,EXPR_LIST); } else if($7) r = set_ll_list(r,$7,EXPR_LIST); */ (yyval.bf_node) = get_bfnd(fi,DVM_REDISTRIBUTE_DIR,SMNULL,q,(yyvsp[-2].ll_node),(yyvsp[0].ll_node));} #line 10294 "gram1.tab.c" /* yacc.c:1646 */ break; case 715: #line 5353 "gram1.y" /* yacc.c:1646 */ { /* r = LLNULL; if($5){ r = set_ll_list($5,LLNULL,EXPR_LIST); if($6) r = set_ll_list(r,$6,EXPR_LIST); } else if($6) r = set_ll_list(r,$6,EXPR_LIST); */ (yyval.bf_node) = get_bfnd(fi,DVM_REDISTRIBUTE_DIR,SMNULL,(yyvsp[0].ll_node) ,(yyvsp[-5].ll_node),(yyvsp[-3].ll_node) ); } #line 10309 "gram1.tab.c" /* yacc.c:1646 */ break; case 716: #line 5381 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); } #line 10315 "gram1.tab.c" /* yacc.c:1646 */ break; case 717: #line 5383 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); } #line 10321 "gram1.tab.c" /* yacc.c:1646 */ break; case 718: #line 5387 "gram1.y" /* yacc.c:1646 */ {(yyval.ll_node) = (yyvsp[0].ll_node);} #line 10327 "gram1.tab.c" /* yacc.c:1646 */ break; case 719: #line 5389 "gram1.y" /* yacc.c:1646 */ {(yyval.ll_node) = (yyvsp[0].ll_node);} #line 10333 "gram1.tab.c" /* yacc.c:1646 */ break; case 720: #line 5393 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; if(parstate == INEXEC){ if (!(s = (yyvsp[0].hash_entry)->id_attr)) { s = make_array((yyvsp[0].hash_entry), TYNULL, LLNULL, 0, LOCAL); s->decl = SOFT; } if(s->attr & PROCESSORS_BIT) errstr( "Illegal use of PROCESSORS name %s ", s->ident, 53); if(s->attr & TASK_BIT) errstr( "Illegal use of task array name %s ", s->ident, 71); } else { s = make_array((yyvsp[0].hash_entry), TYNULL, LLNULL, 0, LOCAL); if(s->attr & DISTRIBUTE_BIT) errstr( "Multiple declaration of identifier %s ", s->ident, 73); else if( (s->attr & PROCESSORS_BIT) || (s->attr & TASK_BIT) || (s->attr & INHERIT_BIT)) errstr("Inconsistent declaration of identifier %s",s->ident, 16); else s->attr = s->attr | DISTRIBUTE_BIT; } if(s->attr & ALIGN_BIT) errstr("A distributee may not have the ALIGN attribute:%s",s->ident, 54); (yyval.ll_node) = make_llnd(fi,ARRAY_REF, LLNULL, LLNULL, s); } #line 10364 "gram1.tab.c" /* yacc.c:1646 */ break; case 721: #line 5422 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; s = make_array((yyvsp[-3].hash_entry), TYNULL, LLNULL, 0, LOCAL); if(parstate != INEXEC) errstr( "Illegal distributee:%s", s->ident, 312); else { if(s->attr & PROCESSORS_BIT) errstr( "Illegal use of PROCESSORS name %s ", s->ident, 53); if(s->attr & TASK_BIT) errstr( "Illegal use of task array name %s ", s->ident, 71); if(s->attr & ALIGN_BIT) errstr("A distributee may not have the ALIGN attribute:%s",s->ident, 54); if(!(s->attr & DVM_POINTER_BIT)) errstr("Illegal distributee:%s", s->ident, 312); /*s->attr = s->attr | DISTRIBUTE_BIT;*/ (yyval.ll_node) = make_llnd(fi,ARRAY_REF, (yyvsp[-1].ll_node), LLNULL, s); } } #line 10388 "gram1.tab.c" /* yacc.c:1646 */ break; case 722: #line 5445 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; if((s=(yyvsp[0].hash_entry)->id_attr) == SMNULL) s = make_array((yyvsp[0].hash_entry), TYNULL, LLNULL, 0, LOCAL); if((parstate == INEXEC) && !(s->attr & PROCESSORS_BIT)) errstr( "'%s' is not processor array ", s->ident, 67); (yyval.symbol) = s; } #line 10400 "gram1.tab.c" /* yacc.c:1646 */ break; case 723: #line 5465 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = LLNULL; } #line 10406 "gram1.tab.c" /* yacc.c:1646 */ break; case 724: #line 5467 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[-1].ll_node);} #line 10412 "gram1.tab.c" /* yacc.c:1646 */ break; case 725: #line 5471 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[-1].ll_node);} #line 10418 "gram1.tab.c" /* yacc.c:1646 */ break; case 726: #line 5492 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); } #line 10424 "gram1.tab.c" /* yacc.c:1646 */ break; case 727: #line 5494 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-3].ll_node),(yyvsp[0].ll_node),EXPR_LIST); } #line 10430 "gram1.tab.c" /* yacc.c:1646 */ break; case 728: #line 5497 "gram1.y" /* yacc.c:1646 */ { opt_kwd_ = YES; } #line 10436 "gram1.tab.c" /* yacc.c:1646 */ break; case 729: #line 5506 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,BLOCK_OP, LLNULL, LLNULL, SMNULL); } #line 10444 "gram1.tab.c" /* yacc.c:1646 */ break; case 730: #line 5510 "gram1.y" /* yacc.c:1646 */ { err("Distribution format BLOCK(n) is not permitted in FDVM", 55); (yyval.ll_node) = make_llnd(fi,BLOCK_OP, (yyvsp[-1].ll_node), LLNULL, SMNULL); endioctl(); } #line 10453 "gram1.tab.c" /* yacc.c:1646 */ break; case 731: #line 5515 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,BLOCK_OP, LLNULL, LLNULL, (yyvsp[-1].symbol)); } #line 10459 "gram1.tab.c" /* yacc.c:1646 */ break; case 732: #line 5517 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,BLOCK_OP, (yyvsp[-1].ll_node), LLNULL, (yyvsp[-3].symbol)); } #line 10465 "gram1.tab.c" /* yacc.c:1646 */ break; case 733: #line 5519 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,BLOCK_OP, LLNULL, (yyvsp[-1].ll_node), SMNULL); } #line 10471 "gram1.tab.c" /* yacc.c:1646 */ break; case 734: #line 5521 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,KEYWORD_VAL, LLNULL, LLNULL, SMNULL); (yyval.ll_node)->entry.string_val = (char *) "*"; (yyval.ll_node)->type = global_string; } #line 10481 "gram1.tab.c" /* yacc.c:1646 */ break; case 735: #line 5527 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,INDIRECT_OP, LLNULL, LLNULL, (yyvsp[-1].symbol)); } #line 10487 "gram1.tab.c" /* yacc.c:1646 */ break; case 736: #line 5529 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,INDIRECT_OP, (yyvsp[-1].ll_node), LLNULL, SMNULL); } #line 10493 "gram1.tab.c" /* yacc.c:1646 */ break; case 737: #line 5533 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; s = make_array((yyvsp[0].hash_entry), TYNULL, LLNULL, 0, LOCAL); if((s->attr & PROCESSORS_BIT) ||(s->attr & TASK_BIT) || (s->attr & TEMPLATE_BIT)) errstr("Inconsistent declaration of identifier %s", s->ident, 16); (yyval.symbol) = s; } #line 10505 "gram1.tab.c" /* yacc.c:1646 */ break; case 738: #line 5543 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,DERIVED_OP, (yyvsp[-4].ll_node), (yyvsp[0].ll_node), SMNULL); } #line 10511 "gram1.tab.c" /* yacc.c:1646 */ break; case 739: #line 5547 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); } #line 10517 "gram1.tab.c" /* yacc.c:1646 */ break; case 740: #line 5549 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); } #line 10523 "gram1.tab.c" /* yacc.c:1646 */ break; case 741: #line 5554 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node);} #line 10529 "gram1.tab.c" /* yacc.c:1646 */ break; case 742: #line 5556 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,DDOT, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), SMNULL);} #line 10535 "gram1.tab.c" /* yacc.c:1646 */ break; case 743: #line 5560 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,ARRAY_REF, LLNULL, LLNULL, (yyvsp[0].symbol)); } #line 10543 "gram1.tab.c" /* yacc.c:1646 */ break; case 744: #line 5564 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,ARRAY_REF, (yyvsp[-1].ll_node), LLNULL, (yyvsp[-3].symbol)); } #line 10551 "gram1.tab.c" /* yacc.c:1646 */ break; case 745: #line 5570 "gram1.y" /* yacc.c:1646 */ { if (!((yyval.symbol) = (yyvsp[0].hash_entry)->id_attr)) { (yyval.symbol) = make_array((yyvsp[0].hash_entry), TYNULL, LLNULL,0,LOCAL); (yyval.symbol)->decl = SOFT; } } #line 10563 "gram1.tab.c" /* yacc.c:1646 */ break; case 746: #line 5580 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); } #line 10569 "gram1.tab.c" /* yacc.c:1646 */ break; case 747: #line 5582 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); } #line 10575 "gram1.tab.c" /* yacc.c:1646 */ break; case 748: #line 5586 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node);} #line 10581 "gram1.tab.c" /* yacc.c:1646 */ break; case 749: #line 5588 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node);} #line 10587 "gram1.tab.c" /* yacc.c:1646 */ break; case 750: #line 5590 "gram1.y" /* yacc.c:1646 */ { (yyvsp[-1].ll_node)->entry.Template.ll_ptr1 = (yyvsp[0].ll_node); (yyval.ll_node) = (yyvsp[-1].ll_node); } #line 10596 "gram1.tab.c" /* yacc.c:1646 */ break; case 751: #line 5597 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; s = make_scalar((yyvsp[0].hash_entry),TYNULL,LOCAL); (yyval.ll_node) = make_llnd(fi,DUMMY_REF, LLNULL, LLNULL, s); /*$$->type = global_int;*/ } #line 10606 "gram1.tab.c" /* yacc.c:1646 */ break; case 752: #line 5614 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = LLNULL; } #line 10612 "gram1.tab.c" /* yacc.c:1646 */ break; case 753: #line 5616 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node); } #line 10618 "gram1.tab.c" /* yacc.c:1646 */ break; case 754: #line 5620 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); } #line 10624 "gram1.tab.c" /* yacc.c:1646 */ break; case 755: #line 5622 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); } #line 10630 "gram1.tab.c" /* yacc.c:1646 */ break; case 756: #line 5626 "gram1.y" /* yacc.c:1646 */ { if((yyvsp[0].ll_node)->type->variant != T_STRING) errstr( "Illegal type of shadow_name", 627); (yyval.ll_node) = (yyvsp[0].ll_node); } #line 10639 "gram1.tab.c" /* yacc.c:1646 */ break; case 757: #line 5633 "gram1.y" /* yacc.c:1646 */ { char *q; nioctl = 1; q = (yyvsp[-1].ll_node)->entry.string_val; if((!strcmp(q,"shadow")) && ((yyvsp[0].ll_node)->variant == INT_VAL)) (yyval.ll_node) = make_llnd(fi,SPEC_PAIR, (yyvsp[-1].ll_node), (yyvsp[0].ll_node), SMNULL); else { err("Illegal shadow width specification", 56); (yyval.ll_node) = LLNULL; } } #line 10653 "gram1.tab.c" /* yacc.c:1646 */ break; case 758: #line 5643 "gram1.y" /* yacc.c:1646 */ { char *ql, *qh; PTR_LLND p1, p2; nioctl = 2; ql = (yyvsp[-4].ll_node)->entry.string_val; qh = (yyvsp[-1].ll_node)->entry.string_val; if((!strcmp(ql,"low_shadow")) && ((yyvsp[-3].ll_node)->variant == INT_VAL) && (!strcmp(qh,"high_shadow")) && ((yyvsp[0].ll_node)->variant == INT_VAL)) { p1 = make_llnd(fi,SPEC_PAIR, (yyvsp[-4].ll_node), (yyvsp[-3].ll_node), SMNULL); p2 = make_llnd(fi,SPEC_PAIR, (yyvsp[-1].ll_node), (yyvsp[0].ll_node), SMNULL); (yyval.ll_node) = make_llnd(fi,CONS, p1, p2, SMNULL); } else { err("Illegal shadow width specification", 56); (yyval.ll_node) = LLNULL; } } #line 10674 "gram1.tab.c" /* yacc.c:1646 */ break; case 759: #line 5672 "gram1.y" /* yacc.c:1646 */ { PTR_LLND q; q = set_ll_list((yyvsp[-1].ll_node),LLNULL,EXPR_LIST); (yyval.bf_node) = (yyvsp[0].bf_node); (yyval.bf_node)->entry.Template.ll_ptr1 = q; } #line 10684 "gram1.tab.c" /* yacc.c:1646 */ break; case 760: #line 5687 "gram1.y" /* yacc.c:1646 */ { PTR_LLND q; q = set_ll_list((yyvsp[-1].ll_node),LLNULL,EXPR_LIST); (yyval.bf_node) = (yyvsp[0].bf_node); (yyval.bf_node)->variant = DVM_REALIGN_DIR; (yyval.bf_node)->entry.Template.ll_ptr1 = q; } #line 10695 "gram1.tab.c" /* yacc.c:1646 */ break; case 761: #line 5694 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = (yyvsp[-3].bf_node); (yyval.bf_node)->variant = DVM_REALIGN_DIR; (yyval.bf_node)->entry.Template.ll_ptr1 = (yyvsp[0].ll_node); } #line 10705 "gram1.tab.c" /* yacc.c:1646 */ break; case 762: #line 5712 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); } #line 10711 "gram1.tab.c" /* yacc.c:1646 */ break; case 763: #line 5714 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); } #line 10717 "gram1.tab.c" /* yacc.c:1646 */ break; case 764: #line 5718 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; s = make_array((yyvsp[0].hash_entry), TYNULL, LLNULL, 0, LOCAL); if((s->attr & ALIGN_BIT)) errstr( "Multiple declaration of identifier %s ", s->ident, 73); if((s->attr & PROCESSORS_BIT) || (s->attr & TASK_BIT) || (s->attr & INHERIT_BIT)) errstr( "Inconsistent declaration of identifier %s", s->ident, 16); else if(s->attr & DISTRIBUTE_BIT) errstr( "An alignee may not have the DISTRIBUTE attribute:'%s'", s->ident,57); else s->attr = s->attr | ALIGN_BIT; (yyval.ll_node) = make_llnd(fi,ARRAY_REF, LLNULL, LLNULL, s); } #line 10733 "gram1.tab.c" /* yacc.c:1646 */ break; case 765: #line 5732 "gram1.y" /* yacc.c:1646 */ {PTR_SYMB s; s = (yyvsp[0].ll_node)->entry.Template.symbol; if(s->attr & PROCESSORS_BIT) errstr( "Illegal use of PROCESSORS name %s ", s->ident, 53); else if(s->attr & TASK_BIT) errstr( "Illegal use of task array name %s ", s->ident, 71); else if( !(s->attr & DIMENSION_BIT) && !(s->attr & DVM_POINTER_BIT)) errstr("The alignee %s isn't an array", s->ident, 58); else { /* if(!(s->attr & DYNAMIC_BIT)) errstr("'%s' hasn't the DYNAMIC attribute", s->ident, 59); */ if(!(s->attr & ALIGN_BIT) && !(s->attr & INHERIT_BIT)) errstr("'%s' hasn't the ALIGN attribute", s->ident, 60); if(s->attr & DISTRIBUTE_BIT) errstr("An alignee may not have the DISTRIBUTE attribute: %s", s->ident, 57); /* if(s->entry.var_decl.local == IO) * errstr("An alignee may not be the dummy argument"); */ } (yyval.ll_node) = make_llnd(fi,ARRAY_REF, LLNULL, LLNULL, s); } #line 10761 "gram1.tab.c" /* yacc.c:1646 */ break; case 766: #line 5758 "gram1.y" /* yacc.c:1646 */ { /* PTR_LLND r; if($7) { r = set_ll_list($6,LLNULL,EXPR_LIST); r = set_ll_list(r,$7,EXPR_LIST); } else r = $6; */ (yyval.bf_node) = get_bfnd(fi,DVM_ALIGN_DIR,SMNULL,LLNULL,(yyvsp[-4].ll_node),(yyvsp[0].ll_node)); } #line 10776 "gram1.tab.c" /* yacc.c:1646 */ break; case 767: #line 5771 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,ARRAY_REF, (yyvsp[-1].ll_node), LLNULL, (yyvsp[-3].symbol)); } #line 10784 "gram1.tab.c" /* yacc.c:1646 */ break; case 768: #line 5787 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); } #line 10790 "gram1.tab.c" /* yacc.c:1646 */ break; case 769: #line 5789 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); } #line 10796 "gram1.tab.c" /* yacc.c:1646 */ break; case 770: #line 5792 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node);} #line 10802 "gram1.tab.c" /* yacc.c:1646 */ break; case 771: #line 5794 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,KEYWORD_VAL, LLNULL, LLNULL, SMNULL); (yyval.ll_node)->entry.string_val = (char *) "*"; (yyval.ll_node)->type = global_string; } #line 10812 "gram1.tab.c" /* yacc.c:1646 */ break; case 772: #line 5800 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node);} #line 10818 "gram1.tab.c" /* yacc.c:1646 */ break; case 773: #line 5804 "gram1.y" /* yacc.c:1646 */ { /* if(parstate == INEXEC){ *for REALIGN directive* if (!($$ = $1->id_attr)) { $$ = make_array($1, TYNULL, LLNULL,0,LOCAL); $$->decl = SOFT; } } else $$ = make_array($1, TYNULL, LLNULL, 0, LOCAL); */ if (!((yyval.symbol) = (yyvsp[0].hash_entry)->id_attr)) { (yyval.symbol) = make_array((yyvsp[0].hash_entry), TYNULL, LLNULL,0,LOCAL); (yyval.symbol)->decl = SOFT; } (yyval.symbol)->attr = (yyval.symbol)->attr | ALIGN_BASE_BIT; if((yyval.symbol)->attr & PROCESSORS_BIT) errstr( "Illegal use of PROCESSORS name %s ", (yyval.symbol)->ident, 53); else if((yyval.symbol)->attr & TASK_BIT) errstr( "Illegal use of task array name %s ", (yyval.symbol)->ident, 71); else if((parstate == INEXEC) /* for REALIGN directive */ && !((yyval.symbol)->attr & DIMENSION_BIT) && !((yyval.symbol)->attr & DVM_POINTER_BIT)) errstr("The align-target %s isn't declared as array", (yyval.symbol)->ident, 61); } #line 10848 "gram1.tab.c" /* yacc.c:1646 */ break; case 774: #line 5832 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); } #line 10854 "gram1.tab.c" /* yacc.c:1646 */ break; case 775: #line 5834 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); } #line 10860 "gram1.tab.c" /* yacc.c:1646 */ break; case 776: #line 5838 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; s = make_scalar((yyvsp[0].hash_entry),TYNULL,LOCAL); if(s->type->variant != T_INT || s->attr & PARAMETER_BIT) errstr("The align-dummy %s isn't a scalar integer variable", s->ident, 62); (yyval.ll_node) = make_llnd(fi,VAR_REF, LLNULL, LLNULL, s); (yyval.ll_node)->type = global_int; } #line 10872 "gram1.tab.c" /* yacc.c:1646 */ break; case 777: #line 5846 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,KEYWORD_VAL, LLNULL, LLNULL, SMNULL); (yyval.ll_node)->entry.string_val = (char *) "*"; (yyval.ll_node)->type = global_string; } #line 10882 "gram1.tab.c" /* yacc.c:1646 */ break; case 778: #line 5852 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,DDOT, LLNULL, LLNULL, SMNULL); } #line 10888 "gram1.tab.c" /* yacc.c:1646 */ break; case 779: #line 5855 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; PTR_LLND q, r, p; int numdim; if(type_options & PROCESSORS_BIT) { /* 27.06.18 || (type_options & TEMPLATE_BIT)){ */ if(! explicit_shape) { err("Explicit shape specification is required", 50); /*$$ = BFNULL;*/ } } /* else { if($6) err("Shape specification is not permitted", 263); } */ if(type_options & DIMENSION_BIT) { p = attr_dims; numdim = attr_ndim;} else { p = LLNULL; numdim = 0; } if((yyvsp[0].ll_node)) /*dimension information after the object name*/ { p = (yyvsp[0].ll_node); numdim = ndim;} /*overrides the DIMENSION attribute */ s = make_array((yyvsp[-1].hash_entry), TYNULL, p, numdim, LOCAL); if((type_options & COMMON_BIT) && !(type_options & TEMPLATE_BIT)) { err("Illegal combination of attributes", 63); type_options = type_options & (~COMMON_BIT); } if((type_options & PROCESSORS_BIT) &&((type_options & ALIGN_BIT) ||(type_options & DISTRIBUTE_BIT) ||(type_options & TEMPLATE_BIT) || (type_options & DYNAMIC_BIT) ||(type_options & SHADOW_BIT) )) err("Illegal combination of attributes", 63); else if((type_options & PROCESSORS_BIT) && ((s->attr & ALIGN_BIT) ||(s->attr & DISTRIBUTE_BIT) ||(s->attr & TEMPLATE_BIT) || (s->attr & DYNAMIC_BIT) ||(s->attr & SHADOW_BIT)) ) { errstr("Inconsistent declaration of %s", s->ident, 16); type_options = type_options & (~PROCESSORS_BIT); } else if ((s->attr & PROCESSORS_BIT) && ((type_options & ALIGN_BIT) ||(type_options & DISTRIBUTE_BIT) ||(type_options & TEMPLATE_BIT) || (type_options & DYNAMIC_BIT) ||(type_options & SHADOW_BIT))) errstr("Inconsistent declaration of %s", s->ident, 16); else if ((s->attr & INHERIT_BIT) && ((type_options & ALIGN_BIT) ||(type_options & DISTRIBUTE_BIT))) errstr("Inconsistent declaration of %s", s->ident, 16); if(( s->attr & DISTRIBUTE_BIT) && (type_options & DISTRIBUTE_BIT)) errstr( "Multiple declaration of identifier %s ", s->ident, 73); if(( s->attr & ALIGN_BIT) && (type_options & ALIGN_BIT)) errstr( "Multiple declaration of identifier %s ", s->ident, 73); if(( s->attr & SHADOW_BIT) && (type_options & SHADOW_BIT)) errstr( "Multiple declaration of identifier %s ", s->ident, 73); if(( s->attr & TEMPLATE_BIT) && (type_options & TEMPLATE_BIT)) errstr( "Multiple declaration of identifier %s ", s->ident, 73); if(( s->attr & PROCESSORS_BIT) && (type_options & PROCESSORS_BIT)) errstr( "Multiple declaration of identifier %s ", s->ident, 73); s->attr = s->attr | type_options; if((yyvsp[0].ll_node)) s->attr = s->attr | DIMENSION_BIT; if((s->attr & DISTRIBUTE_BIT) && (s->attr & ALIGN_BIT)) errstr("%s has the DISTRIBUTE and ALIGN attribute",s->ident, 64); q = make_llnd(fi,ARRAY_REF, (yyvsp[0].ll_node), LLNULL, s); if(p) s->type->entry.ar_decl.ranges = p; r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL); (yyval.bf_node) = get_bfnd(fi,DVM_VAR_DECL, SMNULL, r, LLNULL,(yyvsp[-5].ll_node)); } #line 10950 "gram1.tab.c" /* yacc.c:1646 */ break; case 780: #line 5913 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; PTR_LLND q, r, p; int numdim; if(type_options & PROCESSORS_BIT) { /*23.10.18 || (type_options & TEMPLATE_BIT)){ */ if(! explicit_shape) { err("Explicit shape specification is required", 50); /*$$ = BFNULL;*/ } } /* else { if($4) err("Shape specification is not permitted", 263); } */ if(type_options & DIMENSION_BIT) { p = attr_dims; numdim = attr_ndim;} else { p = LLNULL; numdim = 0; } if((yyvsp[0].ll_node)) /*dimension information after the object name*/ { p = (yyvsp[0].ll_node); numdim = ndim;}/*overrides the DIMENSION attribute */ s = make_array((yyvsp[-1].hash_entry), TYNULL, p, numdim, LOCAL); if((type_options & COMMON_BIT) && !(type_options & TEMPLATE_BIT)) { err("Illegal combination of attributes", 63); type_options = type_options & (~COMMON_BIT); } if((type_options & PROCESSORS_BIT) &&((type_options & ALIGN_BIT) ||(type_options & DISTRIBUTE_BIT) ||(type_options & TEMPLATE_BIT) || (type_options & DYNAMIC_BIT) ||(type_options & SHADOW_BIT) )) err("Illegal combination of attributes", 63); else if((type_options & PROCESSORS_BIT) && ((s->attr & ALIGN_BIT) ||(s->attr & DISTRIBUTE_BIT) ||(s->attr & TEMPLATE_BIT) || (s->attr & DYNAMIC_BIT) ||(s->attr & SHADOW_BIT)) ) { errstr("Inconsistent declaration of identifier %s", s->ident, 16); type_options = type_options & (~PROCESSORS_BIT); } else if ((s->attr & PROCESSORS_BIT) && ((type_options & ALIGN_BIT) ||(type_options & DISTRIBUTE_BIT) ||(type_options & TEMPLATE_BIT) || (type_options & DYNAMIC_BIT) ||(type_options & SHADOW_BIT))) errstr("Inconsistent declaration of identifier %s", s->ident,16); else if ((s->attr & INHERIT_BIT) && ((type_options & ALIGN_BIT) ||(type_options & DISTRIBUTE_BIT))) errstr("Inconsistent declaration of identifier %s", s->ident, 16); if(( s->attr & DISTRIBUTE_BIT) && (type_options & DISTRIBUTE_BIT)) errstr( "Multiple declaration of identifier %s ", s->ident, 73); if(( s->attr & ALIGN_BIT) && (type_options & ALIGN_BIT)) errstr( "Multiple declaration of identifier %s ", s->ident, 73); if(( s->attr & SHADOW_BIT) && (type_options & SHADOW_BIT)) errstr( "Multiple declaration of identifier %s ", s->ident, 73); if(( s->attr & TEMPLATE_BIT) && (type_options & TEMPLATE_BIT)) errstr( "Multiple declaration of identifier %s ", s->ident, 73); if(( s->attr & PROCESSORS_BIT) && (type_options & PROCESSORS_BIT)) errstr( "Multiple declaration of identifier %s ", s->ident, 73); s->attr = s->attr | type_options; if((yyvsp[0].ll_node)) s->attr = s->attr | DIMENSION_BIT; if((s->attr & DISTRIBUTE_BIT) && (s->attr & ALIGN_BIT)) errstr("%s has the DISTRIBUTE and ALIGN attribute",s->ident, 64); q = make_llnd(fi,ARRAY_REF, (yyvsp[0].ll_node), LLNULL, s); if(p) s->type->entry.ar_decl.ranges = p; r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL); add_to_lowLevelList(r, (yyvsp[-3].bf_node)->entry.Template.ll_ptr1); } #line 11010 "gram1.tab.c" /* yacc.c:1646 */ break; case 781: #line 5977 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); type_options = type_opt; } #line 11016 "gram1.tab.c" /* yacc.c:1646 */ break; case 782: #line 5979 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-3].ll_node),(yyvsp[0].ll_node),EXPR_LIST); type_options = type_options | type_opt;} #line 11022 "gram1.tab.c" /* yacc.c:1646 */ break; case 783: #line 5982 "gram1.y" /* yacc.c:1646 */ { type_opt = TEMPLATE_BIT; (yyval.ll_node) = make_llnd(fi,TEMPLATE_OP,LLNULL,LLNULL,SMNULL); } #line 11030 "gram1.tab.c" /* yacc.c:1646 */ break; case 784: #line 5986 "gram1.y" /* yacc.c:1646 */ { type_opt = PROCESSORS_BIT; (yyval.ll_node) = make_llnd(fi,PROCESSORS_OP,LLNULL,LLNULL,SMNULL); } #line 11038 "gram1.tab.c" /* yacc.c:1646 */ break; case 785: #line 5990 "gram1.y" /* yacc.c:1646 */ { type_opt = PROCESSORS_BIT; (yyval.ll_node) = make_llnd(fi,PROCESSORS_OP,LLNULL,LLNULL,SMNULL); } #line 11046 "gram1.tab.c" /* yacc.c:1646 */ break; case 786: #line 5994 "gram1.y" /* yacc.c:1646 */ { type_opt = DYNAMIC_BIT; (yyval.ll_node) = make_llnd(fi,DYNAMIC_OP,LLNULL,LLNULL,SMNULL); } #line 11054 "gram1.tab.c" /* yacc.c:1646 */ break; case 787: #line 6011 "gram1.y" /* yacc.c:1646 */ { if(! explicit_shape) { err("Explicit shape specification is required", 50); } if(! (yyvsp[-1].ll_node)) { err("No shape specification", 65); } type_opt = DIMENSION_BIT; attr_ndim = ndim; attr_dims = (yyvsp[-1].ll_node); (yyval.ll_node) = make_llnd(fi,DIMENSION_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL); } #line 11070 "gram1.tab.c" /* yacc.c:1646 */ break; case 788: #line 6023 "gram1.y" /* yacc.c:1646 */ { type_opt = SHADOW_BIT; (yyval.ll_node) = make_llnd(fi,SHADOW_OP,(yyvsp[0].ll_node),LLNULL,SMNULL); } #line 11078 "gram1.tab.c" /* yacc.c:1646 */ break; case 789: #line 6027 "gram1.y" /* yacc.c:1646 */ { type_opt = ALIGN_BIT; (yyval.ll_node) = make_llnd(fi,ALIGN_OP,(yyvsp[-4].ll_node),(yyvsp[0].ll_node),SMNULL); } #line 11086 "gram1.tab.c" /* yacc.c:1646 */ break; case 790: #line 6031 "gram1.y" /* yacc.c:1646 */ { type_opt = ALIGN_BIT; (yyval.ll_node) = make_llnd(fi,ALIGN_OP,LLNULL,SMNULL,SMNULL); } #line 11094 "gram1.tab.c" /* yacc.c:1646 */ break; case 791: #line 6041 "gram1.y" /* yacc.c:1646 */ { type_opt = DISTRIBUTE_BIT; (yyval.ll_node) = make_llnd(fi,DISTRIBUTE_OP,(yyvsp[-2].ll_node),(yyvsp[0].ll_node),SMNULL); } #line 11103 "gram1.tab.c" /* yacc.c:1646 */ break; case 792: #line 6046 "gram1.y" /* yacc.c:1646 */ { type_opt = DISTRIBUTE_BIT; (yyval.ll_node) = make_llnd(fi,DISTRIBUTE_OP,LLNULL,LLNULL,SMNULL); } #line 11112 "gram1.tab.c" /* yacc.c:1646 */ break; case 793: #line 6051 "gram1.y" /* yacc.c:1646 */ { type_opt = COMMON_BIT; (yyval.ll_node) = make_llnd(fi,COMMON_OP, LLNULL, LLNULL, SMNULL); } #line 11121 "gram1.tab.c" /* yacc.c:1646 */ break; case 794: #line 6058 "gram1.y" /* yacc.c:1646 */ { PTR_LLND l; l = make_llnd(fi, TYPE_OP, LLNULL, LLNULL, SMNULL); l->type = (yyvsp[-10].data_type); (yyval.bf_node) = get_bfnd(fi,DVM_POINTER_DIR, SMNULL, (yyvsp[0].ll_node),(yyvsp[-4].ll_node), l); } #line 11132 "gram1.tab.c" /* yacc.c:1646 */ break; case 795: #line 6066 "gram1.y" /* yacc.c:1646 */ {ndim = 0;} #line 11138 "gram1.tab.c" /* yacc.c:1646 */ break; case 796: #line 6067 "gram1.y" /* yacc.c:1646 */ { PTR_LLND q; if(ndim == maxdim) err("Too many dimensions", 43); else if(ndim < maxdim) q = make_llnd(fi,DDOT,LLNULL,LLNULL,SMNULL); ++ndim; (yyval.ll_node) = set_ll_list(q, LLNULL, EXPR_LIST); /*$$ = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);*/ /*$$->type = global_default;*/ } #line 11153 "gram1.tab.c" /* yacc.c:1646 */ break; case 797: #line 6078 "gram1.y" /* yacc.c:1646 */ { PTR_LLND q; if(ndim == maxdim) err("Too many dimensions", 43); else if(ndim < maxdim) q = make_llnd(fi,DDOT,LLNULL,LLNULL,SMNULL); ++ndim; (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), q, EXPR_LIST); } #line 11166 "gram1.tab.c" /* yacc.c:1646 */ break; case 798: #line 6089 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); } #line 11172 "gram1.tab.c" /* yacc.c:1646 */ break; case 799: #line 6091 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); } #line 11178 "gram1.tab.c" /* yacc.c:1646 */ break; case 800: #line 6095 "gram1.y" /* yacc.c:1646 */ {PTR_SYMB s; /* s = make_scalar($1,TYNULL,LOCAL);*/ s = make_array((yyvsp[0].hash_entry),TYNULL,LLNULL,0,LOCAL); s->attr = s->attr | DVM_POINTER_BIT; if((s->attr & PROCESSORS_BIT) || (s->attr & TASK_BIT) || (s->attr & INHERIT_BIT)) errstr( "Inconsistent declaration of identifier %s", s->ident, 16); (yyval.ll_node) = make_llnd(fi,VAR_REF,LLNULL,LLNULL,s); } #line 11191 "gram1.tab.c" /* yacc.c:1646 */ break; case 801: #line 6106 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,DVM_HEAP_DIR, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL);} #line 11197 "gram1.tab.c" /* yacc.c:1646 */ break; case 802: #line 6110 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); } #line 11203 "gram1.tab.c" /* yacc.c:1646 */ break; case 803: #line 6112 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); } #line 11209 "gram1.tab.c" /* yacc.c:1646 */ break; case 804: #line 6116 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; s = make_array((yyvsp[0].hash_entry), TYNULL, LLNULL, 0, LOCAL); s->attr = s->attr | HEAP_BIT; if((s->attr & PROCESSORS_BIT) ||(s->attr & TASK_BIT) || (s->attr & TEMPLATE_BIT) || (s->attr & ALIGN_BIT) || (s->attr & DISTRIBUTE_BIT) || (s->attr & INHERIT_BIT) || (s->attr & DYNAMIC_BIT) || (s->attr & SHADOW_BIT) || (s->attr & DVM_POINTER_BIT)) errstr("Inconsistent declaration of identifier %s", s->ident, 16); (yyval.ll_node) = make_llnd(fi,ARRAY_REF, LLNULL, LLNULL, s); } #line 11222 "gram1.tab.c" /* yacc.c:1646 */ break; case 805: #line 6127 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,DVM_CONSISTENT_DIR, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL);} #line 11228 "gram1.tab.c" /* yacc.c:1646 */ break; case 806: #line 6131 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); } #line 11234 "gram1.tab.c" /* yacc.c:1646 */ break; case 807: #line 6133 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); } #line 11240 "gram1.tab.c" /* yacc.c:1646 */ break; case 808: #line 6137 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; s = make_array((yyvsp[0].hash_entry), TYNULL, LLNULL, 0, LOCAL); s->attr = s->attr | CONSISTENT_BIT; if((s->attr & PROCESSORS_BIT) ||(s->attr & TASK_BIT) || (s->attr & TEMPLATE_BIT) || (s->attr & ALIGN_BIT) || (s->attr & DISTRIBUTE_BIT) || (s->attr & INHERIT_BIT) || (s->attr & DYNAMIC_BIT) || (s->attr & SHADOW_BIT) || (s->attr & DVM_POINTER_BIT)) errstr("Inconsistent declaration of identifier %s", s->ident, 16); (yyval.ll_node) = make_llnd(fi,ARRAY_REF, LLNULL, LLNULL, s); } #line 11253 "gram1.tab.c" /* yacc.c:1646 */ break; case 809: #line 6149 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,DVM_ASYNCID_DIR, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL);} #line 11259 "gram1.tab.c" /* yacc.c:1646 */ break; case 810: #line 6151 "gram1.y" /* yacc.c:1646 */ { PTR_LLND p; p = make_llnd(fi,COMM_LIST, LLNULL, LLNULL, SMNULL); (yyval.bf_node) = get_bfnd(fi,DVM_ASYNCID_DIR, SMNULL, (yyvsp[0].ll_node), p, LLNULL); } #line 11268 "gram1.tab.c" /* yacc.c:1646 */ break; case 811: #line 6158 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); } #line 11274 "gram1.tab.c" /* yacc.c:1646 */ break; case 812: #line 6160 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); } #line 11280 "gram1.tab.c" /* yacc.c:1646 */ break; case 813: #line 6164 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; if((yyvsp[0].ll_node)){ s = make_array((yyvsp[-1].hash_entry), global_default, (yyvsp[0].ll_node), ndim, LOCAL); s->variant = ASYNC_ID; s->attr = s->attr | DIMENSION_BIT; s->type->entry.ar_decl.ranges = (yyvsp[0].ll_node); (yyval.ll_node) = make_llnd(fi,ARRAY_REF, (yyvsp[0].ll_node), LLNULL, s); } else { s = make_local_entity((yyvsp[-1].hash_entry), ASYNC_ID, global_default, LOCAL); (yyval.ll_node) = make_llnd(fi,VAR_REF, LLNULL, LLNULL, s); } } #line 11297 "gram1.tab.c" /* yacc.c:1646 */ break; case 814: #line 6180 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,DVM_NEW_VALUE_DIR,SMNULL, LLNULL, LLNULL,LLNULL);} #line 11303 "gram1.tab.c" /* yacc.c:1646 */ break; case 815: #line 6190 "gram1.y" /* yacc.c:1646 */ { if((yyvsp[-1].ll_node) && (yyvsp[-1].ll_node)->entry.Template.symbol->attr & TASK_BIT) (yyval.bf_node) = get_bfnd(fi,DVM_PARALLEL_TASK_DIR,SMNULL,(yyvsp[-1].ll_node),(yyvsp[0].ll_node),(yyvsp[-3].ll_node)); else (yyval.bf_node) = get_bfnd(fi,DVM_PARALLEL_ON_DIR,SMNULL,(yyvsp[-1].ll_node),(yyvsp[0].ll_node),(yyvsp[-3].ll_node)); } #line 11313 "gram1.tab.c" /* yacc.c:1646 */ break; case 816: #line 6199 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); } #line 11319 "gram1.tab.c" /* yacc.c:1646 */ break; case 817: #line 6201 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); } #line 11325 "gram1.tab.c" /* yacc.c:1646 */ break; case 818: #line 6205 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node);} #line 11331 "gram1.tab.c" /* yacc.c:1646 */ break; case 819: #line 6208 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = LLNULL; opt_kwd_ = NO;} #line 11337 "gram1.tab.c" /* yacc.c:1646 */ break; case 820: #line 6213 "gram1.y" /* yacc.c:1646 */ { if((yyvsp[-3].ll_node)->type->variant != T_ARRAY) errstr("'%s' isn't array", (yyvsp[-3].ll_node)->entry.Template.symbol->ident, 66); (yyvsp[-3].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node); (yyval.ll_node) = (yyvsp[-3].ll_node); (yyval.ll_node)->type = (yyvsp[-3].ll_node)->type->entry.ar_decl.base_type; } #line 11349 "gram1.tab.c" /* yacc.c:1646 */ break; case 821: #line 6223 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); } #line 11355 "gram1.tab.c" /* yacc.c:1646 */ break; case 822: #line 6225 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); } #line 11361 "gram1.tab.c" /* yacc.c:1646 */ break; case 823: #line 6229 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node);} #line 11367 "gram1.tab.c" /* yacc.c:1646 */ break; case 824: #line 6231 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,KEYWORD_VAL, LLNULL, LLNULL, SMNULL); (yyval.ll_node)->entry.string_val = (char *) "*"; (yyval.ll_node)->type = global_string; } #line 11377 "gram1.tab.c" /* yacc.c:1646 */ break; case 825: #line 6239 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = LLNULL;} #line 11383 "gram1.tab.c" /* yacc.c:1646 */ break; case 826: #line 6241 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node);} #line 11389 "gram1.tab.c" /* yacc.c:1646 */ break; case 827: #line 6245 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); } #line 11395 "gram1.tab.c" /* yacc.c:1646 */ break; case 828: #line 6247 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node),(yyvsp[0].ll_node),EXPR_LIST); } #line 11401 "gram1.tab.c" /* yacc.c:1646 */ break; case 840: #line 6265 "gram1.y" /* yacc.c:1646 */ { if((yyvsp[-3].symbol)->attr & INDIRECT_BIT) errstr("'%s' is not remote group name", (yyvsp[-3].symbol)->ident, 68); (yyval.ll_node) = make_llnd(fi,REMOTE_ACCESS_OP,(yyvsp[-1].ll_node),LLNULL,(yyvsp[-3].symbol)); } #line 11410 "gram1.tab.c" /* yacc.c:1646 */ break; case 841: #line 6270 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,REMOTE_ACCESS_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);} #line 11416 "gram1.tab.c" /* yacc.c:1646 */ break; case 842: #line 6274 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,CONSISTENT_OP,(yyvsp[-1].ll_node),LLNULL,(yyvsp[-3].symbol)); } #line 11424 "gram1.tab.c" /* yacc.c:1646 */ break; case 843: #line 6278 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,CONSISTENT_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);} #line 11430 "gram1.tab.c" /* yacc.c:1646 */ break; case 844: #line 6282 "gram1.y" /* yacc.c:1646 */ { if(((yyval.symbol)=(yyvsp[0].hash_entry)->id_attr) == SMNULL){ errstr("'%s' is not declared as group", (yyvsp[0].hash_entry)->ident, 74); (yyval.symbol) = make_local_entity((yyvsp[0].hash_entry),CONSISTENT_GROUP_NAME,global_default,LOCAL); } else { if((yyval.symbol)->variant != CONSISTENT_GROUP_NAME) errstr("'%s' is not declared as group", (yyvsp[0].hash_entry)->ident, 74); } } #line 11444 "gram1.tab.c" /* yacc.c:1646 */ break; case 845: #line 6295 "gram1.y" /* yacc.c:1646 */ {(yyval.ll_node) = make_llnd(fi,NEW_SPEC_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);} #line 11450 "gram1.tab.c" /* yacc.c:1646 */ break; case 846: #line 6299 "gram1.y" /* yacc.c:1646 */ {(yyval.ll_node) = make_llnd(fi,NEW_SPEC_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);} #line 11456 "gram1.tab.c" /* yacc.c:1646 */ break; case 847: #line 6303 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,ACC_PRIVATE_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);} #line 11462 "gram1.tab.c" /* yacc.c:1646 */ break; case 848: #line 6307 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,ACC_CUDA_BLOCK_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);} #line 11468 "gram1.tab.c" /* yacc.c:1646 */ break; case 849: #line 6310 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST);} #line 11474 "gram1.tab.c" /* yacc.c:1646 */ break; case 850: #line 6312 "gram1.y" /* yacc.c:1646 */ {(yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST);} #line 11480 "gram1.tab.c" /* yacc.c:1646 */ break; case 851: #line 6314 "gram1.y" /* yacc.c:1646 */ {(yyval.ll_node) = set_ll_list((yyvsp[-4].ll_node),(yyvsp[-2].ll_node),EXPR_LIST); (yyval.ll_node) = set_ll_list((yyval.ll_node),(yyvsp[0].ll_node),EXPR_LIST);} #line 11486 "gram1.tab.c" /* yacc.c:1646 */ break; case 852: #line 6318 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST);} #line 11492 "gram1.tab.c" /* yacc.c:1646 */ break; case 853: #line 6320 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST);} #line 11498 "gram1.tab.c" /* yacc.c:1646 */ break; case 854: #line 6324 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,ACC_TIE_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);} #line 11504 "gram1.tab.c" /* yacc.c:1646 */ break; case 855: #line 6328 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST);} #line 11510 "gram1.tab.c" /* yacc.c:1646 */ break; case 856: #line 6330 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST);} #line 11516 "gram1.tab.c" /* yacc.c:1646 */ break; case 857: #line 6334 "gram1.y" /* yacc.c:1646 */ { if(!((yyvsp[-3].symbol)->attr & INDIRECT_BIT)) errstr("'%s' is not indirect group name", (yyvsp[-3].symbol)->ident, 313); (yyval.ll_node) = make_llnd(fi,INDIRECT_ACCESS_OP,(yyvsp[-1].ll_node),LLNULL,(yyvsp[-3].symbol)); } #line 11525 "gram1.tab.c" /* yacc.c:1646 */ break; case 858: #line 6339 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,INDIRECT_ACCESS_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);} #line 11531 "gram1.tab.c" /* yacc.c:1646 */ break; case 859: #line 6343 "gram1.y" /* yacc.c:1646 */ {(yyval.ll_node) = make_llnd(fi,STAGE_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);} #line 11537 "gram1.tab.c" /* yacc.c:1646 */ break; case 860: #line 6347 "gram1.y" /* yacc.c:1646 */ {(yyval.ll_node) = make_llnd(fi,ACROSS_OP,(yyvsp[0].ll_node),LLNULL,SMNULL);} #line 11543 "gram1.tab.c" /* yacc.c:1646 */ break; case 861: #line 6349 "gram1.y" /* yacc.c:1646 */ {(yyval.ll_node) = make_llnd(fi,ACROSS_OP,(yyvsp[-1].ll_node),(yyvsp[0].ll_node),SMNULL);} #line 11549 "gram1.tab.c" /* yacc.c:1646 */ break; case 862: #line 6353 "gram1.y" /* yacc.c:1646 */ { if((yyvsp[-2].ll_node)) (yyval.ll_node) = make_llnd(fi,DDOT,(yyvsp[-2].ll_node),(yyvsp[-1].ll_node),SMNULL); else (yyval.ll_node) = (yyvsp[-1].ll_node); } #line 11559 "gram1.tab.c" /* yacc.c:1646 */ break; case 863: #line 6361 "gram1.y" /* yacc.c:1646 */ { opt_in_out = YES; } #line 11565 "gram1.tab.c" /* yacc.c:1646 */ break; case 864: #line 6365 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL); (yyval.ll_node)->entry.string_val = (char *) "in"; (yyval.ll_node)->type = global_string; } #line 11575 "gram1.tab.c" /* yacc.c:1646 */ break; case 865: #line 6371 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL); (yyval.ll_node)->entry.string_val = (char *) "out"; (yyval.ll_node)->type = global_string; } #line 11585 "gram1.tab.c" /* yacc.c:1646 */ break; case 866: #line 6377 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = LLNULL; opt_in_out = NO;} #line 11591 "gram1.tab.c" /* yacc.c:1646 */ break; case 867: #line 6381 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST);} #line 11597 "gram1.tab.c" /* yacc.c:1646 */ break; case 868: #line 6383 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST);} #line 11603 "gram1.tab.c" /* yacc.c:1646 */ break; case 869: #line 6387 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node);} #line 11609 "gram1.tab.c" /* yacc.c:1646 */ break; case 870: #line 6389 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[-3].ll_node); (yyval.ll_node)-> entry.Template.ll_ptr1 = (yyvsp[-1].ll_node); } #line 11617 "gram1.tab.c" /* yacc.c:1646 */ break; case 871: #line 6393 "gram1.y" /* yacc.c:1646 */ { /* PTR_LLND p; p = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL); p->entry.string_val = (char *) "corner"; p->type = global_string; */ (yyvsp[-6].ll_node)-> entry.Template.ll_ptr1 = (yyvsp[-4].ll_node); (yyval.ll_node) = make_llnd(fi,ARRAY_OP,(yyvsp[-6].ll_node),(yyvsp[-1].ll_node),SMNULL); } #line 11630 "gram1.tab.c" /* yacc.c:1646 */ break; case 872: #line 6405 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST);} #line 11636 "gram1.tab.c" /* yacc.c:1646 */ break; case 873: #line 6407 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST);} #line 11642 "gram1.tab.c" /* yacc.c:1646 */ break; case 874: #line 6411 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,DDOT, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), SMNULL);} #line 11648 "gram1.tab.c" /* yacc.c:1646 */ break; case 875: #line 6415 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST);} #line 11654 "gram1.tab.c" /* yacc.c:1646 */ break; case 876: #line 6417 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST);} #line 11660 "gram1.tab.c" /* yacc.c:1646 */ break; case 877: #line 6421 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,DDOT,(yyvsp[-4].ll_node),make_llnd(fi,DDOT,(yyvsp[-2].ll_node),(yyvsp[0].ll_node),SMNULL),SMNULL); } #line 11666 "gram1.tab.c" /* yacc.c:1646 */ break; case 878: #line 6423 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,DDOT,(yyvsp[-2].ll_node),make_llnd(fi,DDOT,(yyvsp[0].ll_node),LLNULL,SMNULL),SMNULL); } #line 11672 "gram1.tab.c" /* yacc.c:1646 */ break; case 879: #line 6425 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,DDOT,(yyvsp[-2].ll_node),make_llnd(fi,DDOT,LLNULL,(yyvsp[0].ll_node),SMNULL),SMNULL); } #line 11678 "gram1.tab.c" /* yacc.c:1646 */ break; case 880: #line 6427 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,DDOT,(yyvsp[0].ll_node),LLNULL,SMNULL); } #line 11684 "gram1.tab.c" /* yacc.c:1646 */ break; case 881: #line 6429 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,DDOT,LLNULL,make_llnd(fi,DDOT,(yyvsp[-2].ll_node),(yyvsp[0].ll_node),SMNULL),SMNULL); } #line 11690 "gram1.tab.c" /* yacc.c:1646 */ break; case 882: #line 6431 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,DDOT,LLNULL,make_llnd(fi,DDOT,(yyvsp[0].ll_node),LLNULL,SMNULL),SMNULL); } #line 11696 "gram1.tab.c" /* yacc.c:1646 */ break; case 883: #line 6433 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,DDOT,LLNULL,make_llnd(fi,DDOT,LLNULL,(yyvsp[0].ll_node),SMNULL),SMNULL); } #line 11702 "gram1.tab.c" /* yacc.c:1646 */ break; case 884: #line 6437 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node);} #line 11708 "gram1.tab.c" /* yacc.c:1646 */ break; case 885: #line 6441 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node);} #line 11714 "gram1.tab.c" /* yacc.c:1646 */ break; case 886: #line 6445 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node);} #line 11720 "gram1.tab.c" /* yacc.c:1646 */ break; case 887: #line 6449 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[-1].ll_node);} #line 11726 "gram1.tab.c" /* yacc.c:1646 */ break; case 888: #line 6453 "gram1.y" /* yacc.c:1646 */ {PTR_LLND q; /* q = set_ll_list($9,$6,EXPR_LIST); */ q = set_ll_list((yyvsp[-4].ll_node),LLNULL,EXPR_LIST); /*podd 11.10.01*/ q = add_to_lowLevelList((yyvsp[-1].ll_node),q); /*podd 11.10.01*/ (yyval.ll_node) = make_llnd(fi,REDUCTION_OP,q,LLNULL,SMNULL); } #line 11737 "gram1.tab.c" /* yacc.c:1646 */ break; case 889: #line 6460 "gram1.y" /* yacc.c:1646 */ {PTR_LLND q; q = set_ll_list((yyvsp[-2].ll_node),LLNULL,EXPR_LIST); (yyval.ll_node) = make_llnd(fi,REDUCTION_OP,q,LLNULL,SMNULL); } #line 11746 "gram1.tab.c" /* yacc.c:1646 */ break; case 890: #line 6466 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,REDUCTION_OP,(yyvsp[-1].ll_node),LLNULL,(yyvsp[-4].symbol)); } #line 11752 "gram1.tab.c" /* yacc.c:1646 */ break; case 891: #line 6470 "gram1.y" /* yacc.c:1646 */ { opt_kwd_r = YES; } #line 11758 "gram1.tab.c" /* yacc.c:1646 */ break; case 892: #line 6473 "gram1.y" /* yacc.c:1646 */ { opt_kwd_r = NO; } #line 11764 "gram1.tab.c" /* yacc.c:1646 */ break; case 893: #line 6477 "gram1.y" /* yacc.c:1646 */ { if(((yyval.symbol)=(yyvsp[0].hash_entry)->id_attr) == SMNULL) { errstr("'%s' is not declared as reduction group", (yyvsp[0].hash_entry)->ident, 69); (yyval.symbol) = make_local_entity((yyvsp[0].hash_entry),REDUCTION_GROUP_NAME,global_default,LOCAL); } else { if((yyval.symbol)->variant != REDUCTION_GROUP_NAME) errstr("'%s' is not declared as reduction group", (yyvsp[0].hash_entry)->ident, 69); } } #line 11778 "gram1.tab.c" /* yacc.c:1646 */ break; case 894: #line 6490 "gram1.y" /* yacc.c:1646 */ {(yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST);} #line 11784 "gram1.tab.c" /* yacc.c:1646 */ break; case 895: #line 6492 "gram1.y" /* yacc.c:1646 */ {(yyval.ll_node) = set_ll_list((yyvsp[-3].ll_node),(yyvsp[0].ll_node),EXPR_LIST);} #line 11790 "gram1.tab.c" /* yacc.c:1646 */ break; case 896: #line 6496 "gram1.y" /* yacc.c:1646 */ {(yyval.ll_node) = make_llnd(fi,ARRAY_OP,(yyvsp[-3].ll_node),(yyvsp[-1].ll_node),SMNULL);} #line 11796 "gram1.tab.c" /* yacc.c:1646 */ break; case 897: #line 6498 "gram1.y" /* yacc.c:1646 */ {(yyvsp[-3].ll_node) = set_ll_list((yyvsp[-3].ll_node),(yyvsp[-1].ll_node),EXPR_LIST); (yyval.ll_node) = make_llnd(fi,ARRAY_OP,(yyvsp[-5].ll_node),(yyvsp[-3].ll_node),SMNULL);} #line 11803 "gram1.tab.c" /* yacc.c:1646 */ break; case 898: #line 6503 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL); (yyval.ll_node)->entry.string_val = (char *) "sum"; (yyval.ll_node)->type = global_string; } #line 11813 "gram1.tab.c" /* yacc.c:1646 */ break; case 899: #line 6509 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL); (yyval.ll_node)->entry.string_val = (char *) "product"; (yyval.ll_node)->type = global_string; } #line 11823 "gram1.tab.c" /* yacc.c:1646 */ break; case 900: #line 6515 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL); (yyval.ll_node)->entry.string_val = (char *) "min"; (yyval.ll_node)->type = global_string; } #line 11833 "gram1.tab.c" /* yacc.c:1646 */ break; case 901: #line 6521 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL); (yyval.ll_node)->entry.string_val = (char *) "max"; (yyval.ll_node)->type = global_string; } #line 11843 "gram1.tab.c" /* yacc.c:1646 */ break; case 902: #line 6527 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL); (yyval.ll_node)->entry.string_val = (char *) "or"; (yyval.ll_node)->type = global_string; } #line 11853 "gram1.tab.c" /* yacc.c:1646 */ break; case 903: #line 6533 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL); (yyval.ll_node)->entry.string_val = (char *) "and"; (yyval.ll_node)->type = global_string; } #line 11863 "gram1.tab.c" /* yacc.c:1646 */ break; case 904: #line 6539 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL); (yyval.ll_node)->entry.string_val = (char *) "eqv"; (yyval.ll_node)->type = global_string; } #line 11873 "gram1.tab.c" /* yacc.c:1646 */ break; case 905: #line 6545 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL); (yyval.ll_node)->entry.string_val = (char *) "neqv"; (yyval.ll_node)->type = global_string; } #line 11883 "gram1.tab.c" /* yacc.c:1646 */ break; case 906: #line 6551 "gram1.y" /* yacc.c:1646 */ { err("Illegal reduction operation name", 70); errcnt--; (yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL); (yyval.ll_node)->entry.string_val = (char *) "unknown"; (yyval.ll_node)->type = global_string; } #line 11894 "gram1.tab.c" /* yacc.c:1646 */ break; case 907: #line 6560 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL); (yyval.ll_node)->entry.string_val = (char *) "maxloc"; (yyval.ll_node)->type = global_string; } #line 11904 "gram1.tab.c" /* yacc.c:1646 */ break; case 908: #line 6566 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL); (yyval.ll_node)->entry.string_val = (char *) "minloc"; (yyval.ll_node)->type = global_string; } #line 11914 "gram1.tab.c" /* yacc.c:1646 */ break; case 909: #line 6583 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,SHADOW_RENEW_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);} #line 11920 "gram1.tab.c" /* yacc.c:1646 */ break; case 910: #line 6591 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,SHADOW_START_OP,LLNULL,LLNULL,(yyvsp[0].symbol));} #line 11926 "gram1.tab.c" /* yacc.c:1646 */ break; case 911: #line 6599 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,SHADOW_WAIT_OP,LLNULL,LLNULL,(yyvsp[0].symbol));} #line 11932 "gram1.tab.c" /* yacc.c:1646 */ break; case 912: #line 6601 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,SHADOW_COMP_OP,LLNULL,LLNULL,SMNULL);} #line 11938 "gram1.tab.c" /* yacc.c:1646 */ break; case 913: #line 6603 "gram1.y" /* yacc.c:1646 */ { (yyvsp[-4].ll_node)-> entry.Template.ll_ptr1 = (yyvsp[-2].ll_node); (yyval.ll_node) = make_llnd(fi,SHADOW_COMP_OP,(yyvsp[-4].ll_node),LLNULL,SMNULL);} #line 11944 "gram1.tab.c" /* yacc.c:1646 */ break; case 914: #line 6607 "gram1.y" /* yacc.c:1646 */ {(yyval.symbol) = make_local_entity((yyvsp[0].hash_entry), SHADOW_GROUP_NAME,global_default,LOCAL);} #line 11950 "gram1.tab.c" /* yacc.c:1646 */ break; case 915: #line 6611 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST);} #line 11956 "gram1.tab.c" /* yacc.c:1646 */ break; case 916: #line 6613 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST);} #line 11962 "gram1.tab.c" /* yacc.c:1646 */ break; case 917: #line 6617 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node);} #line 11968 "gram1.tab.c" /* yacc.c:1646 */ break; case 918: #line 6619 "gram1.y" /* yacc.c:1646 */ { PTR_LLND p; p = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL); p->entry.string_val = (char *) "corner"; p->type = global_string; (yyval.ll_node) = make_llnd(fi,ARRAY_OP,(yyvsp[-4].ll_node),p,SMNULL); } #line 11979 "gram1.tab.c" /* yacc.c:1646 */ break; case 919: #line 6627 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[-4].ll_node); (yyval.ll_node)-> entry.Template.ll_ptr1 = (yyvsp[-1].ll_node); } #line 11987 "gram1.tab.c" /* yacc.c:1646 */ break; case 920: #line 6631 "gram1.y" /* yacc.c:1646 */ { PTR_LLND p; p = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL); p->entry.string_val = (char *) "corner"; p->type = global_string; (yyvsp[-8].ll_node)-> entry.Template.ll_ptr1 = (yyvsp[-5].ll_node); (yyval.ll_node) = make_llnd(fi,ARRAY_OP,(yyvsp[-8].ll_node),p,SMNULL); } #line 11999 "gram1.tab.c" /* yacc.c:1646 */ break; case 921: #line 6642 "gram1.y" /* yacc.c:1646 */ { optcorner = YES; } #line 12005 "gram1.tab.c" /* yacc.c:1646 */ break; case 922: #line 6646 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; s = (yyvsp[0].ll_node)->entry.Template.symbol; if(s->attr & PROCESSORS_BIT) errstr( "Illegal use of PROCESSORS name %s ", s->ident, 53); else if(s->attr & TASK_BIT) errstr( "Illegal use of task array name %s ", s->ident, 71); else if(s->type->variant != T_ARRAY) errstr("'%s' isn't array", s->ident, 66); else if((!(s->attr & DISTRIBUTE_BIT)) && (!(s->attr & ALIGN_BIT))) ; /*errstr("hpf.gram: %s is not distributed array", s->ident);*/ (yyval.ll_node) = (yyvsp[0].ll_node); } #line 12025 "gram1.tab.c" /* yacc.c:1646 */ break; case 923: #line 6664 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); } #line 12031 "gram1.tab.c" /* yacc.c:1646 */ break; case 924: #line 6666 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); } #line 12037 "gram1.tab.c" /* yacc.c:1646 */ break; case 925: #line 6670 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,DVM_SHADOW_START_DIR,(yyvsp[0].symbol),LLNULL,LLNULL,LLNULL);} #line 12043 "gram1.tab.c" /* yacc.c:1646 */ break; case 926: #line 6672 "gram1.y" /* yacc.c:1646 */ {errstr("Missing DVM directive prefix", 49);} #line 12049 "gram1.tab.c" /* yacc.c:1646 */ break; case 927: #line 6676 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,DVM_SHADOW_WAIT_DIR,(yyvsp[0].symbol),LLNULL,LLNULL,LLNULL);} #line 12055 "gram1.tab.c" /* yacc.c:1646 */ break; case 928: #line 6678 "gram1.y" /* yacc.c:1646 */ {errstr("Missing DVM directive prefix", 49);} #line 12061 "gram1.tab.c" /* yacc.c:1646 */ break; case 929: #line 6682 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,DVM_SHADOW_GROUP_DIR,(yyvsp[-3].symbol),(yyvsp[-1].ll_node),LLNULL,LLNULL);} #line 12067 "gram1.tab.c" /* yacc.c:1646 */ break; case 930: #line 6686 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,DVM_REDUCTION_START_DIR,(yyvsp[0].symbol),LLNULL,LLNULL,LLNULL);} #line 12073 "gram1.tab.c" /* yacc.c:1646 */ break; case 931: #line 6690 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,DVM_REDUCTION_WAIT_DIR,(yyvsp[0].symbol),LLNULL,LLNULL,LLNULL);} #line 12079 "gram1.tab.c" /* yacc.c:1646 */ break; case 932: #line 6699 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,DVM_CONSISTENT_START_DIR,(yyvsp[0].symbol),LLNULL,LLNULL,LLNULL);} #line 12085 "gram1.tab.c" /* yacc.c:1646 */ break; case 933: #line 6703 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,DVM_CONSISTENT_WAIT_DIR,(yyvsp[0].symbol),LLNULL,LLNULL,LLNULL);} #line 12091 "gram1.tab.c" /* yacc.c:1646 */ break; case 934: #line 6707 "gram1.y" /* yacc.c:1646 */ { if(((yyvsp[-3].symbol)->attr & INDIRECT_BIT)) errstr("'%s' is not remote group name", (yyvsp[-3].symbol)->ident, 68); (yyval.bf_node) = get_bfnd(fi,DVM_REMOTE_ACCESS_DIR,(yyvsp[-3].symbol),(yyvsp[-1].ll_node),LLNULL,LLNULL); } #line 12100 "gram1.tab.c" /* yacc.c:1646 */ break; case 935: #line 6712 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,DVM_REMOTE_ACCESS_DIR,SMNULL,(yyvsp[-1].ll_node),LLNULL,LLNULL);} #line 12106 "gram1.tab.c" /* yacc.c:1646 */ break; case 936: #line 6716 "gram1.y" /* yacc.c:1646 */ { if(((yyval.symbol)=(yyvsp[0].hash_entry)->id_attr) == SMNULL){ errstr("'%s' is not declared as group", (yyvsp[0].hash_entry)->ident, 74); (yyval.symbol) = make_local_entity((yyvsp[0].hash_entry),REF_GROUP_NAME,global_default,LOCAL); } else { if((yyval.symbol)->variant != REF_GROUP_NAME) errstr("'%s' is not declared as group", (yyvsp[0].hash_entry)->ident, 74); } } #line 12120 "gram1.tab.c" /* yacc.c:1646 */ break; case 937: #line 6728 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); } #line 12126 "gram1.tab.c" /* yacc.c:1646 */ break; case 938: #line 6730 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); } #line 12132 "gram1.tab.c" /* yacc.c:1646 */ break; case 939: #line 6734 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[-3].ll_node); (yyval.ll_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node); } #line 12141 "gram1.tab.c" /* yacc.c:1646 */ break; case 940: #line 6739 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node);} #line 12147 "gram1.tab.c" /* yacc.c:1646 */ break; case 941: #line 6743 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); } #line 12153 "gram1.tab.c" /* yacc.c:1646 */ break; case 942: #line 6745 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); } #line 12159 "gram1.tab.c" /* yacc.c:1646 */ break; case 943: #line 6749 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node);} #line 12165 "gram1.tab.c" /* yacc.c:1646 */ break; case 944: #line 6751 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,DDOT, LLNULL, LLNULL, SMNULL);} #line 12171 "gram1.tab.c" /* yacc.c:1646 */ break; case 945: #line 6755 "gram1.y" /* yacc.c:1646 */ { PTR_LLND q; q = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL); (yyval.bf_node) = get_bfnd(fi,DVM_TASK_DIR,SMNULL,q,LLNULL,LLNULL); } #line 12180 "gram1.tab.c" /* yacc.c:1646 */ break; case 946: #line 6760 "gram1.y" /* yacc.c:1646 */ { PTR_LLND q; q = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL); add_to_lowLevelList(q, (yyvsp[-2].bf_node)->entry.Template.ll_ptr1); } #line 12189 "gram1.tab.c" /* yacc.c:1646 */ break; case 947: #line 6767 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; s = make_array((yyvsp[-1].hash_entry), global_int, (yyvsp[0].ll_node), ndim, LOCAL); if((yyvsp[0].ll_node)){ s->attr = s->attr | DIMENSION_BIT; s->type->entry.ar_decl.ranges = (yyvsp[0].ll_node); } else err("No dimensions in TASK directive", 75); if(ndim > 1) errstr("Illegal rank of '%s'", s->ident, 76); if(s->attr & TASK_BIT) errstr( "Multiple declaration of identifier %s ", s->ident, 73); if((s->attr & ALIGN_BIT) ||(s->attr & DISTRIBUTE_BIT) ||(s->attr & TEMPLATE_BIT) || (s->attr & DYNAMIC_BIT) ||(s->attr & SHADOW_BIT) || (s->attr & PROCESSORS_BIT) || (s->attr & DVM_POINTER_BIT) || (s->attr & INHERIT_BIT)) errstr("Inconsistent declaration of identifier %s", s->ident, 16); else s->attr = s->attr | TASK_BIT; (yyval.ll_node) = make_llnd(fi,ARRAY_REF, (yyvsp[0].ll_node), LLNULL, s); } #line 12214 "gram1.tab.c" /* yacc.c:1646 */ break; case 948: #line 6790 "gram1.y" /* yacc.c:1646 */ {(yyval.bf_node) = get_bfnd(fi,DVM_TASK_REGION_DIR,(yyvsp[0].symbol),LLNULL,LLNULL,LLNULL);} #line 12220 "gram1.tab.c" /* yacc.c:1646 */ break; case 949: #line 6792 "gram1.y" /* yacc.c:1646 */ {(yyval.bf_node) = get_bfnd(fi,DVM_TASK_REGION_DIR,(yyvsp[-1].symbol),(yyvsp[0].ll_node),LLNULL,LLNULL);} #line 12226 "gram1.tab.c" /* yacc.c:1646 */ break; case 950: #line 6794 "gram1.y" /* yacc.c:1646 */ {(yyval.bf_node) = get_bfnd(fi,DVM_TASK_REGION_DIR,(yyvsp[-1].symbol),LLNULL,(yyvsp[0].ll_node),LLNULL);} #line 12232 "gram1.tab.c" /* yacc.c:1646 */ break; case 951: #line 6796 "gram1.y" /* yacc.c:1646 */ {(yyval.bf_node) = get_bfnd(fi,DVM_TASK_REGION_DIR,(yyvsp[-2].symbol),(yyvsp[-1].ll_node),(yyvsp[0].ll_node),LLNULL);} #line 12238 "gram1.tab.c" /* yacc.c:1646 */ break; case 952: #line 6798 "gram1.y" /* yacc.c:1646 */ {(yyval.bf_node) = get_bfnd(fi,DVM_TASK_REGION_DIR,(yyvsp[-2].symbol),(yyvsp[0].ll_node),(yyvsp[-1].ll_node),LLNULL);} #line 12244 "gram1.tab.c" /* yacc.c:1646 */ break; case 953: #line 6802 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; if((s=(yyvsp[0].hash_entry)->id_attr) == SMNULL) s = make_array((yyvsp[0].hash_entry), TYNULL, LLNULL, 0, LOCAL); if(!(s->attr & TASK_BIT)) errstr("'%s' is not task array", s->ident, 77); (yyval.symbol) = s; } #line 12257 "gram1.tab.c" /* yacc.c:1646 */ break; case 954: #line 6813 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,DVM_END_TASK_REGION_DIR,SMNULL,LLNULL,LLNULL,LLNULL);} #line 12263 "gram1.tab.c" /* yacc.c:1646 */ break; case 955: #line 6817 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; PTR_LLND q; /* s = make_array($1, TYNULL, LLNULL, 0, LOCAL); if((parstate == INEXEC) && !(s->attr & TASK_BIT)) errstr("'%s' is not task array", s->ident, 77); q = set_ll_list($3,LLNULL,EXPR_LIST); $$ = make_llnd(fi,ARRAY_REF, q, LLNULL, s); */ s = (yyvsp[-3].symbol); q = set_ll_list((yyvsp[-1].ll_node),LLNULL,EXPR_LIST); (yyval.ll_node) = make_llnd(fi,ARRAY_REF, q, LLNULL, s); } #line 12282 "gram1.tab.c" /* yacc.c:1646 */ break; case 956: #line 6832 "gram1.y" /* yacc.c:1646 */ { PTR_LLND q; q = set_ll_list((yyvsp[-1].ll_node),LLNULL,EXPR_LIST); (yyval.ll_node) = make_llnd(fi,ARRAY_REF, q, LLNULL, (yyvsp[-3].symbol)); } #line 12291 "gram1.tab.c" /* yacc.c:1646 */ break; case 957: #line 6839 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,DVM_ON_DIR,SMNULL,(yyvsp[-1].ll_node),(yyvsp[0].ll_node),LLNULL); } #line 12299 "gram1.tab.c" /* yacc.c:1646 */ break; case 958: #line 6845 "gram1.y" /* yacc.c:1646 */ {(yyval.ll_node) = LLNULL;} #line 12305 "gram1.tab.c" /* yacc.c:1646 */ break; case 959: #line 6847 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node);} #line 12311 "gram1.tab.c" /* yacc.c:1646 */ break; case 960: #line 6851 "gram1.y" /* yacc.c:1646 */ {(yyval.bf_node) = get_bfnd(fi,DVM_END_ON_DIR,SMNULL,LLNULL,LLNULL,LLNULL);} #line 12317 "gram1.tab.c" /* yacc.c:1646 */ break; case 961: #line 6855 "gram1.y" /* yacc.c:1646 */ { PTR_LLND q; /* if(!($6->attr & PROCESSORS_BIT)) errstr("'%s' is not processor array", $6->ident, 67); */ q = make_llnd(fi,ARRAY_REF, (yyvsp[0].ll_node), LLNULL, (yyvsp[-1].symbol)); (yyval.bf_node) = get_bfnd(fi,DVM_MAP_DIR,SMNULL,(yyvsp[-4].ll_node),q,LLNULL); } #line 12329 "gram1.tab.c" /* yacc.c:1646 */ break; case 962: #line 6863 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,DVM_MAP_DIR,SMNULL,(yyvsp[-3].ll_node),LLNULL,(yyvsp[0].ll_node)); } #line 12335 "gram1.tab.c" /* yacc.c:1646 */ break; case 963: #line 6867 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,DVM_PREFETCH_DIR,(yyvsp[0].symbol),LLNULL,LLNULL,LLNULL);} #line 12341 "gram1.tab.c" /* yacc.c:1646 */ break; case 964: #line 6871 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,DVM_RESET_DIR,(yyvsp[0].symbol),LLNULL,LLNULL,LLNULL);} #line 12347 "gram1.tab.c" /* yacc.c:1646 */ break; case 965: #line 6879 "gram1.y" /* yacc.c:1646 */ { if(!((yyvsp[-3].symbol)->attr & INDIRECT_BIT)) errstr("'%s' is not indirect group name", (yyvsp[-3].symbol)->ident, 313); (yyval.bf_node) = get_bfnd(fi,DVM_INDIRECT_ACCESS_DIR,(yyvsp[-3].symbol),(yyvsp[-1].ll_node),LLNULL,LLNULL); } #line 12356 "gram1.tab.c" /* yacc.c:1646 */ break; case 966: #line 6884 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,DVM_INDIRECT_ACCESS_DIR,SMNULL,(yyvsp[-1].ll_node),LLNULL,LLNULL);} #line 12362 "gram1.tab.c" /* yacc.c:1646 */ break; case 967: #line 6898 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); } #line 12368 "gram1.tab.c" /* yacc.c:1646 */ break; case 968: #line 6900 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); } #line 12374 "gram1.tab.c" /* yacc.c:1646 */ break; case 969: #line 6904 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node);} #line 12380 "gram1.tab.c" /* yacc.c:1646 */ break; case 970: #line 6906 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[-3].ll_node); (yyval.ll_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);} #line 12386 "gram1.tab.c" /* yacc.c:1646 */ break; case 971: #line 6915 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,HPF_INDEPENDENT_DIR,SMNULL,LLNULL,LLNULL,LLNULL);} #line 12392 "gram1.tab.c" /* yacc.c:1646 */ break; case 972: #line 6917 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,HPF_INDEPENDENT_DIR,SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL);} #line 12398 "gram1.tab.c" /* yacc.c:1646 */ break; case 973: #line 6919 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,HPF_INDEPENDENT_DIR,SMNULL, LLNULL, (yyvsp[0].ll_node), LLNULL);} #line 12404 "gram1.tab.c" /* yacc.c:1646 */ break; case 974: #line 6921 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,HPF_INDEPENDENT_DIR,SMNULL, (yyvsp[-1].ll_node), (yyvsp[0].ll_node),LLNULL);} #line 12410 "gram1.tab.c" /* yacc.c:1646 */ break; case 975: #line 6957 "gram1.y" /* yacc.c:1646 */ {(yyval.ll_node) = make_llnd(fi,REDUCTION_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);} #line 12416 "gram1.tab.c" /* yacc.c:1646 */ break; case 976: #line 6961 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,DVM_ASYNCHRONOUS_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL);} #line 12422 "gram1.tab.c" /* yacc.c:1646 */ break; case 977: #line 6965 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,DVM_ENDASYNCHRONOUS_DIR,SMNULL,LLNULL,LLNULL,LLNULL);} #line 12428 "gram1.tab.c" /* yacc.c:1646 */ break; case 978: #line 6969 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,DVM_ASYNCWAIT_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL);} #line 12434 "gram1.tab.c" /* yacc.c:1646 */ break; case 979: #line 6973 "gram1.y" /* yacc.c:1646 */ { if(((yyval.symbol)=(yyvsp[0].hash_entry)->id_attr) == SMNULL) { errstr("'%s' is not declared as ASYNCID", (yyvsp[0].hash_entry)->ident, 115); (yyval.symbol) = make_local_entity((yyvsp[0].hash_entry),ASYNC_ID,global_default,LOCAL); } else { if((yyval.symbol)->variant != ASYNC_ID) errstr("'%s' is not declared as ASYNCID", (yyvsp[0].hash_entry)->ident, 115); } } #line 12448 "gram1.tab.c" /* yacc.c:1646 */ break; case 980: #line 6985 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,VAR_REF, LLNULL, LLNULL, (yyvsp[0].symbol));} #line 12454 "gram1.tab.c" /* yacc.c:1646 */ break; case 981: #line 6987 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,ARRAY_REF, (yyvsp[-1].ll_node), LLNULL, (yyvsp[-3].symbol));} #line 12460 "gram1.tab.c" /* yacc.c:1646 */ break; case 982: #line 6991 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,DVM_F90_DIR,SMNULL,(yyvsp[-2].ll_node),(yyvsp[0].ll_node),LLNULL);} #line 12466 "gram1.tab.c" /* yacc.c:1646 */ break; case 983: #line 6994 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,DVM_DEBUG_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL);} #line 12472 "gram1.tab.c" /* yacc.c:1646 */ break; case 984: #line 6996 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,DVM_DEBUG_DIR,SMNULL,(yyvsp[-3].ll_node),(yyvsp[-1].ll_node),LLNULL);} #line 12478 "gram1.tab.c" /* yacc.c:1646 */ break; case 985: #line 7000 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); endioctl(); } #line 12487 "gram1.tab.c" /* yacc.c:1646 */ break; case 986: #line 7005 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-3].ll_node), (yyvsp[0].ll_node), EXPR_LIST); endioctl(); } #line 12496 "gram1.tab.c" /* yacc.c:1646 */ break; case 987: #line 7012 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi, KEYWORD_ARG, (yyvsp[-1].ll_node), (yyvsp[0].ll_node), SMNULL); } #line 12502 "gram1.tab.c" /* yacc.c:1646 */ break; case 988: #line 7015 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,INT_VAL, LLNULL, LLNULL, SMNULL); (yyval.ll_node)->entry.ival = atoi(yytext); (yyval.ll_node)->type = global_int; } #line 12512 "gram1.tab.c" /* yacc.c:1646 */ break; case 989: #line 7023 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,DVM_ENDDEBUG_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL);} #line 12518 "gram1.tab.c" /* yacc.c:1646 */ break; case 990: #line 7027 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,DVM_INTERVAL_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL);} #line 12524 "gram1.tab.c" /* yacc.c:1646 */ break; case 991: #line 7031 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = LLNULL;} #line 12530 "gram1.tab.c" /* yacc.c:1646 */ break; case 992: #line 7034 "gram1.y" /* yacc.c:1646 */ { if((yyvsp[0].ll_node)->type->variant != T_INT) err("Illegal interval number", 78); (yyval.ll_node) = (yyvsp[0].ll_node); } #line 12539 "gram1.tab.c" /* yacc.c:1646 */ break; case 993: #line 7042 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,DVM_EXIT_INTERVAL_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL);} #line 12545 "gram1.tab.c" /* yacc.c:1646 */ break; case 994: #line 7046 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,DVM_ENDINTERVAL_DIR,SMNULL,LLNULL,LLNULL,LLNULL);} #line 12551 "gram1.tab.c" /* yacc.c:1646 */ break; case 995: #line 7050 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,DVM_TRACEON_DIR,SMNULL,LLNULL,LLNULL,LLNULL);} #line 12557 "gram1.tab.c" /* yacc.c:1646 */ break; case 996: #line 7054 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,DVM_TRACEOFF_DIR,SMNULL,LLNULL,LLNULL,LLNULL);} #line 12563 "gram1.tab.c" /* yacc.c:1646 */ break; case 997: #line 7058 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,DVM_BARRIER_DIR,SMNULL,LLNULL,LLNULL,LLNULL);} #line 12569 "gram1.tab.c" /* yacc.c:1646 */ break; case 998: #line 7062 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,DVM_CHECK_DIR,SMNULL,(yyvsp[0].ll_node),(yyvsp[-4].ll_node),LLNULL); } #line 12575 "gram1.tab.c" /* yacc.c:1646 */ break; case 999: #line 7066 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,DVM_IO_MODE_DIR,SMNULL,(yyvsp[-1].ll_node),LLNULL,LLNULL);} #line 12581 "gram1.tab.c" /* yacc.c:1646 */ break; case 1000: #line 7069 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); } #line 12587 "gram1.tab.c" /* yacc.c:1646 */ break; case 1001: #line 7071 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); } #line 12593 "gram1.tab.c" /* yacc.c:1646 */ break; case 1002: #line 7075 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,ACC_ASYNC_OP,LLNULL,LLNULL,SMNULL);} #line 12599 "gram1.tab.c" /* yacc.c:1646 */ break; case 1003: #line 7077 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,ACC_LOCAL_OP, LLNULL,LLNULL,SMNULL);} #line 12605 "gram1.tab.c" /* yacc.c:1646 */ break; case 1004: #line 7079 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,PARALLEL_OP, LLNULL,LLNULL,SMNULL);} #line 12611 "gram1.tab.c" /* yacc.c:1646 */ break; case 1005: #line 7083 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,DVM_SHADOW_ADD_DIR,SMNULL,(yyvsp[-5].ll_node),(yyvsp[-3].ll_node),(yyvsp[0].ll_node)); } #line 12617 "gram1.tab.c" /* yacc.c:1646 */ break; case 1006: #line 7087 "gram1.y" /* yacc.c:1646 */ { if((yyvsp[-3].ll_node)->type->variant != T_ARRAY) errstr("'%s' isn't array", (yyvsp[-3].ll_node)->entry.Template.symbol->ident, 66); if(!((yyvsp[-3].ll_node)->entry.Template.symbol->attr & TEMPLATE_BIT)) errstr("'%s' isn't TEMPLATE", (yyvsp[-3].ll_node)->entry.Template.symbol->ident, 628); (yyvsp[-3].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node); (yyval.ll_node) = (yyvsp[-3].ll_node); /*$$->type = $1->type->entry.ar_decl.base_type;*/ } #line 12631 "gram1.tab.c" /* yacc.c:1646 */ break; case 1007: #line 7099 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); } #line 12637 "gram1.tab.c" /* yacc.c:1646 */ break; case 1008: #line 7101 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); } #line 12643 "gram1.tab.c" /* yacc.c:1646 */ break; case 1009: #line 7105 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node); } #line 12649 "gram1.tab.c" /* yacc.c:1646 */ break; case 1010: #line 7107 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node); } #line 12655 "gram1.tab.c" /* yacc.c:1646 */ break; case 1011: #line 7111 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node);} #line 12661 "gram1.tab.c" /* yacc.c:1646 */ break; case 1012: #line 7113 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = LLNULL; opt_kwd_ = NO;} #line 12667 "gram1.tab.c" /* yacc.c:1646 */ break; case 1013: #line 7117 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,DVM_LOCALIZE_DIR,SMNULL,(yyvsp[-3].ll_node),(yyvsp[-1].ll_node),LLNULL); } #line 12673 "gram1.tab.c" /* yacc.c:1646 */ break; case 1014: #line 7121 "gram1.y" /* yacc.c:1646 */ { if((yyvsp[0].ll_node)->type->variant != T_ARRAY) errstr("'%s' isn't array", (yyvsp[0].ll_node)->entry.Template.symbol->ident, 66); (yyval.ll_node) = (yyvsp[0].ll_node); } #line 12683 "gram1.tab.c" /* yacc.c:1646 */ break; case 1015: #line 7127 "gram1.y" /* yacc.c:1646 */ { if((yyvsp[-3].ll_node)->type->variant != T_ARRAY) errstr("'%s' isn't array", (yyvsp[-3].ll_node)->entry.Template.symbol->ident, 66); (yyvsp[-3].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node); (yyval.ll_node) = (yyvsp[-3].ll_node); (yyval.ll_node)->type = (yyvsp[-3].ll_node)->type->entry.ar_decl.base_type; } #line 12696 "gram1.tab.c" /* yacc.c:1646 */ break; case 1016: #line 7139 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); } #line 12702 "gram1.tab.c" /* yacc.c:1646 */ break; case 1017: #line 7141 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); } #line 12708 "gram1.tab.c" /* yacc.c:1646 */ break; case 1018: #line 7145 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node); } #line 12714 "gram1.tab.c" /* yacc.c:1646 */ break; case 1019: #line 7147 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,DDOT, LLNULL, LLNULL, SMNULL);} #line 12720 "gram1.tab.c" /* yacc.c:1646 */ break; case 1020: #line 7151 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,KEYWORD_VAL, LLNULL, LLNULL, SMNULL); (yyval.ll_node)->entry.string_val = (char *) "*"; (yyval.ll_node)->type = global_string; } #line 12730 "gram1.tab.c" /* yacc.c:1646 */ break; case 1021: #line 7159 "gram1.y" /* yacc.c:1646 */ { PTR_LLND q; if((yyvsp[0].ll_node)) q = make_llnd(fi,ARRAY_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), SMNULL); else q = (yyvsp[-2].ll_node); (yyval.bf_node) = get_bfnd(fi,DVM_CP_CREATE_DIR,SMNULL,(yyvsp[-13].ll_node),(yyvsp[-8].ll_node),q); } #line 12743 "gram1.tab.c" /* yacc.c:1646 */ break; case 1022: #line 7170 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = LLNULL; } #line 12749 "gram1.tab.c" /* yacc.c:1646 */ break; case 1023: #line 7172 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi, PARALLEL_OP, LLNULL, LLNULL, SMNULL); } #line 12755 "gram1.tab.c" /* yacc.c:1646 */ break; case 1024: #line 7174 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,ACC_LOCAL_OP, LLNULL, LLNULL, SMNULL); } #line 12761 "gram1.tab.c" /* yacc.c:1646 */ break; case 1025: #line 7178 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,DVM_CP_LOAD_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL); } #line 12767 "gram1.tab.c" /* yacc.c:1646 */ break; case 1026: #line 7182 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,DVM_CP_SAVE_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL); } #line 12773 "gram1.tab.c" /* yacc.c:1646 */ break; case 1027: #line 7184 "gram1.y" /* yacc.c:1646 */ { PTR_LLND q; q = make_llnd(fi,ACC_ASYNC_OP,LLNULL,LLNULL,SMNULL); (yyval.bf_node) = get_bfnd(fi,DVM_CP_SAVE_DIR,SMNULL,(yyvsp[-3].ll_node),q,LLNULL); } #line 12783 "gram1.tab.c" /* yacc.c:1646 */ break; case 1028: #line 7192 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,DVM_CP_WAIT_DIR,SMNULL,(yyvsp[-6].ll_node),(yyvsp[-1].ll_node),LLNULL); } #line 12789 "gram1.tab.c" /* yacc.c:1646 */ break; case 1029: #line 7196 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,DVM_TEMPLATE_CREATE_DIR,SMNULL,(yyvsp[-1].ll_node),LLNULL,LLNULL); } #line 12795 "gram1.tab.c" /* yacc.c:1646 */ break; case 1030: #line 7199 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); } #line 12801 "gram1.tab.c" /* yacc.c:1646 */ break; case 1031: #line 7201 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); } #line 12807 "gram1.tab.c" /* yacc.c:1646 */ break; case 1032: #line 7205 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,DVM_TEMPLATE_DELETE_DIR,SMNULL,(yyvsp[-1].ll_node),LLNULL,LLNULL); } #line 12813 "gram1.tab.c" /* yacc.c:1646 */ break; case 1060: #line 7239 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,OMP_ONETHREAD_DIR,SMNULL,LLNULL,LLNULL,LLNULL); } #line 12821 "gram1.tab.c" /* yacc.c:1646 */ break; case 1061: #line 7245 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = make_endparallel(); } #line 12829 "gram1.tab.c" /* yacc.c:1646 */ break; case 1062: #line 7251 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = make_parallel(); (yyval.bf_node)->entry.Template.ll_ptr1 = (yyvsp[0].ll_node); opt_kwd_ = NO; } #line 12839 "gram1.tab.c" /* yacc.c:1646 */ break; case 1063: #line 7257 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = make_parallel(); opt_kwd_ = NO; } #line 12848 "gram1.tab.c" /* yacc.c:1646 */ break; case 1064: #line 7263 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node),LLNULL,EXPR_LIST); } #line 12856 "gram1.tab.c" /* yacc.c:1646 */ break; case 1065: #line 7267 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-4].ll_node),(yyvsp[-1].ll_node),EXPR_LIST); } #line 12864 "gram1.tab.c" /* yacc.c:1646 */ break; case 1075: #line 7284 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[-1].ll_node); } #line 12872 "gram1.tab.c" /* yacc.c:1646 */ break; case 1076: #line 7289 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,OMP_PRIVATE,(yyvsp[0].ll_node),LLNULL,SMNULL); } #line 12880 "gram1.tab.c" /* yacc.c:1646 */ break; case 1077: #line 7294 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,OMP_FIRSTPRIVATE,(yyvsp[0].ll_node),LLNULL,SMNULL); } #line 12888 "gram1.tab.c" /* yacc.c:1646 */ break; case 1078: #line 7300 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,OMP_LASTPRIVATE,(yyvsp[0].ll_node),LLNULL,SMNULL); } #line 12896 "gram1.tab.c" /* yacc.c:1646 */ break; case 1079: #line 7306 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,OMP_COPYIN,(yyvsp[0].ll_node),LLNULL,SMNULL); } #line 12904 "gram1.tab.c" /* yacc.c:1646 */ break; case 1080: #line 7312 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,OMP_SHARED,(yyvsp[0].ll_node),LLNULL,SMNULL); } #line 12912 "gram1.tab.c" /* yacc.c:1646 */ break; case 1081: #line 7317 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,OMP_DEFAULT,(yyvsp[-1].ll_node),LLNULL,SMNULL); } #line 12920 "gram1.tab.c" /* yacc.c:1646 */ break; case 1082: #line 7323 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL); (yyval.ll_node)->entry.string_val = (char *) "private"; (yyval.ll_node)->type = global_string; } #line 12930 "gram1.tab.c" /* yacc.c:1646 */ break; case 1083: #line 7329 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL); (yyval.ll_node)->entry.string_val = (char *) "shared"; (yyval.ll_node)->type = global_string; } #line 12940 "gram1.tab.c" /* yacc.c:1646 */ break; case 1084: #line 7335 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL); (yyval.ll_node)->entry.string_val = (char *) "none"; (yyval.ll_node)->type = global_string; } #line 12950 "gram1.tab.c" /* yacc.c:1646 */ break; case 1085: #line 7342 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,OMP_IF,(yyvsp[-1].ll_node),LLNULL,SMNULL); } #line 12958 "gram1.tab.c" /* yacc.c:1646 */ break; case 1086: #line 7348 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,OMP_NUM_THREADS,(yyvsp[-1].ll_node),LLNULL,SMNULL); } #line 12966 "gram1.tab.c" /* yacc.c:1646 */ break; case 1087: #line 7354 "gram1.y" /* yacc.c:1646 */ { PTR_LLND q; q = set_ll_list((yyvsp[-1].ll_node),LLNULL,EXPR_LIST); (yyval.ll_node) = make_llnd(fi,OMP_REDUCTION,q,LLNULL,SMNULL); } #line 12976 "gram1.tab.c" /* yacc.c:1646 */ break; case 1088: #line 7361 "gram1.y" /* yacc.c:1646 */ {(yyval.ll_node) = make_llnd(fi,DDOT,(yyvsp[-2].ll_node),(yyvsp[0].ll_node),SMNULL);} #line 12982 "gram1.tab.c" /* yacc.c:1646 */ break; case 1090: #line 7367 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL); (yyval.ll_node)->entry.string_val = (char *) "+"; (yyval.ll_node)->type = global_string; } #line 12992 "gram1.tab.c" /* yacc.c:1646 */ break; case 1091: #line 7373 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL); (yyval.ll_node)->entry.string_val = (char *) "-"; (yyval.ll_node)->type = global_string; } #line 13002 "gram1.tab.c" /* yacc.c:1646 */ break; case 1092: #line 7380 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL); (yyval.ll_node)->entry.string_val = (char *) "*"; (yyval.ll_node)->type = global_string; } #line 13012 "gram1.tab.c" /* yacc.c:1646 */ break; case 1093: #line 7386 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL); (yyval.ll_node)->entry.string_val = (char *) "/"; (yyval.ll_node)->type = global_string; } #line 13022 "gram1.tab.c" /* yacc.c:1646 */ break; case 1094: #line 7392 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL); (yyval.ll_node)->entry.string_val = (char *) "min"; (yyval.ll_node)->type = global_string; } #line 13032 "gram1.tab.c" /* yacc.c:1646 */ break; case 1095: #line 7398 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL); (yyval.ll_node)->entry.string_val = (char *) "max"; (yyval.ll_node)->type = global_string; } #line 13042 "gram1.tab.c" /* yacc.c:1646 */ break; case 1096: #line 7404 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL); (yyval.ll_node)->entry.string_val = (char *) ".or."; (yyval.ll_node)->type = global_string; } #line 13052 "gram1.tab.c" /* yacc.c:1646 */ break; case 1097: #line 7410 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL); (yyval.ll_node)->entry.string_val = (char *) ".and."; (yyval.ll_node)->type = global_string; } #line 13062 "gram1.tab.c" /* yacc.c:1646 */ break; case 1098: #line 7416 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL); (yyval.ll_node)->entry.string_val = (char *) ".eqv."; (yyval.ll_node)->type = global_string; } #line 13072 "gram1.tab.c" /* yacc.c:1646 */ break; case 1099: #line 7422 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL); (yyval.ll_node)->entry.string_val = (char *) ".neqv."; (yyval.ll_node)->type = global_string; } #line 13082 "gram1.tab.c" /* yacc.c:1646 */ break; case 1100: #line 7428 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL); (yyval.ll_node)->entry.string_val = (char *) "iand"; (yyval.ll_node)->type = global_string; } #line 13092 "gram1.tab.c" /* yacc.c:1646 */ break; case 1101: #line 7434 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL); (yyval.ll_node)->entry.string_val = (char *) "ieor"; (yyval.ll_node)->type = global_string; } #line 13102 "gram1.tab.c" /* yacc.c:1646 */ break; case 1102: #line 7440 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL); (yyval.ll_node)->entry.string_val = (char *) "ior"; (yyval.ll_node)->type = global_string; } #line 13112 "gram1.tab.c" /* yacc.c:1646 */ break; case 1103: #line 7446 "gram1.y" /* yacc.c:1646 */ { err("Illegal reduction operation name", 70); errcnt--; (yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL); (yyval.ll_node)->entry.string_val = (char *) "unknown"; (yyval.ll_node)->type = global_string; } #line 13123 "gram1.tab.c" /* yacc.c:1646 */ break; case 1104: #line 7456 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = make_sections((yyvsp[0].ll_node)); opt_kwd_ = NO; } #line 13132 "gram1.tab.c" /* yacc.c:1646 */ break; case 1105: #line 7461 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = make_sections(LLNULL); opt_kwd_ = NO; } #line 13141 "gram1.tab.c" /* yacc.c:1646 */ break; case 1106: #line 7467 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node),LLNULL,EXPR_LIST); } #line 13149 "gram1.tab.c" /* yacc.c:1646 */ break; case 1107: #line 7471 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-4].ll_node),(yyvsp[-1].ll_node),EXPR_LIST); } #line 13157 "gram1.tab.c" /* yacc.c:1646 */ break; case 1112: #line 7483 "gram1.y" /* yacc.c:1646 */ { PTR_LLND q; (yyval.bf_node) = make_endsections(); q = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); (yyval.bf_node)->entry.Template.ll_ptr1 = q; opt_kwd_ = NO; } #line 13169 "gram1.tab.c" /* yacc.c:1646 */ break; case 1113: #line 7491 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = make_endsections(); opt_kwd_ = NO; } #line 13178 "gram1.tab.c" /* yacc.c:1646 */ break; case 1114: #line 7497 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = make_ompsection(); } #line 13186 "gram1.tab.c" /* yacc.c:1646 */ break; case 1115: #line 7503 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,OMP_DO_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL); opt_kwd_ = NO; } #line 13195 "gram1.tab.c" /* yacc.c:1646 */ break; case 1116: #line 7508 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,OMP_DO_DIR,SMNULL,LLNULL,LLNULL,LLNULL); opt_kwd_ = NO; } #line 13204 "gram1.tab.c" /* yacc.c:1646 */ break; case 1117: #line 7514 "gram1.y" /* yacc.c:1646 */ { PTR_LLND q; q = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); (yyval.bf_node) = get_bfnd(fi,OMP_END_DO_DIR,SMNULL,q,LLNULL,LLNULL); opt_kwd_ = NO; } #line 13215 "gram1.tab.c" /* yacc.c:1646 */ break; case 1118: #line 7521 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,OMP_END_DO_DIR,SMNULL,LLNULL,LLNULL,LLNULL); opt_kwd_ = NO; } #line 13224 "gram1.tab.c" /* yacc.c:1646 */ break; case 1119: #line 7527 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node),LLNULL,EXPR_LIST); } #line 13232 "gram1.tab.c" /* yacc.c:1646 */ break; case 1120: #line 7531 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-4].ll_node),(yyvsp[-1].ll_node),EXPR_LIST); } #line 13240 "gram1.tab.c" /* yacc.c:1646 */ break; case 1127: #line 7545 "gram1.y" /* yacc.c:1646 */ { /*$$ = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL); $$->entry.string_val = (char *) "ORDERED"; $$->type = global_string;*/ (yyval.ll_node) = make_llnd(fi,OMP_ORDERED,LLNULL,LLNULL,SMNULL); } #line 13251 "gram1.tab.c" /* yacc.c:1646 */ break; case 1128: #line 7554 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,OMP_SCHEDULE,(yyvsp[-3].ll_node),(yyvsp[-1].ll_node),SMNULL); } #line 13259 "gram1.tab.c" /* yacc.c:1646 */ break; case 1129: #line 7558 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,OMP_SCHEDULE,(yyvsp[-1].ll_node),LLNULL,SMNULL); } #line 13267 "gram1.tab.c" /* yacc.c:1646 */ break; case 1130: #line 7564 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL); (yyval.ll_node)->entry.string_val = (char *) "STATIC"; (yyval.ll_node)->type = global_string; } #line 13278 "gram1.tab.c" /* yacc.c:1646 */ break; case 1131: #line 7571 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL); (yyval.ll_node)->entry.string_val = (char *) "DYNAMIC"; (yyval.ll_node)->type = global_string; } #line 13289 "gram1.tab.c" /* yacc.c:1646 */ break; case 1132: #line 7578 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL); (yyval.ll_node)->entry.string_val = (char *) "GUIDED"; (yyval.ll_node)->type = global_string; } #line 13300 "gram1.tab.c" /* yacc.c:1646 */ break; case 1133: #line 7585 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL); (yyval.ll_node)->entry.string_val = (char *) "RUNTIME"; (yyval.ll_node)->type = global_string; } #line 13311 "gram1.tab.c" /* yacc.c:1646 */ break; case 1134: #line 7594 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = make_single(); (yyval.bf_node)->entry.Template.ll_ptr1 = (yyvsp[0].ll_node); opt_kwd_ = NO; } #line 13321 "gram1.tab.c" /* yacc.c:1646 */ break; case 1135: #line 7600 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = make_single(); opt_kwd_ = NO; } #line 13330 "gram1.tab.c" /* yacc.c:1646 */ break; case 1136: #line 7606 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node),LLNULL,EXPR_LIST); } #line 13338 "gram1.tab.c" /* yacc.c:1646 */ break; case 1137: #line 7610 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-4].ll_node),(yyvsp[-1].ll_node),EXPR_LIST); } #line 13346 "gram1.tab.c" /* yacc.c:1646 */ break; case 1140: #line 7620 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = make_endsingle(); (yyval.bf_node)->entry.Template.ll_ptr1 = (yyvsp[0].ll_node); opt_kwd_ = NO; } #line 13356 "gram1.tab.c" /* yacc.c:1646 */ break; case 1141: #line 7626 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = make_endsingle(); opt_kwd_ = NO; } #line 13365 "gram1.tab.c" /* yacc.c:1646 */ break; case 1142: #line 7632 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node),LLNULL,EXPR_LIST); } #line 13373 "gram1.tab.c" /* yacc.c:1646 */ break; case 1143: #line 7636 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-4].ll_node),(yyvsp[-1].ll_node),EXPR_LIST); } #line 13381 "gram1.tab.c" /* yacc.c:1646 */ break; case 1146: #line 7647 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,OMP_COPYPRIVATE,(yyvsp[0].ll_node),LLNULL,SMNULL); } #line 13389 "gram1.tab.c" /* yacc.c:1646 */ break; case 1147: #line 7653 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,OMP_NOWAIT,LLNULL,LLNULL,SMNULL); } #line 13397 "gram1.tab.c" /* yacc.c:1646 */ break; case 1148: #line 7659 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = make_workshare(); } #line 13405 "gram1.tab.c" /* yacc.c:1646 */ break; case 1149: #line 7664 "gram1.y" /* yacc.c:1646 */ { PTR_LLND q; (yyval.bf_node) = make_endworkshare(); q = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); (yyval.bf_node)->entry.Template.ll_ptr1 = q; opt_kwd_ = NO; } #line 13417 "gram1.tab.c" /* yacc.c:1646 */ break; case 1150: #line 7672 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = make_endworkshare(); opt_kwd_ = NO; } #line 13426 "gram1.tab.c" /* yacc.c:1646 */ break; case 1151: #line 7678 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,OMP_PARALLEL_DO_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL); opt_kwd_ = NO; } #line 13435 "gram1.tab.c" /* yacc.c:1646 */ break; case 1152: #line 7683 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,OMP_PARALLEL_DO_DIR,SMNULL,LLNULL,LLNULL,LLNULL); opt_kwd_ = NO; } #line 13444 "gram1.tab.c" /* yacc.c:1646 */ break; case 1153: #line 7690 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node),LLNULL,EXPR_LIST); } #line 13452 "gram1.tab.c" /* yacc.c:1646 */ break; case 1154: #line 7694 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-4].ll_node),(yyvsp[-1].ll_node),EXPR_LIST); } #line 13460 "gram1.tab.c" /* yacc.c:1646 */ break; case 1166: #line 7714 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,OMP_END_PARALLEL_DO_DIR,SMNULL,LLNULL,LLNULL,LLNULL); } #line 13468 "gram1.tab.c" /* yacc.c:1646 */ break; case 1167: #line 7719 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = make_parallelsections((yyvsp[0].ll_node)); opt_kwd_ = NO; } #line 13477 "gram1.tab.c" /* yacc.c:1646 */ break; case 1168: #line 7724 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = make_parallelsections(LLNULL); opt_kwd_ = NO; } #line 13486 "gram1.tab.c" /* yacc.c:1646 */ break; case 1169: #line 7731 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = make_endparallelsections(); } #line 13494 "gram1.tab.c" /* yacc.c:1646 */ break; case 1170: #line 7736 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = make_parallelworkshare(); (yyval.bf_node)->entry.Template.ll_ptr1 = (yyvsp[0].ll_node); opt_kwd_ = NO; } #line 13504 "gram1.tab.c" /* yacc.c:1646 */ break; case 1171: #line 7742 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = make_parallelworkshare(); opt_kwd_ = NO; } #line 13513 "gram1.tab.c" /* yacc.c:1646 */ break; case 1172: #line 7748 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = make_endparallelworkshare(); } #line 13521 "gram1.tab.c" /* yacc.c:1646 */ break; case 1173: #line 7753 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,OMP_THREADPRIVATE_DIR, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL); } #line 13529 "gram1.tab.c" /* yacc.c:1646 */ break; case 1174: #line 7758 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = make_master(); } #line 13537 "gram1.tab.c" /* yacc.c:1646 */ break; case 1175: #line 7763 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = make_endmaster(); } #line 13545 "gram1.tab.c" /* yacc.c:1646 */ break; case 1176: #line 7767 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = make_ordered(); } #line 13553 "gram1.tab.c" /* yacc.c:1646 */ break; case 1177: #line 7772 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = make_endordered(); } #line 13561 "gram1.tab.c" /* yacc.c:1646 */ break; case 1178: #line 7777 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,OMP_BARRIER_DIR,SMNULL,LLNULL,LLNULL,LLNULL); } #line 13569 "gram1.tab.c" /* yacc.c:1646 */ break; case 1179: #line 7781 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,OMP_ATOMIC_DIR,SMNULL,LLNULL,LLNULL,LLNULL); } #line 13577 "gram1.tab.c" /* yacc.c:1646 */ break; case 1180: #line 7786 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,OMP_FLUSH_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL); } #line 13585 "gram1.tab.c" /* yacc.c:1646 */ break; case 1181: #line 7790 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,OMP_FLUSH_DIR,SMNULL,LLNULL,LLNULL,LLNULL); } #line 13593 "gram1.tab.c" /* yacc.c:1646 */ break; case 1182: #line 7796 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = make_critical(); (yyval.bf_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node); } #line 13602 "gram1.tab.c" /* yacc.c:1646 */ break; case 1183: #line 7801 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = make_critical(); } #line 13610 "gram1.tab.c" /* yacc.c:1646 */ break; case 1184: #line 7807 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = make_endcritical(); (yyval.bf_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node); } #line 13619 "gram1.tab.c" /* yacc.c:1646 */ break; case 1185: #line 7812 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = make_endcritical(); } #line 13627 "gram1.tab.c" /* yacc.c:1646 */ break; case 1186: #line 7818 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; PTR_LLND l; s = make_common((yyvsp[-3].hash_entry)); l = make_llnd(fi,VAR_REF, LLNULL, LLNULL, s); (yyval.ll_node) = make_llnd(fi,OMP_THREADPRIVATE, l, LLNULL, SMNULL); } #line 13639 "gram1.tab.c" /* yacc.c:1646 */ break; case 1187: #line 7828 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); } #line 13647 "gram1.tab.c" /* yacc.c:1646 */ break; case 1188: #line 7832 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); } #line 13655 "gram1.tab.c" /* yacc.c:1646 */ break; case 1189: #line 7836 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); } #line 13663 "gram1.tab.c" /* yacc.c:1646 */ break; case 1190: #line 7840 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); } #line 13671 "gram1.tab.c" /* yacc.c:1646 */ break; case 1191: #line 7845 "gram1.y" /* yacc.c:1646 */ { operator_slash = 1; } #line 13679 "gram1.tab.c" /* yacc.c:1646 */ break; case 1192: #line 7848 "gram1.y" /* yacc.c:1646 */ { operator_slash = 0; } #line 13687 "gram1.tab.c" /* yacc.c:1646 */ break; case 1201: #line 7864 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,ACC_REGION_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL);} #line 13693 "gram1.tab.c" /* yacc.c:1646 */ break; case 1202: #line 7868 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,ACC_CHECKSECTION_DIR,SMNULL,LLNULL,LLNULL,LLNULL);} #line 13699 "gram1.tab.c" /* yacc.c:1646 */ break; case 1203: #line 7872 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,ACC_GET_ACTUAL_DIR,SMNULL,(yyvsp[-1].ll_node),LLNULL,LLNULL);} #line 13705 "gram1.tab.c" /* yacc.c:1646 */ break; case 1204: #line 7874 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,ACC_GET_ACTUAL_DIR,SMNULL,LLNULL,LLNULL,LLNULL);} #line 13711 "gram1.tab.c" /* yacc.c:1646 */ break; case 1205: #line 7876 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,ACC_GET_ACTUAL_DIR,SMNULL,LLNULL,LLNULL,LLNULL);} #line 13717 "gram1.tab.c" /* yacc.c:1646 */ break; case 1206: #line 7880 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,ACC_ACTUAL_DIR,SMNULL,(yyvsp[-1].ll_node),LLNULL,LLNULL);} #line 13723 "gram1.tab.c" /* yacc.c:1646 */ break; case 1207: #line 7882 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,ACC_ACTUAL_DIR,SMNULL,LLNULL,LLNULL,LLNULL);} #line 13729 "gram1.tab.c" /* yacc.c:1646 */ break; case 1208: #line 7884 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,ACC_ACTUAL_DIR,SMNULL,LLNULL,LLNULL,LLNULL);} #line 13735 "gram1.tab.c" /* yacc.c:1646 */ break; case 1209: #line 7888 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = LLNULL;} #line 13741 "gram1.tab.c" /* yacc.c:1646 */ break; case 1210: #line 7890 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node); } #line 13747 "gram1.tab.c" /* yacc.c:1646 */ break; case 1211: #line 7894 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); } #line 13753 "gram1.tab.c" /* yacc.c:1646 */ break; case 1212: #line 7896 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); } #line 13759 "gram1.tab.c" /* yacc.c:1646 */ break; case 1213: #line 7900 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node);} #line 13765 "gram1.tab.c" /* yacc.c:1646 */ break; case 1214: #line 7903 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node);} #line 13771 "gram1.tab.c" /* yacc.c:1646 */ break; case 1215: #line 7906 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node);} #line 13777 "gram1.tab.c" /* yacc.c:1646 */ break; case 1216: #line 7911 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,ACC_INOUT_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);} #line 13783 "gram1.tab.c" /* yacc.c:1646 */ break; case 1217: #line 7913 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,ACC_IN_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);} #line 13789 "gram1.tab.c" /* yacc.c:1646 */ break; case 1218: #line 7915 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,ACC_OUT_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);} #line 13795 "gram1.tab.c" /* yacc.c:1646 */ break; case 1219: #line 7917 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,ACC_LOCAL_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);} #line 13801 "gram1.tab.c" /* yacc.c:1646 */ break; case 1220: #line 7919 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,ACC_INLOCAL_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);} #line 13807 "gram1.tab.c" /* yacc.c:1646 */ break; case 1221: #line 7923 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,ACC_TARGETS_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);} #line 13813 "gram1.tab.c" /* yacc.c:1646 */ break; case 1222: #line 7927 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,ACC_ASYNC_OP,LLNULL,LLNULL,SMNULL);} #line 13819 "gram1.tab.c" /* yacc.c:1646 */ break; case 1223: #line 7932 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node);} #line 13825 "gram1.tab.c" /* yacc.c:1646 */ break; case 1224: #line 7936 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); } #line 13831 "gram1.tab.c" /* yacc.c:1646 */ break; case 1225: #line 7938 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); } #line 13837 "gram1.tab.c" /* yacc.c:1646 */ break; case 1226: #line 7942 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,ACC_HOST_OP, LLNULL,LLNULL,SMNULL);} #line 13843 "gram1.tab.c" /* yacc.c:1646 */ break; case 1227: #line 7944 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,ACC_CUDA_OP, LLNULL,LLNULL,SMNULL);} #line 13849 "gram1.tab.c" /* yacc.c:1646 */ break; case 1228: #line 7948 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,ACC_END_REGION_DIR,SMNULL,LLNULL,LLNULL,LLNULL);} #line 13855 "gram1.tab.c" /* yacc.c:1646 */ break; case 1229: #line 7952 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,ACC_END_CHECKSECTION_DIR,SMNULL,LLNULL,LLNULL,LLNULL);} #line 13861 "gram1.tab.c" /* yacc.c:1646 */ break; case 1230: #line 7956 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,ACC_DECLARE_DIR, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL); } #line 13869 "gram1.tab.c" /* yacc.c:1646 */ break; case 1231: #line 7961 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL); } #line 13875 "gram1.tab.c" /* yacc.c:1646 */ break; case 1232: #line 7963 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); } #line 13881 "gram1.tab.c" /* yacc.c:1646 */ break; case 1233: #line 7967 "gram1.y" /* yacc.c:1646 */ { PTR_SYMB s; s = make_scalar((yyvsp[0].hash_entry),TYNULL,LOCAL); if((s->attr & PROCESSORS_BIT) ||(s->attr & TASK_BIT) || (s->attr & TEMPLATE_BIT) || (s->attr & ALIGN_BIT) || (s->attr & DISTRIBUTE_BIT) || (s->attr & DYNAMIC_BIT) || (s->attr & HEAP_BIT)|| (s->attr & DVM_POINTER_BIT) || (s->attr & INHERIT_BIT) ||(s->attr & SHADOW_BIT)) errstr("Inconsistent declaration of identifier %s", s->ident, 16); (yyval.ll_node) = make_llnd(fi,VAR_REF, LLNULL, LLNULL, s); } #line 13893 "gram1.tab.c" /* yacc.c:1646 */ break; case 1234: #line 7977 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,ACC_ROUTINE_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL);} #line 13899 "gram1.tab.c" /* yacc.c:1646 */ break; case 1235: #line 7981 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = LLNULL;} #line 13905 "gram1.tab.c" /* yacc.c:1646 */ break; case 1236: #line 7983 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node);} #line 13911 "gram1.tab.c" /* yacc.c:1646 */ break; case 1237: #line 7987 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); } #line 13917 "gram1.tab.c" /* yacc.c:1646 */ break; case 1238: #line 7989 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node),(yyvsp[0].ll_node),EXPR_LIST); } #line 13923 "gram1.tab.c" /* yacc.c:1646 */ break; case 1239: #line 7993 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,ACC_PRIVATE_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);} #line 13929 "gram1.tab.c" /* yacc.c:1646 */ break; case 1240: #line 7995 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[0].ll_node);} #line 13935 "gram1.tab.c" /* yacc.c:1646 */ break; case 1247: #line 8006 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,SPF_ANALYSIS_DIR,SMNULL,(yyvsp[-1].ll_node),LLNULL,LLNULL);} #line 13941 "gram1.tab.c" /* yacc.c:1646 */ break; case 1248: #line 8010 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,SPF_PARALLEL_DIR,SMNULL,(yyvsp[-1].ll_node),LLNULL,LLNULL);} #line 13947 "gram1.tab.c" /* yacc.c:1646 */ break; case 1249: #line 8014 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,SPF_TRANSFORM_DIR,SMNULL,(yyvsp[-1].ll_node),LLNULL,LLNULL);} #line 13953 "gram1.tab.c" /* yacc.c:1646 */ break; case 1250: #line 8018 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,SPF_PARALLEL_REG_DIR,(yyvsp[0].symbol),LLNULL,LLNULL,LLNULL);} #line 13959 "gram1.tab.c" /* yacc.c:1646 */ break; case 1251: #line 8020 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,SPF_PARALLEL_REG_DIR,(yyvsp[-7].symbol),(yyvsp[-2].ll_node),(yyvsp[0].ll_node),LLNULL);} #line 13965 "gram1.tab.c" /* yacc.c:1646 */ break; case 1252: #line 8022 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,SPF_PARALLEL_REG_DIR,(yyvsp[-7].symbol),(yyvsp[0].ll_node),(yyvsp[-2].ll_node),LLNULL);} #line 13971 "gram1.tab.c" /* yacc.c:1646 */ break; case 1253: #line 8026 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); } #line 13977 "gram1.tab.c" /* yacc.c:1646 */ break; case 1254: #line 8028 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); } #line 13983 "gram1.tab.c" /* yacc.c:1646 */ break; case 1255: #line 8032 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,SPF_CODE_COVERAGE_OP,LLNULL,LLNULL,SMNULL);} #line 13989 "gram1.tab.c" /* yacc.c:1646 */ break; case 1256: #line 8036 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = LLNULL;} #line 13995 "gram1.tab.c" /* yacc.c:1646 */ break; case 1257: #line 8038 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[-1].ll_node);} #line 14001 "gram1.tab.c" /* yacc.c:1646 */ break; case 1258: #line 8042 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = LLNULL;} #line 14007 "gram1.tab.c" /* yacc.c:1646 */ break; case 1259: #line 8044 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = (yyvsp[-1].ll_node);} #line 14013 "gram1.tab.c" /* yacc.c:1646 */ break; case 1260: #line 8048 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,SPF_END_PARALLEL_REG_DIR,SMNULL,LLNULL,LLNULL,LLNULL);} #line 14019 "gram1.tab.c" /* yacc.c:1646 */ break; case 1261: #line 8052 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); } #line 14025 "gram1.tab.c" /* yacc.c:1646 */ break; case 1262: #line 8054 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); } #line 14031 "gram1.tab.c" /* yacc.c:1646 */ break; case 1268: #line 8065 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,REDUCTION_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL); } #line 14037 "gram1.tab.c" /* yacc.c:1646 */ break; case 1269: #line 8069 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,ACC_PRIVATE_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);} #line 14043 "gram1.tab.c" /* yacc.c:1646 */ break; case 1270: #line 8073 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,SPF_PROCESS_PRIVATE_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);} #line 14049 "gram1.tab.c" /* yacc.c:1646 */ break; case 1271: #line 8077 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,SPF_COVER_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);} #line 14055 "gram1.tab.c" /* yacc.c:1646 */ break; case 1272: #line 8081 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,SPF_PARAMETER_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);} #line 14061 "gram1.tab.c" /* yacc.c:1646 */ break; case 1273: #line 8084 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); } #line 14067 "gram1.tab.c" /* yacc.c:1646 */ break; case 1274: #line 8086 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); } #line 14073 "gram1.tab.c" /* yacc.c:1646 */ break; case 1275: #line 8090 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi, ASSGN_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), SMNULL); } #line 14079 "gram1.tab.c" /* yacc.c:1646 */ break; case 1276: #line 8094 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); } #line 14085 "gram1.tab.c" /* yacc.c:1646 */ break; case 1277: #line 8096 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); } #line 14091 "gram1.tab.c" /* yacc.c:1646 */ break; case 1281: #line 8105 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,SHADOW_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);} #line 14097 "gram1.tab.c" /* yacc.c:1646 */ break; case 1282: #line 8109 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,ACROSS_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);} #line 14103 "gram1.tab.c" /* yacc.c:1646 */ break; case 1283: #line 8113 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,REMOTE_ACCESS_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);} #line 14109 "gram1.tab.c" /* yacc.c:1646 */ break; case 1284: #line 8117 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); } #line 14115 "gram1.tab.c" /* yacc.c:1646 */ break; case 1285: #line 8119 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); } #line 14121 "gram1.tab.c" /* yacc.c:1646 */ break; case 1286: #line 8123 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,SPF_NOINLINE_OP,LLNULL,LLNULL,SMNULL);} #line 14127 "gram1.tab.c" /* yacc.c:1646 */ break; case 1287: #line 8125 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,SPF_FISSION_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);} #line 14133 "gram1.tab.c" /* yacc.c:1646 */ break; case 1288: #line 8127 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,SPF_EXPAND_OP,LLNULL,LLNULL,SMNULL);} #line 14139 "gram1.tab.c" /* yacc.c:1646 */ break; case 1289: #line 8129 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,SPF_EXPAND_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);} #line 14145 "gram1.tab.c" /* yacc.c:1646 */ break; case 1290: #line 8132 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,SPF_SHRINK_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);} #line 14151 "gram1.tab.c" /* yacc.c:1646 */ break; case 1291: #line 8134 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,SPF_UNROLL_OP,LLNULL,LLNULL,SMNULL);} #line 14157 "gram1.tab.c" /* yacc.c:1646 */ break; case 1292: #line 8136 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,SPF_UNROLL_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);} #line 14163 "gram1.tab.c" /* yacc.c:1646 */ break; case 1293: #line 8138 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,SPF_MERGE_OP,LLNULL,LLNULL,SMNULL);} #line 14169 "gram1.tab.c" /* yacc.c:1646 */ break; case 1294: #line 8142 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-4].ll_node), (yyvsp[-2].ll_node), EXPR_LIST); (yyval.ll_node) = set_ll_list((yyval.ll_node), (yyvsp[0].ll_node), EXPR_LIST); } #line 14178 "gram1.tab.c" /* yacc.c:1646 */ break; case 1295: #line 8149 "gram1.y" /* yacc.c:1646 */ { (yyval.symbol) = make_parallel_region((yyvsp[0].hash_entry));} #line 14184 "gram1.tab.c" /* yacc.c:1646 */ break; case 1296: #line 8153 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); } #line 14190 "gram1.tab.c" /* yacc.c:1646 */ break; case 1297: #line 8155 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); } #line 14196 "gram1.tab.c" /* yacc.c:1646 */ break; case 1298: #line 8159 "gram1.y" /* yacc.c:1646 */ { (yyval.bf_node) = get_bfnd(fi,SPF_CHECKPOINT_DIR,SMNULL,(yyvsp[-1].ll_node),LLNULL,LLNULL);} #line 14202 "gram1.tab.c" /* yacc.c:1646 */ break; case 1299: #line 8163 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); } #line 14208 "gram1.tab.c" /* yacc.c:1646 */ break; case 1300: #line 8165 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); } #line 14214 "gram1.tab.c" /* yacc.c:1646 */ break; case 1301: #line 8169 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,SPF_TYPE_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);} #line 14220 "gram1.tab.c" /* yacc.c:1646 */ break; case 1302: #line 8171 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,SPF_VARLIST_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);} #line 14226 "gram1.tab.c" /* yacc.c:1646 */ break; case 1303: #line 8173 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,SPF_EXCEPT_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);} #line 14232 "gram1.tab.c" /* yacc.c:1646 */ break; case 1304: #line 8175 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,SPF_FILES_COUNT_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);} #line 14238 "gram1.tab.c" /* yacc.c:1646 */ break; case 1305: #line 8177 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,SPF_INTERVAL_OP,(yyvsp[-3].ll_node),(yyvsp[-1].ll_node),SMNULL);} #line 14244 "gram1.tab.c" /* yacc.c:1646 */ break; case 1306: #line 8181 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); } #line 14250 "gram1.tab.c" /* yacc.c:1646 */ break; case 1307: #line 8183 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); } #line 14256 "gram1.tab.c" /* yacc.c:1646 */ break; case 1308: #line 8187 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,ACC_ASYNC_OP, LLNULL,LLNULL,SMNULL);} #line 14262 "gram1.tab.c" /* yacc.c:1646 */ break; case 1309: #line 8189 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,SPF_FLEXIBLE_OP, LLNULL,LLNULL,SMNULL);} #line 14268 "gram1.tab.c" /* yacc.c:1646 */ break; case 1310: #line 8193 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,SPF_TIME_OP, LLNULL,LLNULL,SMNULL);} #line 14274 "gram1.tab.c" /* yacc.c:1646 */ break; case 1311: #line 8195 "gram1.y" /* yacc.c:1646 */ { (yyval.ll_node) = make_llnd(fi,SPF_ITER_OP, LLNULL,LLNULL,SMNULL);} #line 14280 "gram1.tab.c" /* yacc.c:1646 */ break; case 1312: #line 8199 "gram1.y" /* yacc.c:1646 */ { if(position==IN_OUTSIDE) err("Misplaced SPF-directive",103); } #line 14288 "gram1.tab.c" /* yacc.c:1646 */ break; #line 14292 "gram1.tab.c" /* yacc.c:1646 */ default: break; } /* User semantic actions sometimes alter yychar, and that requires that yytoken be updated with the new translation. We take the approach of translating immediately before every use of yytoken. One alternative is translating here after every semantic action, but that translation would be missed if the semantic action invokes YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an incorrect destructor might then be invoked immediately. In the case of YYERROR or YYBACKUP, subsequent parser actions might lead to an incorrect destructor call or verbose syntax error message before the lookahead is translated. */ YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); YYPOPSTACK (yylen); yylen = 0; YY_STACK_PRINT (yyss, yyssp); *++yyvsp = yyval; /* Now 'shift' the result of the reduction. Determine what state that goes to, based on the state we popped back to and the rule number reduced by. */ yyn = yyr1[yyn]; yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) yystate = yytable[yystate]; else yystate = yydefgoto[yyn - YYNTOKENS]; goto yynewstate; /*--------------------------------------. | yyerrlab -- here on detecting error. | `--------------------------------------*/ yyerrlab: /* Make sure we have latest lookahead translation. See comments at user semantic actions for why this is necessary. */ yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar); /* If not already recovering from an error, report this error. */ if (!yyerrstatus) { ++yynerrs; #if ! YYERROR_VERBOSE yyerror (YY_("syntax error")); #else # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \ yyssp, yytoken) { char const *yymsgp = YY_("syntax error"); int yysyntax_error_status; yysyntax_error_status = YYSYNTAX_ERROR; if (yysyntax_error_status == 0) yymsgp = yymsg; else if (yysyntax_error_status == 1) { if (yymsg != yymsgbuf) YYSTACK_FREE (yymsg); yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc); if (!yymsg) { yymsg = yymsgbuf; yymsg_alloc = sizeof yymsgbuf; yysyntax_error_status = 2; } else { yysyntax_error_status = YYSYNTAX_ERROR; yymsgp = yymsg; } } yyerror (yymsgp); if (yysyntax_error_status == 2) goto yyexhaustedlab; } # undef YYSYNTAX_ERROR #endif } if (yyerrstatus == 3) { /* If just tried and failed to reuse lookahead token after an error, discard it. */ if (yychar <= YYEOF) { /* Return failure if at end of input. */ if (yychar == YYEOF) YYABORT; } else { yydestruct ("Error: discarding", yytoken, &yylval); yychar = YYEMPTY; } } /* Else will try to reuse lookahead token after shifting the error token. */ goto yyerrlab1; /*---------------------------------------------------. | yyerrorlab -- error raised explicitly by YYERROR. | `---------------------------------------------------*/ yyerrorlab: /* Pacify compilers like GCC when the user code never invokes YYERROR and the label yyerrorlab therefore never appears in user code. */ if (/*CONSTCOND*/ 0) goto yyerrorlab; /* Do not reclaim the symbols of the rule whose action triggered this YYERROR. */ YYPOPSTACK (yylen); yylen = 0; YY_STACK_PRINT (yyss, yyssp); yystate = *yyssp; goto yyerrlab1; /*-------------------------------------------------------------. | yyerrlab1 -- common code for both syntax error and YYERROR. | `-------------------------------------------------------------*/ yyerrlab1: yyerrstatus = 3; /* Each real token shifted decrements this. */ for (;;) { yyn = yypact[yystate]; if (!yypact_value_is_default (yyn)) { yyn += YYTERROR; if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) { yyn = yytable[yyn]; if (0 < yyn) break; } } /* Pop the current state because it cannot handle the error token. */ if (yyssp == yyss) YYABORT; yydestruct ("Error: popping", yystos[yystate], yyvsp); YYPOPSTACK (1); yystate = *yyssp; YY_STACK_PRINT (yyss, yyssp); } YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN *++yyvsp = yylval; YY_IGNORE_MAYBE_UNINITIALIZED_END /* Shift the error token. */ YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); yystate = yyn; goto yynewstate; /*-------------------------------------. | yyacceptlab -- YYACCEPT comes here. | `-------------------------------------*/ yyacceptlab: yyresult = 0; goto yyreturn; /*-----------------------------------. | yyabortlab -- YYABORT comes here. | `-----------------------------------*/ yyabortlab: yyresult = 1; goto yyreturn; #if !defined yyoverflow || YYERROR_VERBOSE /*-------------------------------------------------. | yyexhaustedlab -- memory exhaustion comes here. | `-------------------------------------------------*/ yyexhaustedlab: yyerror (YY_("memory exhausted")); yyresult = 2; /* Fall through. */ #endif yyreturn: if (yychar != YYEMPTY) { /* Make sure we have latest lookahead translation. See comments at user semantic actions for why this is necessary. */ yytoken = YYTRANSLATE (yychar); yydestruct ("Cleanup: discarding lookahead", yytoken, &yylval); } /* Do not reclaim the symbols of the rule whose action triggered this YYABORT or YYACCEPT. */ YYPOPSTACK (yylen); YY_STACK_PRINT (yyss, yyssp); while (yyssp != yyss) { yydestruct ("Cleanup: popping", yystos[*yyssp], yyvsp); YYPOPSTACK (1); } #ifndef yyoverflow if (yyss != yyssa) YYSTACK_FREE (yyss); #endif #if YYERROR_VERBOSE if (yymsg != yymsgbuf) YYSTACK_FREE (yymsg); #endif return yyresult; }