14475 lines
561 KiB
C
14475 lines
561 KiB
C
/* 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 <http://www.gnu.org/licenses/>. */
|
|
|
|
/* 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 359 "gram1.y" /* yacc.c:339 */
|
|
|
|
#include <string.h>
|
|
#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 <alloca.h>
|
|
#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,
|
|
SPF_WEIGHT = 357,
|
|
BINARY_OP = 360,
|
|
UNARY_OP = 361
|
|
};
|
|
#endif
|
|
|
|
/* Value type. */
|
|
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
|
|
|
|
union YYSTYPE
|
|
{
|
|
#line 440 "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 561 "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 650 "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 723 "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 <stddef.h> /* 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 <libintl.h> /* 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 <alloca.h> /* INFRINGES ON USER NAME SPACE */
|
|
# elif defined _AIX
|
|
# define YYSTACK_ALLOC __alloca
|
|
# elif defined _MSC_VER
|
|
# include <malloc.h> /* INFRINGES ON USER NAME SPACE */
|
|
# define alloca _alloca
|
|
# else
|
|
# define YYSTACK_ALLOC alloca
|
|
# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
|
|
# include <stdlib.h> /* 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 <stdlib.h> /* 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 5655
|
|
|
|
/* YYNTOKENS -- Number of terminals. */
|
|
#define YYNTOKENS 362
|
|
/* YYNNTS -- Number of nonterminals. */
|
|
#define YYNNTS 547
|
|
/* YYNRULES -- Number of rules. */
|
|
#define YYNRULES 1313
|
|
/* YYNSTATES -- Number of states. */
|
|
#define YYNSTATES 2617
|
|
|
|
/* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
|
|
by yylex, with out-of-bounds checking. */
|
|
#define YYUNDEFTOK 2
|
|
#define YYMAXUTOK 361
|
|
|
|
#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, 359, 1, 2,
|
|
360, 361
|
|
};
|
|
|
|
#if YYDEBUG
|
|
/* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
|
|
static const yytype_uint16 yyrline[] =
|
|
{
|
|
0, 797, 797, 798, 802, 804, 818, 849, 858, 864,
|
|
884, 893, 909, 921, 931, 938, 944, 949, 954, 978,
|
|
1005, 1019, 1021, 1023, 1027, 1044, 1058, 1082, 1098, 1112,
|
|
1130, 1132, 1139, 1143, 1144, 1151, 1152, 1160, 1161, 1163,
|
|
1167, 1168, 1172, 1176, 1182, 1192, 1196, 1201, 1208, 1209,
|
|
1210, 1211, 1212, 1213, 1214, 1215, 1216, 1217, 1218, 1219,
|
|
1220, 1221, 1222, 1227, 1232, 1239, 1241, 1242, 1243, 1244,
|
|
1245, 1246, 1247, 1248, 1249, 1250, 1251, 1252, 1255, 1259,
|
|
1267, 1275, 1284, 1292, 1296, 1298, 1302, 1304, 1306, 1308,
|
|
1310, 1312, 1314, 1316, 1318, 1320, 1322, 1324, 1326, 1328,
|
|
1330, 1332, 1334, 1336, 1341, 1350, 1360, 1368, 1378, 1399,
|
|
1419, 1420, 1422, 1426, 1428, 1432, 1436, 1438, 1442, 1448,
|
|
1452, 1454, 1458, 1462, 1466, 1470, 1474, 1480, 1484, 1488,
|
|
1494, 1499, 1506, 1517, 1530, 1541, 1554, 1564, 1577, 1582,
|
|
1589, 1592, 1597, 1602, 1609, 1612, 1622, 1636, 1639, 1658,
|
|
1685, 1687, 1699, 1707, 1708, 1709, 1710, 1711, 1712, 1713,
|
|
1718, 1719, 1723, 1725, 1732, 1737, 1738, 1740, 1742, 1755,
|
|
1761, 1767, 1776, 1785, 1798, 1799, 1802, 1806, 1821, 1836,
|
|
1854, 1875, 1895, 1917, 1934, 1952, 1959, 1966, 1973, 1986,
|
|
1993, 2000, 2011, 2015, 2017, 2022, 2040, 2051, 2063, 2075,
|
|
2089, 2095, 2102, 2108, 2114, 2122, 2129, 2145, 2148, 2157,
|
|
2159, 2163, 2167, 2187, 2191, 2193, 2197, 2198, 2201, 2203,
|
|
2205, 2207, 2209, 2212, 2215, 2219, 2225, 2229, 2233, 2235,
|
|
2240, 2241, 2245, 2249, 2251, 2255, 2257, 2259, 2264, 2268,
|
|
2270, 2272, 2275, 2277, 2278, 2279, 2280, 2281, 2282, 2283,
|
|
2284, 2287, 2288, 2294, 2297, 2298, 2300, 2304, 2305, 2308,
|
|
2309, 2311, 2315, 2316, 2317, 2318, 2320, 2323, 2324, 2333,
|
|
2335, 2342, 2349, 2356, 2365, 2367, 2369, 2373, 2375, 2379,
|
|
2388, 2395, 2402, 2404, 2408, 2412, 2418, 2420, 2425, 2429,
|
|
2433, 2440, 2447, 2457, 2459, 2463, 2475, 2478, 2487, 2500,
|
|
2506, 2512, 2518, 2526, 2536, 2538, 2542, 2544, 2577, 2579,
|
|
2583, 2622, 2623, 2627, 2627, 2632, 2636, 2644, 2653, 2662,
|
|
2672, 2678, 2681, 2683, 2687, 2695, 2710, 2717, 2719, 2723,
|
|
2739, 2739, 2743, 2745, 2757, 2759, 2763, 2769, 2781, 2793,
|
|
2810, 2839, 2840, 2848, 2849, 2853, 2855, 2857, 2868, 2872,
|
|
2878, 2880, 2884, 2886, 2888, 2892, 2894, 2898, 2900, 2902,
|
|
2904, 2906, 2908, 2910, 2912, 2914, 2916, 2918, 2920, 2922,
|
|
2924, 2926, 2928, 2930, 2932, 2934, 2936, 2938, 2940, 2942,
|
|
2946, 2947, 2958, 3032, 3044, 3046, 3050, 3181, 3231, 3275,
|
|
3317, 3375, 3377, 3379, 3418, 3461, 3472, 3473, 3477, 3482,
|
|
3483, 3487, 3489, 3495, 3497, 3503, 3516, 3522, 3529, 3535,
|
|
3543, 3551, 3567, 3577, 3590, 3597, 3599, 3622, 3624, 3626,
|
|
3628, 3630, 3632, 3634, 3636, 3640, 3640, 3640, 3654, 3656,
|
|
3679, 3681, 3683, 3699, 3701, 3703, 3717, 3720, 3722, 3730,
|
|
3732, 3734, 3736, 3790, 3810, 3825, 3834, 3837, 3887, 3893,
|
|
3898, 3916, 3918, 3920, 3922, 3924, 3927, 3933, 3935, 3937,
|
|
3940, 3942, 3944, 3971, 3980, 3989, 3990, 3992, 3997, 4004,
|
|
4012, 4014, 4018, 4021, 4023, 4027, 4033, 4035, 4037, 4039,
|
|
4043, 4045, 4054, 4055, 4062, 4063, 4067, 4071, 4092, 4095,
|
|
4099, 4101, 4108, 4113, 4114, 4125, 4137, 4160, 4185, 4186,
|
|
4193, 4195, 4197, 4199, 4201, 4205, 4282, 4294, 4301, 4303,
|
|
4304, 4306, 4315, 4322, 4329, 4337, 4342, 4347, 4350, 4353,
|
|
4356, 4359, 4362, 4366, 4384, 4389, 4408, 4427, 4431, 4432,
|
|
4435, 4439, 4444, 4451, 4453, 4455, 4459, 4460, 4471, 4486,
|
|
4490, 4497, 4500, 4510, 4523, 4536, 4539, 4541, 4544, 4547,
|
|
4551, 4560, 4563, 4567, 4569, 4575, 4579, 4581, 4583, 4590,
|
|
4594, 4596, 4600, 4602, 4606, 4625, 4641, 4650, 4659, 4661,
|
|
4665, 4691, 4706, 4721, 4738, 4746, 4755, 4763, 4768, 4773,
|
|
4795, 4811, 4813, 4817, 4819, 4826, 4828, 4830, 4834, 4836,
|
|
4838, 4840, 4842, 4844, 4848, 4851, 4854, 4860, 4866, 4875,
|
|
4879, 4886, 4888, 4892, 4894, 4896, 4901, 4906, 4911, 4916,
|
|
4925, 4930, 4936, 4937, 4952, 4953, 4954, 4955, 4956, 4957,
|
|
4958, 4959, 4960, 4961, 4962, 4963, 4964, 4965, 4966, 4967,
|
|
4968, 4969, 4970, 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, 5016, 5020, 5022, 5033,
|
|
5054, 5058, 5060, 5064, 5077, 5081, 5083, 5087, 5098, 5109,
|
|
5113, 5115, 5119, 5121, 5123, 5138, 5150, 5170, 5190, 5212,
|
|
5218, 5227, 5235, 5241, 5249, 5256, 5262, 5271, 5275, 5281,
|
|
5289, 5303, 5317, 5322, 5338, 5353, 5381, 5383, 5387, 5389,
|
|
5393, 5422, 5445, 5466, 5467, 5471, 5492, 5494, 5498, 5506,
|
|
5510, 5515, 5517, 5519, 5521, 5527, 5529, 5533, 5543, 5547,
|
|
5549, 5554, 5556, 5560, 5564, 5570, 5580, 5582, 5586, 5588,
|
|
5590, 5597, 5615, 5616, 5620, 5622, 5626, 5633, 5643, 5672,
|
|
5687, 5694, 5712, 5714, 5718, 5732, 5758, 5771, 5787, 5789,
|
|
5792, 5794, 5800, 5804, 5832, 5834, 5838, 5846, 5852, 5855,
|
|
5913, 5977, 5979, 5982, 5986, 5990, 5994, 6011, 6023, 6027,
|
|
6031, 6041, 6046, 6051, 6058, 6067, 6067, 6078, 6089, 6091,
|
|
6095, 6106, 6110, 6112, 6116, 6127, 6131, 6133, 6137, 6149,
|
|
6151, 6158, 6160, 6164, 6180, 6188, 6199, 6201, 6205, 6208,
|
|
6213, 6223, 6225, 6229, 6231, 6240, 6241, 6245, 6247, 6252,
|
|
6253, 6254, 6255, 6256, 6257, 6258, 6259, 6260, 6261, 6262,
|
|
6265, 6270, 6274, 6278, 6282, 6295, 6299, 6303, 6307, 6310,
|
|
6312, 6314, 6318, 6320, 6324, 6328, 6330, 6334, 6339, 6343,
|
|
6347, 6349, 6353, 6362, 6365, 6371, 6378, 6381, 6383, 6387,
|
|
6389, 6393, 6405, 6407, 6411, 6415, 6417, 6421, 6423, 6425,
|
|
6427, 6429, 6431, 6433, 6437, 6441, 6445, 6449, 6453, 6460,
|
|
6466, 6471, 6474, 6477, 6490, 6492, 6496, 6498, 6503, 6509,
|
|
6515, 6521, 6527, 6533, 6539, 6545, 6551, 6560, 6566, 6583,
|
|
6585, 6593, 6601, 6603, 6607, 6611, 6613, 6617, 6619, 6627,
|
|
6631, 6643, 6646, 6664, 6666, 6670, 6672, 6676, 6678, 6682,
|
|
6686, 6690, 6699, 6703, 6707, 6712, 6716, 6728, 6730, 6734,
|
|
6739, 6743, 6745, 6749, 6751, 6755, 6760, 6767, 6790, 6792,
|
|
6794, 6796, 6798, 6802, 6813, 6817, 6832, 6839, 6846, 6847,
|
|
6851, 6855, 6863, 6867, 6871, 6879, 6884, 6898, 6900, 6904,
|
|
6906, 6915, 6917, 6919, 6921, 6957, 6961, 6965, 6969, 6973,
|
|
6985, 6987, 6991, 6994, 6996, 7000, 7005, 7012, 7015, 7023,
|
|
7027, 7032, 7034, 7041, 7046, 7050, 7054, 7058, 7062, 7066,
|
|
7069, 7071, 7075, 7077, 7079, 7083, 7087, 7099, 7101, 7105,
|
|
7107, 7111, 7114, 7117, 7121, 7127, 7139, 7141, 7145, 7147,
|
|
7151, 7159, 7171, 7172, 7174, 7178, 7182, 7184, 7192, 7196,
|
|
7199, 7201, 7205, 7209, 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, 7236,
|
|
7239, 7245, 7251, 7257, 7263, 7267, 7273, 7274, 7275, 7276,
|
|
7277, 7278, 7279, 7280, 7281, 7284, 7289, 7294, 7300, 7306,
|
|
7312, 7317, 7323, 7329, 7335, 7342, 7348, 7354, 7361, 7365,
|
|
7367, 7373, 7380, 7386, 7392, 7398, 7404, 7410, 7416, 7422,
|
|
7428, 7434, 7440, 7446, 7456, 7461, 7467, 7471, 7477, 7478,
|
|
7479, 7480, 7483, 7491, 7497, 7503, 7508, 7514, 7521, 7527,
|
|
7531, 7537, 7538, 7539, 7540, 7541, 7542, 7545, 7554, 7558,
|
|
7564, 7571, 7578, 7585, 7594, 7600, 7606, 7610, 7616, 7617,
|
|
7620, 7626, 7632, 7636, 7643, 7644, 7647, 7653, 7659, 7664,
|
|
7672, 7678, 7683, 7690, 7694, 7700, 7701, 7702, 7703, 7704,
|
|
7705, 7706, 7707, 7708, 7709, 7710, 7714, 7719, 7724, 7731,
|
|
7736, 7742, 7748, 7753, 7758, 7763, 7767, 7772, 7777, 7781,
|
|
7786, 7790, 7796, 7801, 7807, 7812, 7818, 7828, 7832, 7836,
|
|
7840, 7846, 7849, 7853, 7854, 7856, 7857, 7858, 7859, 7860,
|
|
7861, 7864, 7868, 7872, 7874, 7876, 7880, 7882, 7884, 7888,
|
|
7890, 7894, 7896, 7900, 7903, 7906, 7911, 7913, 7915, 7917,
|
|
7919, 7923, 7927, 7932, 7936, 7938, 7942, 7944, 7948, 7952,
|
|
7956, 7961, 7963, 7967, 7977, 7982, 7983, 7987, 7989, 7993,
|
|
7995, 7998, 7999, 8000, 8001, 8002, 8003, 8006, 8010, 8014,
|
|
8018, 8020, 8022, 8026, 8028, 8032, 8034, 8045, 8046, 8051,
|
|
8052, 8056, 8060, 8062, 8066, 8067, 8068, 8069, 8070, 8073,
|
|
8077, 8081, 8085, 8089, 8092, 8094, 8098, 8102, 8104, 8108,
|
|
8109, 8110, 8113, 8117, 8121, 8125, 8127, 8131, 8133, 8135,
|
|
8137, 8140, 8142, 8144, 8146, 8150, 8157, 8161, 8163, 8167,
|
|
8171, 8173, 8177, 8179, 8181, 8183, 8185, 8189, 8191, 8195,
|
|
8197, 8201, 8203, 8208
|
|
};
|
|
#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", "SPF_WEIGHT", "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, 358, 359, 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, 357,
|
|
360, 361
|
|
};
|
|
# endif
|
|
|
|
#define YYPACT_NINF -2103
|
|
|
|
#define yypact_value_is_default(Yystate) \
|
|
(!!((Yystate) == (-2103)))
|
|
|
|
#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[] =
|
|
{
|
|
-2103, 120, -2103, -2103, -2103, -2103, -7, 5156, -2103, -2103,
|
|
-2103, 134, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
|
|
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, 889, -2103,
|
|
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
|
|
-2103, 118, -2103, -2103, 753, 162, -2103, -2103, -2103, 118,
|
|
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
|
|
-2103, -2103, 124, 124, -2103, -2103, -2103, -2103, -2103, 124,
|
|
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
|
|
238, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
|
|
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, 124, -2103,
|
|
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
|
|
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
|
|
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
|
|
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
|
|
-2103, 211, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
|
|
344, 417, -2103, -2103, -2103, -2103, -2103, 118, -2103, -2103,
|
|
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
|
|
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
|
|
-2103, -2103, -2103, -2103, -2103, -2103, 118, -2103, -2103, -2103,
|
|
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
|
|
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, 234,
|
|
1817, 445, 234, -2103, -2103, -2103, 504, 530, 594, 615,
|
|
-2103, -2103, -2103, 786, 621, 124, -2103, -2103, 725, 755,
|
|
774, 791, 630, 518, 837, 856, 862, -2103, 153, -2103,
|
|
-2103, -2103, 234, -2103, -2103, -2103, 570, 917, 2307, 2403,
|
|
-2103, -2103, 2952, -2103, 701, -2103, -2103, 1131, -2103, 870,
|
|
-2103, -2103, 1762, 870, 896, -2103, -2103, 925, -2103, -2103,
|
|
-2103, 941, 967, 979, 997, 1001, -2103, -2103, -2103, -2103,
|
|
1004, 972, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
|
|
-2103, -2103, -2103, -2103, -2103, -2103, -2103, 1006, -2103, -2103,
|
|
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
|
|
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
|
|
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
|
|
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
|
|
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
|
|
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
|
|
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
|
|
-2103, -2103, -2103, -2103, -2103, -2103, 152, 124, 1009, 1015,
|
|
1033, 903, 124, 124, 190, 124, -2103, 124, 124, 1056,
|
|
-2103, 525, 1068, 124, 124, 124, 124, -2103, -2103, 124,
|
|
-2103, 1090, 124, 964, 124, 1031, -2103, -2103, -2103, 124,
|
|
-2103, 1096, 124, -2103, 124, 1107, 175, -2103, 964, -2103,
|
|
124, 124, 124, 124, -2103, -2103, -2103, -2103, -2103, 124,
|
|
-2103, 124, 124, 445, 124, 1110, 1009, 124, 1114, -2103,
|
|
124, 124, -2103, -2103, -2103, 1124, 1119, 124, 124, -2103,
|
|
1122, 1128, 124, 1009, 1134, 2952, -2103, 1140, 1144, 124,
|
|
-2103, 1157, 124, 1102, -2103, 1175, 124, 1009, 1194, 1205,
|
|
-2103, 903, 1009, 124, 124, 2162, 79, 124, 84, -2103,
|
|
-2103, 202, -2103, 203, 124, 124, 124, 1231, 124, 124,
|
|
2952, 93, -2103, -2103, 1235, 124, 124, 124, 124, 124,
|
|
2647, 124, -2103, 1009, 124, 1009, 124, 124, -2103, -2103,
|
|
124, -2103, 1009, 124, 1241, 1243, -2103, 124, -2103, -2103,
|
|
1246, -2103, -2103, 1250, -2103, -2103, -2103, -2103, -2103, -2103,
|
|
-2103, -2103, -2103, -2103, 1253, -2103, -2103, -2103, -2103, -2103,
|
|
-2103, -2103, -2103, -2103, -2103, -2103, 124, -2103, -2103, 1269,
|
|
1289, 1223, 1009, 1313, 2952, 2952, 2952, 2952, 2952, 1315,
|
|
1321, 1348, 1370, 1382, 124, -2103, 1392, -2103, -2103, -2103,
|
|
-2103, 1195, 113, -2103, -2103, 124, 124, 124, 124, 1362,
|
|
-2103, -2103, 1290, 124, 124, -2103, 700, 124, 124, 124,
|
|
124, 124, 312, 124, 1102, 124, 124, 1110, -2103, -2103,
|
|
-2103, -2103, -2103, -2103, -2103, -2103, 1154, -2103, -2103, -2103,
|
|
-2103, -2103, -2103, 2952, 2952, 2952, -2103, 2952, -2103, -2103,
|
|
-2103, -2103, -2103, -2103, 2952, 2407, -2103, 80, 1414, -2103,
|
|
1408, -2103, 1182, 1189, 1426, -2103, -2103, 1428, 2952, -2103,
|
|
-2103, 2055, -2103, -2103, 1421, 1527, 1414, -2103, -2103, 1075,
|
|
3, -2103, 2055, -2103, -2103, -2103, 1468, 210, 72, 2960,
|
|
2960, 124, 124, 124, 124, 124, 124, 124, 1474, -2103,
|
|
124, -2103, -2103, -2103, 667, -2103, -2103, 1463, 124, -2103,
|
|
2952, -2103, 1242, 878, -2103, 1482, -2103, -2103, 1485, 1478,
|
|
-2103, -2103, -2103, -2103, -2103, 2662, 124, 1490, -2103, 124,
|
|
1485, 124, -2103, 903, -2103, -2103, -2103, -2103, -2103, -2103,
|
|
1498, -2103, -2103, -2103, -2103, -2103, 1485, -2103, -2103, 1500,
|
|
-2103, -2103, 771, 1177, 124, 792, 97, -2103, 1507, 1366,
|
|
2952, 1374, -2103, 1537, -2103, -2103, 2952, 2952, -2103, -2103,
|
|
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, 124,
|
|
-2103, 124, 1531, 243, 124, 445, -2103, -2103, 1543, -2103,
|
|
1548, -2103, 1550, 1139, -2103, 1562, -2103, 124, -2103, -2103,
|
|
-2103, 1563, -2103, 870, 1549, 3062, -2103, 124, -2103, 5617,
|
|
-2103, 124, 2952, -2103, 1564, -2103, 124, -2103, 124, 124,
|
|
124, 1414, 731, 124, 124, 124, 1374, -2103, 124, 648,
|
|
-2103, -2103, -2103, 1527, 1075, -2103, -2103, -2103, -2103, -2103,
|
|
-2103, 152, -2103, 1463, 1570, 1507, -2103, -2103, -2103, -2103,
|
|
-2103, -2103, 124, -2103, -2103, -2103, 5617, -2103, 525, 1520,
|
|
124, -2103, 1585, -2103, -2103, -2103, -2103, 1588, 3140, 798,
|
|
-2103, -2103, 211, 124, 445, -2103, 124, 1485, -2103, 1598,
|
|
1589, -2103, 124, -2103, 1606, 2952, 2952, -2103, 1485, 124,
|
|
272, 124, 1330, 1330, 364, 1330, -2103, 1603, 419, 487,
|
|
495, 524, 526, 532, -2103, 1485, 838, -2103, 1624, -2103,
|
|
198, 485, -2103, -2103, 1223, -2103, 124, -2103, 3203, 5617,
|
|
3237, 3329, 1626, 5617, 124, 124, -2103, -2103, -2103, -2103,
|
|
1627, -2103, 124, 124, -2103, -2103, -2103, -2103, 821, -2103,
|
|
-2103, 1423, 1485, -2103, -2103, -2103, -2103, 1297, 124, -2103,
|
|
-2103, -2103, -2103, -2103, -2103, -2103, 1485, -2103, -2103, -2103,
|
|
-2103, 1638, -2103, 1638, -2103, -2103, -2103, -2103, 578, -2103,
|
|
214, -2103, 1636, -2103, -2103, 3403, 1650, 1656, 1656, 1673,
|
|
-2103, 2952, 2952, 2952, 2952, 2952, 2952, 2952, 2952, 2952,
|
|
2952, 2952, 2952, 2952, 2952, 2952, 2952, 2952, 2952, 2952,
|
|
-2103, 1602, 1544, 1664, 390, 440, 2952, -2103, -2103, -2103,
|
|
832, 1228, -2103, -2103, -2103, -2103, 846, -2103, 1410, 1273,
|
|
2952, 1668, 1527, 1527, 1527, 1527, 1527, -2103, 1663, -2103,
|
|
210, 210, 1414, 1679, -2103, 2960, 5617, 125, 150, -2103,
|
|
1684, 1689, -2103, -2103, 1485, -2103, -2103, -2103, -2103, 1485,
|
|
-2103, 708, -2103, 152, -2103, -2103, -2103, 124, 3450, 124,
|
|
1697, 2952, 1651, -2103, -2103, 124, -2103, 2952, 3513, -2103,
|
|
855, -2103, -2103, 1662, -2103, -2103, 882, -2103, 124, -2103,
|
|
124, -2103, -2103, 1177, -2103, -2103, -2103, -2103, -2103, 3585,
|
|
1485, -2103, -2103, -2103, 1704, 1705, 1706, 1715, 1716, 1718,
|
|
-2103, 1366, -2103, 124, -2103, 3665, -2103, -2103, 124, 3750,
|
|
3781, -2103, 1725, 900, 1737, 1426, -2103, -2103, 124, -2103,
|
|
1739, -2103, 1724, -2103, 124, -2103, 1622, 748, -2103, -2103,
|
|
-26, -2103, -2103, 1745, -2103, 1738, 1749, 905, -2103, 124,
|
|
2960, 1744, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
|
|
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
|
|
-2103, 1751, -2103, -2103, 57, 1752, 1740, 3830, 2685, -70,
|
|
-2103, 1722, -2103, -2103, 920, -2103, -2103, -2103, -2103, -2103,
|
|
943, 1748, 944, -2103, -2103, -2103, 2952, -2103, 1792, -2103,
|
|
-2103, -2103, 961, -2103, 1759, -2103, 1366, 1755, 1768, 962,
|
|
-2103, -2103, -2103, 1772, -2103, 1766, 1770, 1761, 124, 2952,
|
|
2952, 2647, -2103, -2103, -2103, -2103, -2103, -2103, -2103, 1782,
|
|
1783, -2103, 623, -2103, -2103, 3866, 3982, -2103, 1771, -2103,
|
|
565, 1774, -2103, -2103, -2103, -2103, 568, -2103, -2103, -2103,
|
|
571, -2103, 573, 574, 576, -2103, 592, -2103, 593, -2103,
|
|
1785, 1787, 1795, 1796, -2103, 1799, 1802, -2103, -2103, -2103,
|
|
-2103, -2103, -2103, 1414, 1810, 1798, -2103, 1800, -49, -2103,
|
|
-2103, 1814, -2103, -15, 981, -2103, -2103, -2103, -2103, 2952,
|
|
372, 691, -2103, 989, 1013, 286, 1028, -2103, -2103, -2103,
|
|
-2103, -2103, -2103, 89, 1032, -2103, -2103, -2103, -2103, 726,
|
|
1054, -2103, -2103, 401, 1065, -2103, -2103, 445, 124, 191,
|
|
-2103, 1809, -2103, 1823, -2103, 1485, -2103, -2103, -2103, 1815,
|
|
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, 983, -2103,
|
|
-2103, -2103, 124, 1485, 138, 1494, -2103, -2103, 124, 124,
|
|
-2103, 1820, 214, -2103, 1819, -2103, 1776, 2952, 2960, -2103,
|
|
2952, 1656, 1656, 569, 569, 1673, 857, 1567, 2757, 5617,
|
|
2757, 2757, 2757, 2757, 2757, 1567, 1732, 1656, 1732, 3280,
|
|
1664, -2103, -2103, 1818, 1832, 2253, -2103, -2103, -2103, -2103,
|
|
-2103, 1834, -2103, -2103, 903, 5617, -2103, 2952, -2103, -2103,
|
|
-2103, -2103, 5617, 83, 5617, 1668, 1668, 1355, 1668, 654,
|
|
-2103, 1679, 1835, 210, 4229, 1836, 1837, 1838, 2960, 2960,
|
|
2960, -2103, -2103, 124, 1827, -2103, -2103, 1840, 1507, -2103,
|
|
211, -2103, -2103, -2103, -2103, 1595, -2103, 1069, 903, -2103,
|
|
903, 1085, 1845, 1086, -2103, 5617, 2952, 2662, -2103, 1100,
|
|
-2103, 903, 1638, -2103, 707, 710, -2103, 1112, 1692, 1123,
|
|
-2103, 1789, -2103, 97, -2103, 1844, 124, 124, 2952, 124,
|
|
-2103, -2103, 1485, -2103, -2103, -2103, 1621, 124, 2952, 124,
|
|
-2103, 124, -2103, 1414, 2952, 1841, 2685, -2103, -2103, -2103,
|
|
-2103, 1133, -2103, 1847, -2103, 1846, 1850, 1851, 1659, 2952,
|
|
124, 124, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
|
|
1009, 124, -2103, 2700, 2998, 1848, 124, 124, -2103, 124,
|
|
-2103, 1677, 124, -2103, 2952, 124, -2103, 1638, 5617, -2103,
|
|
1862, 544, 1862, -2103, 124, 1366, 1864, 2736, 124, 124,
|
|
-2103, 525, 2952, 863, 2952, 1152, -2103, 1858, 1153, 5617,
|
|
-2103, 37, -2103, -2103, -2103, -2103, -2103, 1009, 15, -2103,
|
|
124, -2103, 918, -2103, -2103, -116, -2103, 91, 635, -2103,
|
|
633, -2103, 323, -2103, 33, -2103, 124, 124, 124, -2103,
|
|
124, 124, 838, -2103, 124, -2103, -2103, 1859, -2103, 124,
|
|
-2103, -2103, -2103, -2103, -2103, 1546, 1561, 1565, 5617, -2103,
|
|
1664, 124, -2103, -2103, 1860, 1863, 1867, 1879, 1880, -2103,
|
|
-2103, 1881, 1883, 1887, -2103, -2103, -2103, 1888, 1889, 1894,
|
|
1895, -2103, -2103, -2103, 693, 1898, 1899, 1900, 1901, 1902,
|
|
-2103, -2103, -2103, -2103, -2103, 124, 826, -2103, -2103, 1904,
|
|
-2103, 1913, -2103, -2103, 1823, -2103, -2103, -2103, -2103, 5617,
|
|
1916, -2103, -2103, -2103, 115, 371, 371, 1682, 1683, -2103,
|
|
-2103, 1688, 1690, 1693, 580, 124, -2103, -2103, -2103, -2103,
|
|
1930, -2103, -2103, -2103, 1819, -2103, 1932, -2103, 164, 1927,
|
|
-2103, 1933, 4290, -2103, 1924, 1926, 1426, -2103, -2103, 3908,
|
|
-2103, 2952, 2952, 1228, -2103, 5617, 2055, 210, -2103, 183,
|
|
2960, 2960, 2960, 193, -2103, 228, -2103, 493, -2103, 1485,
|
|
124, -2103, -2103, 1949, 1168, -2103, 1951, -2103, 5617, -2103,
|
|
-2103, -2103, 2952, -2103, -2103, 2952, -2103, -2103, -2103, -2103,
|
|
5617, -2103, 1692, 2952, 1938, -2103, 1941, 1943, 4337, 1952,
|
|
-2103, 67, 124, -2103, 1191, -2103, -2103, 1942, 5617, -2103,
|
|
-2103, 3908, -2103, 1622, -2103, 1622, 124, 124, 124, 1197,
|
|
1207, -2103, 124, 1950, 1946, 2952, 4372, 2914, -2103, -2103,
|
|
-2103, 1485, 1414, -2103, 1955, -2103, 1801, 1964, 5617, -2103,
|
|
124, -2103, 1962, 1963, -2103, -2103, 1727, 1971, -2103, -2103,
|
|
1976, -2103, 5617, 1211, -2103, 1216, -2103, -2103, 4403, -2103,
|
|
-2103, 1219, -2103, -2103, 5617, 1965, 124, -2103, -2103, -2103,
|
|
1969, 1973, 1781, 1920, 124, 124, 1975, 1986, -2103, 448,
|
|
-2103, 1980, -2103, -2103, -2103, 1981, -2103, -2103, -2103, -2103,
|
|
-2103, -2103, -2103, 918, -2103, -2103, -2103, -2103, -116, 124,
|
|
-2103, -2103, 1249, 1983, -2103, 1984, -2103, 1985, -2103, -2103,
|
|
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, 635, -2103,
|
|
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
|
|
-2103, 633, -2103, -2103, -2103, -2103, -2103, 323, -2103, -2103,
|
|
-2103, 33, 1990, 1991, 1993, 738, 1258, -2103, 1994, 1997,
|
|
1414, 124, -2103, -2103, 1987, -2103, 1992, 1664, 2002, -2103,
|
|
124, 124, -2103, 1857, 124, -2103, 124, 124, 124, -2103,
|
|
124, 124, 124, 2952, -2103, 2014, 2015, -2103, 124, 124,
|
|
2952, -2103, -2103, 2012, 2952, 2952, -2103, -2103, 2013, -2103,
|
|
1023, 826, 1939, -2103, 1277, -2103, 5617, -2103, -2103, -2103,
|
|
2032, -2103, -2103, -2103, -2103, 390, 390, 390, 390, 390,
|
|
1820, -2103, 2026, 2037, 2028, 1820, 1927, -2103, 214, 164,
|
|
145, 145, -2103, -2103, -2103, 1278, 2039, 872, 171, -2103,
|
|
2035, 164, -2103, 2952, -2103, 2027, -2103, 1426, -2103, 2253,
|
|
5617, 2030, -2103, -2103, 1075, 2029, 2031, 1279, 2033, 2036,
|
|
2038, -2103, -2103, -2103, 2047, 40, 903, -2103, 124, 1009,
|
|
5617, 40, 5617, 1692, 2952, 2042, 4437, 1287, -2103, -2103,
|
|
-2103, -2103, -2103, 2952, -2103, 2051, -2103, -2103, -2103, -2103,
|
|
-2103, 1301, 1304, 1308, -2103, -2103, -2103, 754, -2103, 5617,
|
|
2952, 2952, 4471, -2103, 124, 124, -2103, -2103, 1964, -2103,
|
|
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
|
|
-2103, 2041, 544, 2043, 3062, -2103, 124, 124, 124, 2736,
|
|
-2103, -2103, -2103, 863, -2103, -2103, -2103, 2616, 124, -2103,
|
|
-2103, 1975, 2040, -2103, -2103, 124, 124, 2952, -2103, -2103,
|
|
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, 91,
|
|
-2103, -2103, -2103, 2952, -2103, 2952, -2103, -2103, -2103, -2103,
|
|
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
|
|
-2103, -2103, -2103, 1316, 124, 124, 2052, 750, 2048, 1319,
|
|
-2103, 1326, 938, 1337, 2054, 1338, 1353, 1354, 1360, 1368,
|
|
1378, -2103, 1379, 3360, 2057, -2103, -2103, -113, 1380, -2103,
|
|
1383, 1397, 4502, 876, 2045, -2103, 5617, 5617, 1401, 2069,
|
|
-2103, -2103, -2103, 2058, 4539, -2103, -2103, -2103, 115, -2103,
|
|
-2103, -2103, -2103, -2103, -2103, 1820, -2103, 124, -2103, -2103,
|
|
2065, 2059, -2103, 662, 171, 171, 164, -2103, 164, 145,
|
|
145, 145, 145, 145, 1071, 4573, -2103, -2103, -2103, -2103,
|
|
2952, -2103, -2103, -2103, -2103, 1647, -2103, 124, 2073, 1478,
|
|
124, -2103, 124, -2103, 4614, -2103, 2952, 2952, -2103, 4645,
|
|
1829, 2952, -2103, -2103, -2103, -2103, 1430, -2103, -2103, 5617,
|
|
5617, 2952, 1431, 2072, -2103, 954, -2103, 2952, -2103, 2063,
|
|
2068, -2103, -2103, 2075, 2084, -2103, -2103, -2103, -2103, -2103,
|
|
1961, 2074, 1442, 2087, 2090, 1445, 785, 124, -2103, -2103,
|
|
5617, 721, 2077, 28, -2103, -2103, 2062, -2103, -2103, 217,
|
|
4676, 4713, -2103, -2103, -2103, -2103, -2103, -2103, 1451, 2079,
|
|
795, 2952, 124, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
|
|
-2103, -2103, -2103, -2103, -2103, -2103, -2103, 2086, 2088, -2103,
|
|
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, 124, -2103,
|
|
2952, -2103, 553, 1469, -2103, 1471, -2103, -2103, -2103, -2103,
|
|
-2103, -2103, -2103, -2103, -2103, 2952, 2095, 2097, -2103, -2103,
|
|
-2103, 1494, 2085, -2103, 1664, -2103, 164, -2103, 1071, 2092,
|
|
171, 171, -2103, -2103, -2103, -2103, 4744, -2103, 3908, -2103,
|
|
1475, -2103, -2103, 903, 1810, -2103, 1692, 5617, -2103, 1861,
|
|
-2103, 2100, 4787, 754, -2103, 5617, -2103, 2022, 2124, 2126,
|
|
2127, 2128, 2129, 124, 124, 2131, 2133, 2134, 4832, -2103,
|
|
-2103, -2103, 2952, 124, 124, -2103, -2103, 2139, 124, -2103,
|
|
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
|
|
-2103, -2103, -2103, -2103, -2103, -2103, -2103, 2148, -2103, -2103,
|
|
-2103, -2103, -2103, 1477, -2103, -2103, -2103, -2103, 2135, -2103,
|
|
-2103, 2150, -2103, 5617, -2103, 124, 124, 938, -2103, 4863,
|
|
-2103, 2145, -2103, 2153, 2154, -2103, 4927, -2103, 2156, -2103,
|
|
-2103, 2143, 1493, 1071, -2103, 2952, 1647, -2103, -2103, 2952,
|
|
124, 2952, -2103, -2103, -2103, 5617, 1499, -2103, -2103, 2124,
|
|
124, 124, 124, 124, -2103, -2103, 2952, 2952, 124, 2952,
|
|
1504, -2103, -2103, 2157, -2103, 1508, 2159, 1526, 124, 2952,
|
|
-2103, -2103, -2103, -2103, 189, 2160, -2103, 2952, 2078, -2103,
|
|
-2103, -2103, -2103, -2103, -2103, 124, 2151, -2103, -2103, 4958,
|
|
-2103, 5617, -2103, -2103, 2158, 4992, 2022, -2103, 348, -2103,
|
|
2173, 1541, 2174, 1545, 2167, 1552, 5023, 5093, 2164, -2103,
|
|
1559, 5151, -2103, 124, 2105, -2103, -2103, -2103, -2103, 1810,
|
|
-2103, 5490, 1856, -2103, 2952, 5617, 2169, 1839, 1842, -2103,
|
|
2180, -2103, -2103, 2952, 1521, -2103, -2103, 2184, 2186, 124,
|
|
124, -2103, 124, -2103, 2647, -2103, -2103, 2952, -2103, 124,
|
|
-2103, 2952, -2103, 2175, 1560, 1566, -2103, 2182, 5521, 908,
|
|
-2103, 2187, 2188, 124, 5617, 124, 5617, 1580, -2103, -2103,
|
|
-2103, -2103, 1600, -2103, 2192, 1601, 1604, 1607, 5552, -2103,
|
|
5617, -2103, -2103, -2103, 2952, -2103, -2103, -2103, -2103, -2103,
|
|
2178, 1521, -2103, 124, -2103, 2952, -2103, -2103, 2190, 2952,
|
|
1612, 1632, 1634, 2952, 2191, -2103, -2103, -2103, 5586, 1667,
|
|
-2103, -2103, 5617, 2204, -2103, -2103, -2103, 2952, 2952, 2952,
|
|
2198, -2103, -2103, -2103, 5617, -2103, -2103, -47, 380, 1685,
|
|
-2103, 2208, 2209, -2103, -2103, -2103, 2202, 2202, 2202, -2103,
|
|
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, 541, 2212,
|
|
-2103, 2096, -2103, 1686, -2103, -2103, -2103
|
|
};
|
|
|
|
/* 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, 1313, 1313, 1313, 1313, 1313, 1313, 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, 1261, 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, 1296,
|
|
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, 1262, 1264, 1265,
|
|
1266, 1268, 1267, 0, 0, 1277, 1279, 1280, 1281, 0,
|
|
0, 1285, 45, 0, 0, 1300, 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, 1287, 1289, 0, 0,
|
|
1292, 1294, 45, 1249, 0, 0, 0, 0, 0, 0,
|
|
45, 1299, 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, 1263, 0, 0, 0, 1278,
|
|
0, 0, 0, 0, 1286, 0, 0, 45, 0, 0,
|
|
0, 45, 1301, 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,
|
|
1274, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 1297, 0, 0, 0, 45, 45, 0, 0, 1307,
|
|
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, 1273, 1270, 903, 904, 905, 902, 907,
|
|
901, 908, 900, 899, 898, 906, 894, 0, 0, 45,
|
|
1269, 1272, 1271, 1283, 1284, 1282, 1290, 1288, 0, 1291,
|
|
0, 1293, 0, 0, 1253, 0, 1309, 1310, 45, 1302,
|
|
1303, 1304, 1305, 1311, 1312, 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, 1276, 1275, 0, 0, 0, 1298, 0,
|
|
1255, 0, 45, 1257, 1259, 1308, 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, 0, 1254,
|
|
45, 1251, 45, 1252, 1306, 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, 1295, 0, 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,
|
|
1256, 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, 1258, 1260, 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[] =
|
|
{
|
|
-2103, -2103, -2103, -2103, -2103, -20, 2004, 1317, -2103, -2103,
|
|
-688, -31, -2103, -2103, -408, -2103, 946, -2103, -50, 1318,
|
|
-2103, -2103, -2103, 2626, 216, -2103, -2103, -2103, -2103, -2103,
|
|
-2103, 338, 631, 1040, -2103, -2103, -2103, -2103, -2103, -2103,
|
|
-2103, -2103, -180, -899, -2103, -2103, -2103, 1136, 632, 1648,
|
|
-2103, -46, -1581, 346, -2103, -2103, -2103, -2103, -2103, -2103,
|
|
1644, -274, -194, -2103, -2103, -2103, 1642, -2103, -636, -2103,
|
|
-2103, -2103, -2103, 1529, -2103, -2103, 930, -1269, -1542, 1306,
|
|
607, -1550, -42, 109, 1309, -2103, 330, 341, -1818, -2103,
|
|
-1548, -1246, -1543, -445, -2103, 135, -1609, -1615, -776, -2103,
|
|
-2103, 751, 1097, 516, 71, 250, -2103, 779, -2103, -2103,
|
|
-2103, -2103, -2103, 58, -2103, -1465, -358, 1233, -2103, 1218,
|
|
851, 873, -378, -2103, -2103, 1179, -2103, -2103, -2103, -2103,
|
|
562, 563, 2201, 144, -366, -1321, 343, -326, -1027, 1169,
|
|
-544, -508, 1420, -223, 1822, -876, -879, -2103, -2103, -614,
|
|
-602, -208, -2103, -848, -2103, -638, -952, -1124, -2103, -2103,
|
|
-2103, 322, -2103, -2103, 1569, -2103, -2103, 2049, -2103, 2050,
|
|
-2103, -2103, 879, -2103, -371, 18, -2103, -2103, 2056, 2061,
|
|
-2103, 841, -2103, -737, -204, 1502, -2103, 986, -2103, -2103,
|
|
255, -2103, 1248, 642, -2103, 4031, -413, -1107, -2103, -2103,
|
|
-2103, -2103, -2103, -2103, -2103, -186, -2103, 643, -926, -2103,
|
|
-2103, -2103, 301, -1309, -632, 1299, -931, -380, -192, -368,
|
|
673, -58, -2103, -2103, -2103, 1645, -2103, -2103, 1227, -2103,
|
|
-2103, 1200, -2103, 1470, -1986, 1129, -2103, -2103, -2103, 1653,
|
|
-2103, 1649, -2103, 1654, -2103, 1652, -993, -2103, -2103, -2103,
|
|
-13, -243, -2103, -2103, -2103, -395, -2103, 811, 898, -487,
|
|
897, -2103, 156, -2103, -2103, -2103, -227, -2103, -2103, -2103,
|
|
-1903, -2103, -2103, -2103, -2103, -2103, -1454, -530, 310, -2103,
|
|
-69, -2103, 1517, 1307, -2103, -2103, 1310, -2103, -2103, -2103,
|
|
-2103, -191, -2103, -2103, 1239, -2103, -2103, 1281, -2103, 377,
|
|
1303, -2103, -2103, -871, -2103, -1896, -2103, -120, -2103, -2103,
|
|
345, -2103, -767, -384, 1896, 1547, -2103, -2103, -1553, -2103,
|
|
-2103, -2103, -2103, -2103, -62, -2103, -2103, -2103, -202, -2103,
|
|
-225, -2103, -242, -2103, -240, -1890, -1195, -787, -2103, 17,
|
|
-477, -1065, -2102, -2103, -2103, -2103, -491, -1820, 596, -2103,
|
|
-765, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
|
|
-488, -1461, 860, -2103, 347, -2103, 1694, -2103, 1865, -2103,
|
|
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -1444, 904,
|
|
-2103, 1605, -2103, -2103, -2103, -2103, 1982, -2103, -2103, -2103,
|
|
408, 1957, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
|
|
-2103, -2103, -2103, 824, -2103, -2103, -2103, 355, -2103, -2103,
|
|
-2103, -2103, 68, -1952, -2103, -2103, -2103, -2103, -2103, -2103,
|
|
-2103, -2103, -2103, -2103, -2103, -2103, -2103, 561, 567, -531,
|
|
-936, -912, -1438, -1445, -1427, -1419, -2103, -1417, -1416, -1392,
|
|
-2103, -2103, -2103, -2103, -2103, 550, -2103, -2103, -2103, -2103,
|
|
-2103, 598, -1407, -1401, -2103, -2103, -2103, 548, -2103, -2103,
|
|
595, -2103, 96, -2103, -2103, -2103, -2103, 566, -2103, -2103,
|
|
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
|
|
-2103, -2103, -2103, 349, -2103, 351, 32, -2103, -2103, -2103,
|
|
-2103, -2103, -2103, -2103, -2103, 1170, -2103, 1162, -2103, -837,
|
|
-2103, 334, -2103, -2103, -2103, 554, 858, -2103, -2103, -2103,
|
|
1522, -2103, -2103, -2103, -2103, -2103, -2036, 22, -2103, -2103,
|
|
-2103, -2103, 839, -2103, -2103, -2103, -2103, -2103, -2103, 177,
|
|
-2103, 836, -2103, -2103, -2103, -2103, 831, -2103, -2103, -2103,
|
|
-2103, -2103, 825, -2103, 157, -2103, 1509
|
|
};
|
|
|
|
/* 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, 2453, 2454, 2527, 2528, 2550, 2564, 2565,
|
|
1765, 1965, 278, 279, 1747, 677, 813, 814, 1953, 2300,
|
|
2301, 1954, 674, 675, 280, 281, 282, 283, 2108, 2109,
|
|
2490, 2491, 284, 758, 759, 285, 710, 711, 286, 689,
|
|
690, 287, 288, 1150, 1737, 2184, 2406, 2407, 1997, 1998,
|
|
1999, 2000, 2001, 707, 2002, 2003, 2004, 2468, 1234, 2005,
|
|
2470, 2006, 2007, 2008, 2409, 2458, 2499, 2532, 2533, 2569,
|
|
2570, 2589, 2590, 2591, 2592, 2593, 2604, 2009, 2206, 2426,
|
|
820, 2083, 2246, 2247, 2248, 2010, 832, 1505, 1506, 2027,
|
|
1167, 2423, 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, 2582, 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, 2480, 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, 2441, 2443,
|
|
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, 1105, 682, 1401, 833, 834, 835, 836, 821,
|
|
697, 708, 678, 874, 1475, 1252, 1720, 1092, 1251, 1645,
|
|
978, 1008, 1008, 1350, 1254, 747, 1306, 1894, 1012, 1927,
|
|
571, 425, 425, 720, 646, 2178, 982, 1755, 433, 646,
|
|
1748, 2202, 1625, 735, 1237, 738, 2086, 1487, 2088, 647,
|
|
741, 742, 743, 1778, 647, 1357, 440, 796, 744, 1081,
|
|
2265, 746, 1190, 748, 1658, 1630, 1897, 460, 479, 946,
|
|
751, 1899, 482, 653, 1377, 1974, 657, 659, 1430, 462,
|
|
-564, 427, 1189, 1913, 1917, 1822, 405, 777, 816, 1932,
|
|
1811, 405, 1821, 797, 1834, 970, 477, 2128, -566, 1959,
|
|
405, 793, 1063, 1823, 2341, 1476, 798, 804, 1770, 8,
|
|
806, 1824, 809, 1825, 1826, 1007, 1007, 701, 905, -542,
|
|
2, 3, 2359, 1828, 504, 828, 1347, 1347, 1799, 1829,
|
|
1571, 1615, 1616, 1378, 906, 2594, 1817, 843, 1827, 846,
|
|
1835, 996, 1547, 1455, 424, -585, 852, 1025, 1396, 376,
|
|
1794, 1251, 1508, 1605, 574, 1064, 378, 671, -594, 672,
|
|
1919, 598, 384, 1981, 1982, 1983, 728, 1550, -528, 424,
|
|
-594, 1202, 391, 1496, 1415, 393, 2141, 408, 396, 1919,
|
|
1920, 1921, 1456, 1065, 600, 402, 886, 1775, -564, 409,
|
|
737, -595, 972, 412, 585, -138, 905, 702, 687, -566,
|
|
-142, -588, 2266, -595, 1467, 1468, 985, 1621, 2142, -62,
|
|
2483, 431, -566, -588, 753, 435, 436, 811, 408, 1232,
|
|
424, 441, 442, 1066, 1780, 1001, 500, 447, 448, 1312,
|
|
450, 451, 452, 453, 1067, 454, -592, 1469, 2267, 1858,
|
|
815, -585, 424, 791, 463, 1771, 972, -340, -592, 467,
|
|
799, 469, 646, 424, 1477, 472, 1457, 981, 2360, 476,
|
|
-542, 478, 1068, -340, 1622, 1223, -594, 647, 484, 1088,
|
|
4, 2595, 488, 989, 424, 2436, 491, 991, 493, 1106,
|
|
598, 424, -528, 1163, 998, 501, 503, 621, 810, 505,
|
|
506, -340, 1516, 424, 1922, 512, 996, 513, 1572, -595,
|
|
1551, 517, 443, 1552, 424, 2134, 2135, 2283, 2081, -588,
|
|
2133, 2085, 2361, 1922, 1036, 1782, 1623, 1573, 931, 424,
|
|
424, 1975, 1712, 2362, 857, 1041, 971, 424, 544, -564,
|
|
546, 424, 424, 1072, 1168, 698, -138, 551, 552, 424,
|
|
-566, -142, 1044, 424, -592, 673, 676, 1093, 1658, 699,
|
|
-62, 683, 684, 688, 684, 1069, 692, 694, 1051, 510,
|
|
700, 2178, 704, 706, 706, 709, 2129, 1008, 712, 1901,
|
|
1903, 716, 598, 712, 1351, -383, 2131, 5, 727, 1610,
|
|
1811, 732, -585, 712, 915, 712, 1822, 1559, -1116, 425,
|
|
712, 712, 712, 1821, 927, 928, 929, 930, 712, 1834,
|
|
745, 712, 1513, 712, 1823, 1447, 2087, -594, 2365, 756,
|
|
757, 1704, 1824, 1507, 1825, 1826, 768, 770, 646, 1651,
|
|
1165, 776, 646, 1515, 1828, 511, 1817, 598, 783, 646,
|
|
1829, 787, 1719, 647, 1002, 1158, 1185, 647, 740, 1827,
|
|
-595, 2182, 829, 800, 647, 1835, 807, 1664, 1666, 1668,
|
|
-588, 972, 727, 817, 819, 819, 1606, 823, 800, 997,
|
|
572, 1375, 999, 1621, 831, 831, 831, 831, 831, 1564,
|
|
841, 1442, 1008, 845, 2037, 847, 783, 1565, 1464, 850,
|
|
-1141, 996, 853, 996, 1026, -592, 858, 592, 594, 1187,
|
|
996, 567, 1685, 599, 1566, 598, 2497, 876, 1892, 1893,
|
|
1197, -590, 1749, 598, 1349, 2366, 1236, 1045, 2596, 1304,
|
|
2561, 2562, 575, -590, 1780, 875, 2367, 1219, 2537, 424,
|
|
1622, 2228, 2469, 911, 2290, 2291, 593, 2288, 2498, -1116,
|
|
917, 1781, 598, 899, 598, -1063, 2076, 2597, 576, 621,
|
|
598, 907, 2529, 1305, 912, 913, 914, 700, 698, 902,
|
|
903, 724, 920, 921, 1283, -528, 926, 700, 700, 700,
|
|
700, 918, 699, 2192, 934, 935, 1007, 2205, 1307, 424,
|
|
1897, 2209, 1623, 598, 951, 1899, 598, 601, 952, 598,
|
|
646, 598, 598, 1098, 598, 2285, 1310, 1110, 1910, 621,
|
|
1340, 1742, 1809, 2465, 1819, 647, 1832, 2598, 1838, 2529,
|
|
598, 598, 577, -1152, 1155, 1782, 967, 2304, 1783, -590,
|
|
1157, -1168, 1159, 2539, 424, 1311, 1810, 1911, 1820, 1021,
|
|
1833, -1141, 1839, 578, 1365, 1366, 1367, 1368, 1369, 584,
|
|
716, 1014, 768, 823, 817, 704, 1019, 1032, 591, 847,
|
|
-1171, 1625, -1105, 1567, 1568, 1585, 2127, 700, -1135, 1184,
|
|
996, 972, 1186, -528, 424, 851, 1381, 1233, 1233, 992,
|
|
2576, 1382, 981, 993, 1630, 712, 1156, -528, 1043, 2596,
|
|
700, 791, 1418, 424, 2583, 1023, -1063, 2393, 2139, 2140,
|
|
1008, -1115, 1859, 2287, -1140, 1251, 1643, -1062, 1024, -1151,
|
|
-1167, 995, -1170, 1060, -384, 1105, 1105, 911, 2597, 1842,
|
|
1843, 1844, 1422, 1848, 1849, 922, 1560, 1092, -1104, -1134,
|
|
-383, 2610, 2612, -384, 1100, 923, 637, 1803, 1082, 1803,
|
|
1087, 1743, 970, 1089, 2616, 973, 2343, 1357, 1134, 1664,
|
|
1666, 1668, 1586, 587, -385, 1139, 1103, 2344, 2345, 1145,
|
|
1008, 1008, 1008, 2346, -1152, 2347, 1133, 1587, 1588, 1589,
|
|
-590, 1384, -1168, -388, 2348, 1140, 2349, 1141, 2350, 1759,
|
|
405, 2175, 1148, 588, 1151, 976, 1964, 700, 406, 646,
|
|
646, 646, 646, 646, 1007, 1385, 1644, 1002, 1002, 1053,
|
|
673, -1171, 589, -1105, 647, 647, 647, 647, 647, -1135,
|
|
1386, 1103, 1054, 579, 580, 1387, 1388, 700, -386, 590,
|
|
1061, 1192, 1389, 1705, 791, 1706, 1181, 2235, 2446, 2236,
|
|
976, 25, 700, 1062, 1293, 700, 29, 1294, 2237, 1182,
|
|
2238, 1193, -1115, 2435, 1780, -1140, 1780, 791, -1062, 1279,
|
|
-1151, -1167, 1238, -1170, 1663, 1665, 1667, 1243, 47, 48,
|
|
1352, 1781, 1280, 1781, 1884, 595, 1255, 1263, 1269, -1104,
|
|
-1134, 1273, 1885, 1353, 1358, 1240, 2127, 996, 996, 996,
|
|
996, 996, 951, 1407, 596, 1443, 952, 1359, 1759, 1592,
|
|
597, 1276, 845, 953, 954, 2479, 1408, 2425, 1693, -231,
|
|
2351, 50, 1809, 2352, 1278, 652, 598, 1301, 2139, 2140,
|
|
1411, 1316, 90, -528, 967, 1819, -793, -793, 1804, 1302,
|
|
1804, 1832, 95, 1412, 660, 1838, 1810, 2380, 1439, 1313,
|
|
581, 972, 2381, 1461, 424, 1782, -853, 1782, 1783, 1820,
|
|
1783, 1440, 1805, 1784, 1805, 1833, 1462, 1598, 1479, 1839,
|
|
650, 1785, 1806, 661, 1806, 658, 1390, 1807, 1030, 1807,
|
|
1697, 1480, 1699, 2239, 2240, 1604, 2241, 2242, 121, 662,
|
|
2463, 1482, 1485, 2119, 2120, 2121, 2122, 2123, 1203, 1204,
|
|
2235, 1207, 2236, 2391, 1483, 1486, 2461, 1391, 2353, 1023,
|
|
1499, 2237, 1653, 2238, 1395, 663, 1654, 2243, 1656, 668,
|
|
669, 118, 1493, 1500, 1251, 1220, 1221, 664, 122, 1553,
|
|
1601, 1602, 673, 2091, 2115, 2318, 1251, 1561, 1399, 2089,
|
|
2090, 1507, 1554, 2011, 688, 665, 46, 2100, 2101, 666,
|
|
1562, 1392, 667, 1651, 670, 2084, 405, 709, 1222, 2244,
|
|
1673, 1482, 1008, 1008, 1008, 1770, 2354, 2355, 2356, 2157,
|
|
679, 2299, 2245, 1681, 1563, 2162, 1569, 1685, 721, 74,
|
|
1574, 2536, 1432, 911, 1692, 1875, 1876, 732, 680, 1570,
|
|
1941, 1458, 681, 1575, 2067, 2068, 2535, 1347, 1347, 1347,
|
|
1347, 1347, 1582, 757, 1303, 1576, 1703, 1284, 1577, 1578,
|
|
1579, 695, 96, 1590, 1700, 1583, 2156, 1671, 770, 1251,
|
|
992, 1580, 1581, 703, 993, 1415, 1591, 2139, 2140, 2319,
|
|
1672, 642, 643, 1249, 1053, 1481, 2239, 2240, 994, 2241,
|
|
2242, 1507, 109, 1507, 1722, 715, 1675, 1677, 1352, 1780,
|
|
1285, 730, 995, 718, 1611, 1199, 1947, 1665, 1667, 1205,
|
|
1683, 1680, 736, 1455, 1211, 749, 1781, 1215, 1217, 754,
|
|
2243, 1687, 764, 1684, 767, 602, 639, 774, 1511, 788,
|
|
640, 1713, 1287, 775, 1688, 1734, 641, 642, 643, 778,
|
|
1002, 1774, 1223, 1224, 1714, 781, 1225, 1226, 616, 782,
|
|
1766, 1249, 1771, 2320, 1383, 786, 1288, 618, 1289, 603,
|
|
1902, 1904, 2244, 1767, 1769, 2321, 1411, 2322, 2323, 1857,
|
|
2324, 1542, 1055, 2325, 1056, 2245, 1308, 611, 1309, 1957,
|
|
790, 612, 613, 614, 615, 619, 1555, 1556, 1557, 1249,
|
|
1782, 1290, 25, 1783, 616, 1249, 1291, 29, 1784, 794,
|
|
1292, 617, 1978, 618, 1293, 1461, 1785, 1294, 1984, 2019,
|
|
795, 729, 1584, 620, 1499, 2273, 2274, 2023, 1985, 47,
|
|
48, 882, 2020, 1354, 609, 610, 1457, 2021, 611, 1295,
|
|
2024, 619, 612, 613, 614, 615, 822, 1593, 907, 2038,
|
|
830, 2040, 2041, 1296, 1732, 616, 855, 2049, 856, 1297,
|
|
644, 859, 617, 2045, 618, 861, 2069, 1939, -1191, 620,
|
|
2050, 1603, 2299, 2052, 2326, 2054, 2327, 700, 992, 2070,
|
|
621, 1313, 993, 90, 880, 2116, 2136, -588, 1944, 642,
|
|
643, 1955, 619, 95, 1363, 2167, 994, 1779, 2117, 2137,
|
|
1936, 1371, 1372, 1961, 881, 2420, 424, 1963, 2168, 1544,
|
|
995, 1951, 1544, 1233, 1233, 1233, 1544, 1233, 1233, 904,
|
|
620, 1850, 2172, 2147, 1549, 2173, 621, 2232, 887, 2174,
|
|
894, 1977, 622, 860, 1544, 862, 895, 2227, 791, 121,
|
|
2233, 1284, 863, 864, 865, 2249, 1544, 2234, 868, 869,
|
|
870, 871, 1669, 872, 873, 1610, 1251, 424, 2250, 2252,
|
|
992, 1766, 1499, 896, 993, 2292, 2293, 2294, 1766, 916,
|
|
1097, 642, 643, 1993, 2253, 2254, 1482, 621, 622, 2378,
|
|
2399, 2255, 1251, 150, 1285, 897, 1482, 2258, 2268, 2256,
|
|
1286, 1482, 995, 943, 985, 1695, 1695, 898, 1695, 2257,
|
|
2259, 2269, 2605, 2606, 2270, 1482, 712, 901, 1082, 2276,
|
|
1082, 2514, 2515, 1707, 919, 1360, 1287, 972, 2271, 1361,
|
|
611, 625, 2277, 973, 612, 613, 614, 615, 974, 622,
|
|
1599, 1213, 1214, 646, 1002, 975, 996, 616, 2313, 1544,
|
|
1288, 976, 1289, 1746, 617, 1730, 618, 990, 647, 979,
|
|
1181, 2314, 2316, 1499, 1151, 1523, 1948, 1949, 1950, 1544,
|
|
1744, 1526, 1772, 2337, 1773, 1529, 2339, 1531, 1529, 1529,
|
|
700, 1533, 2371, 1535, 619, 1290, 1000, 2382, 811, 2382,
|
|
1291, 1020, 1029, 2396, 1292, 2429, 1035, 1776, 1293, 1845,
|
|
2383, 1294, 2384, 1233, 1233, 1233, 2397, 1031, 2430, 1607,
|
|
1033, 2136, 620, 1243, 611, 1042, 1048, 2456, 612, 613,
|
|
614, 615, 1249, 1295, 2448, 1052, 1499, 2560, 1240, 1255,
|
|
2457, 616, 408, 1076, 1263, 2472, 1759, 1296, 617, 2475,
|
|
618, 611, 1269, 1297, 2477, 612, 613, 614, 615, 424,
|
|
1273, 1073, 803, 642, 643, 1078, 970, 2478, 616, 1461,
|
|
1134, 1094, 1890, 1499, 616, 617, 1095, 618, 619, 621,
|
|
1766, 2525, 2501, 618, 1883, 1096, 2503, 2509, 2249, 2422,
|
|
1101, 1109, 951, 2505, 2249, 1111, 952, 1164, 2158, 1138,
|
|
2510, 2542, 1175, 953, 954, 619, 620, 2543, 2551, 955,
|
|
956, 619, 958, 2160, 1912, 960, 961, 962, 963, 964,
|
|
1178, 2552, 966, 1179, 967, 968, 1188, 1923, 2553, 1461,
|
|
1191, 622, 1499, 620, 1194, 1181, 2147, 1202, 1208, 620,
|
|
1249, 2554, 2556, 424, 779, 2557, 1707, 1166, 2558, 1707,
|
|
1707, 1707, 1231, 2573, 1249, 1272, 1281, 791, 1233, 1952,
|
|
2382, 1233, 2382, 621, 2204, 1105, 598, 2464, 1507, 791,
|
|
424, 1317, 2297, 2574, 1473, 2575, 644, 611, 1320, 826,
|
|
985, 612, 613, 614, 615, 952, 1341, 1682, 992, 838,
|
|
621, 712, 993, 1342, 616, 2579, 621, 993, 951, 642,
|
|
643, 617, 952, 618, 1370, -343, 994, 1373, 2580, 953,
|
|
954, 1986, 1379, 2599, 1647, 622, 956, 1380, 958, 1410,
|
|
995, 960, 961, 962, 963, 964, 2600, 2615, 2512, 1089,
|
|
967, 619, 1400, 562, 563, 564, 565, 566, 1402, 1424,
|
|
1425, 1426, 622, 888, 889, 890, 891, 893, 622, 2340,
|
|
1427, 1428, 791, 1429, 2534, 1105, 2281, 951, 791, 620,
|
|
1438, 952, 1740, 2030, 2031, 1441, 2284, 1444, 953, 954,
|
|
1446, 1450, -936, 1459, 955, 956, 1460, 958, 1471, 1478,
|
|
960, 961, 962, 963, 964, 1465, 1494, 655, 2048, 967,
|
|
1497, 1233, 1466, 1470, 1484, 1498, 424, 641, 642, 643,
|
|
1501, 1502, 945, 947, 948, 1503, 949, 1504, 2534, 616,
|
|
1512, 1514, 1521, 950, 1055, 1524, 621, 992, 618, 611,
|
|
1536, 993, 1537, 612, 613, 614, 615, 826, 642, 643,
|
|
1538, 1539, 2082, 1489, 1540, 994, 616, 1541, 1544, 1545,
|
|
1240, 1546, 1549, 617, 1595, 618, 619, 2097, 922, 995,
|
|
1600, 2103, 2414, 2415, 1638, 1614, 1615, 1616, 1641, 1646,
|
|
1647, 1652, 376, 1657, 1660, 1661, 1662, 1617, 622, 1028,
|
|
1670, 1233, 1676, 619, 620, 406, 1618, 752, 985, 1693,
|
|
1702, 1716, 1710, 1715, 1038, 1717, 1718, 1456, 1734, 1729,
|
|
1741, 1750, 1423, 1768, 1851, 1860, 1855, 1854, 1861, 1619,
|
|
25, 620, 1862, 1431, 1620, 29, 752, 2130, 1923, 1923,
|
|
1923, 644, 1059, 752, 1863, 1864, 1866, 1856, 1867, 1075,
|
|
1923, 812, 1868, 1870, 1871, 1079, 1080, 47, 48, 1872,
|
|
1873, 621, 1621, 1877, 1878, 1879, 1880, 1881, 424, 1887,
|
|
1889, 1895, 2460, 2462, 2170, 2398, 611, 688, 1905, 1906,
|
|
612, 613, 614, 615, 1907, 1915, 1908, 1233, 621, 1909,
|
|
1918, 569, 1931, 616, 2113, 1936, 2185, 1937, 1933, 611,
|
|
617, 1137, 618, 612, 613, 614, 615, 1956, 1958, 1969,
|
|
1973, 90, 1970, 622, 1971, 1987, 616, 1988, -495, 1622,
|
|
1994, 95, 1996, 617, 1995, 618, 1495, 2013, 2014, 2017,
|
|
619, 1744, 2016, 2018, 2028, 1952, 2025, 2193, 2029, 1771,
|
|
622, 1770, 2213, 2035, 2036, 2039, 2042, 2203, 2051, 2053,
|
|
2055, 2219, 2074, 619, 2208, 1776, 621, 2075, 620, 791,
|
|
1522, 2064, 2065, 932, 2066, 2071, 1525, 121, 2072, 1845,
|
|
1528, 1623, 1530, 2077, 1195, 1196, 1532, 2404, 1534, 2095,
|
|
2096, 620, 611, 2105, 2110, 791, 612, 613, 614, 615,
|
|
2118, -382, 2125, 2126, 2143, 424, 2138, 2146, 2207, 616,
|
|
570, 2149, 2151, 2275, 2152, 2150, 617, 2153, 618, 2154,
|
|
983, 150, 2155, 2165, 984, 621, 2171, 2187, 424, 2189,
|
|
803, 642, 643, 2230, 2231, 2251, 2278, 752, 2261, 2279,
|
|
-225, 2303, 616, 2311, 2330, 2286, 619, 2317, 621, 2331,
|
|
2332, 618, 2333, 2334, -844, 2336, 1912, 2338, 2358, 2364,
|
|
2372, 2375, 2387, 2376, 2388, 1923, 2390, 1923, 1923, 1923,
|
|
1923, 1923, 1923, 2394, 620, 2401, 2400, 622, 2309, 619,
|
|
1321, 1322, 1323, 1324, 1325, 1326, 1327, 1328, 1329, 1330,
|
|
1331, 1332, 1333, 1334, 1335, 1336, 1337, 1338, 1339, 2408,
|
|
622, 2410, 2411, 2412, 2413, 826, 2416, 620, 2417, 2418,
|
|
1355, 424, 2434, 1233, 2424, 2428, 2432, 1362, 2433, 1364,
|
|
2438, 2440, 2442, 2445, 2447, 2473, 2476, 802, 2484, 1085,
|
|
2486, 621, 2492, 2494, 1374, 819, 2031, 803, 642, 643,
|
|
2500, 2502, 2504, 2513, 644, 2508, 2517, 1104, 2523, 616,
|
|
2520, 2530, 2521, 2531, 2522, 2563, 2541, 2544, 618, 2377,
|
|
893, 1136, 2546, 2547, 621, 1233, 1405, 2555, 2577, 1142,
|
|
1143, 2571, 2581, 2586, 1149, 2601, 2602, 2603, 2097, 2614,
|
|
1277, 985, 1059, 622, 2596, 1594, 619, 582, 2111, 1282,
|
|
2190, 1888, 1517, 1454, 924, 2389, 1891, 2112, 933, 936,
|
|
1613, 1916, 1104, 1049, 2392, 1701, 1314, 2289, 2132, 1315,
|
|
1176, 2124, 1757, 2282, 620, 1923, 622, 2012, 1492, 2329,
|
|
1473, 2519, 2188, 611, 1739, 2342, 1403, 612, 613, 614,
|
|
615, 1420, 1689, 1674, 1449, 1979, 439, 2613, 1980, 1198,
|
|
616, 1201, 2148, 2161, 1050, 1709, 1679, 617, 792, 618,
|
|
1409, 644, 831, 831, 1736, 1942, 604, 605, 1154, 1943,
|
|
752, 752, 2193, 606, 1376, 1435, 1013, 1474, 607, 1463,
|
|
1510, 621, 1183, 1016, 1250, 1149, 1015, 619, 1018, 1017,
|
|
2421, 1691, 1694, 2308, 2566, 1488, 2191, 2450, 1162, 1413,
|
|
1394, 1393, 2548, 1448, 1793, 2159, 2496, 1798, 1404, 1146,
|
|
1818, 765, 1831, 2186, 1837, 620, 1841, 2459, 893, 1509,
|
|
838, 2567, 13, 14, 2585, 15, 16, 2607, 2427, 1756,
|
|
20, 2609, 2026, 622, 1022, 1721, 2198, 691, 23, 2452,
|
|
1102, 2163, 849, 27, 2474, 739, 30, 1853, 2199, 1103,
|
|
1103, 2403, 424, 2482, 37, 2057, 38, 2061, 40, 2063,
|
|
2487, 2044, 2488, 2047, 1346, 1346, 2431, 2059, 2218, 2216,
|
|
1548, 1543, 621, 2226, 2439, 2073, 1239, 1852, 1865, 2374,
|
|
1869, 59, 951, 1874, 2489, 1882, 952, 611, 1558, 985,
|
|
752, 752, 70, 953, 954, 2385, 2082, 2082, 0, 955,
|
|
956, 957, 958, 959, 0, 960, 961, 962, 963, 964,
|
|
965, 0, 966, 0, 967, 968, 85, 1250, 13, 14,
|
|
0, 15, 16, 0, 622, 0, 20, 0, 0, 93,
|
|
0, 0, 0, 0, 23, 0, 0, 0, 0, 27,
|
|
1414, 0, 30, 0, 1609, 0, 0, 102, 0, 0,
|
|
37, 0, 38, 104, 40, 0, 1642, 0, 0, 0,
|
|
0, 108, 2489, 110, 2549, 112, 0, 114, 0, 0,
|
|
0, 0, 0, 0, 119, 0, 0, 59, 752, 0,
|
|
0, 0, 0, 0, 1649, 0, 0, 0, 70, 0,
|
|
0, 130, 131, 0, 0, 0, 1655, 0, 0, 0,
|
|
0, 2587, 0, 0, 0, 0, 2588, 0, 0, 143,
|
|
0, 0, 85, 0, 0, 0, 608, 0, 0, 2588,
|
|
0, 2608, 2611, 0, 0, 93, 0, 0, 0, 0,
|
|
155, 0, 0, 156, 2611, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 102, 0, 1678, 1038, 0, 0, 104,
|
|
0, 0, 0, 0, 0, 0, 0, 108, 0, 110,
|
|
1690, 112, 0, 114, 0, 0, 0, 1698, 1104, 0,
|
|
119, 2043, 0, 0, 0, 0, 2046, 893, 0, 0,
|
|
0, 0, 0, 1708, 0, 1711, 0, 130, 131, 2056,
|
|
0, 0, 0, 837, 0, 0, 611, 0, 893, 0,
|
|
612, 613, 614, 615, 0, 143, 0, 0, 0, 0,
|
|
0, 2058, 1726, 616, 0, 0, 0, 2060, 0, 0,
|
|
617, 2062, 618, 1738, 837, 0, 155, 611, 0, 156,
|
|
0, 612, 613, 614, 615, 0, 1752, 0, 0, 1037,
|
|
0, 1758, 611, 1764, 616, 0, 612, 613, 614, 615,
|
|
619, 617, 0, 618, 0, 0, 0, 0, 0, 616,
|
|
0, 0, 1473, 0, 2201, 611, 617, 0, 618, 612,
|
|
613, 614, 615, 0, 0, 0, 0, 1725, 620, 0,
|
|
611, 619, 616, 0, 612, 613, 614, 615, 0, 617,
|
|
0, 618, 0, 0, 0, 0, 619, 616, 0, 1612,
|
|
0, 0, 0, 0, 617, 0, 618, 0, 0, 620,
|
|
0, 0, 0, 1751, 0, 424, 611, 0, 0, 619,
|
|
612, 613, 614, 615, 620, 0, 0, 0, 0, 0,
|
|
0, 0, 951, 616, 619, 621, 952, 0, 0, 0,
|
|
617, 0, 618, 953, 954, 0, 424, 620, 0, 1896,
|
|
956, 0, -1192, 0, 0, -1192, -1192, -1192, -1192, -1192,
|
|
0, 424, 620, 752, 967, 0, 621, 0, 0, 0,
|
|
619, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 621, 0, 0, 424, 0, 0, 622, 0, 0,
|
|
1940, 826, 1355, 0, 0, 0, 0, 0, 620, 424,
|
|
0, 0, 0, 0, 621, 0, 2200, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 622, 621,
|
|
2211, 1960, 0, 0, 1962, 2214, 0, 0, 2215, 1085,
|
|
0, 1085, 1966, 622, 0, 424, 0, 0, 2222, 0,
|
|
2223, 0, 2224, 0, 2225, 0, 0, 0, 0, 0,
|
|
1104, 1104, 0, 0, 0, 621, 622, 0, 0, 0,
|
|
0, 1723, 0, 0, 1989, 0, 1992, 752, 0, 1733,
|
|
0, 622, 1735, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 812, 0, 0, 0, 1104, 1104,
|
|
0, 1991, 0, 0, 611, 0, 0, 0, 612, 613,
|
|
614, 615, 0, 0, 0, 0, 0, 622, 0, 0,
|
|
752, 616, 0, 0, 0, 0, 0, 1800, 617, 0,
|
|
618, 0, 0, 0, 0, 0, 752, 752, 752, 0,
|
|
752, 752, 611, 0, 752, 0, 612, 613, 614, 615,
|
|
611, 0, 0, 0, 612, 1005, 614, 615, 619, 616,
|
|
0, 1250, 0, 0, 0, 0, 617, 616, 618, 0,
|
|
0, 0, 0, 0, 617, 0, 618, 0, 0, 0,
|
|
0, 0, 0, 951, 0, 1727, 620, 952, 611, 0,
|
|
0, 0, 0, 0, 953, 954, 619, 0, 0, 1728,
|
|
955, 956, 957, 958, 619, 0, 960, 961, 962, 963,
|
|
964, 965, 0, 966, 0, 967, 968, 0, 0, 0,
|
|
0, 0, 2093, 424, 620, 1914, 0, 0, 0, 2102,
|
|
0, 0, 620, 2106, 2107, 0, 0, 0, 0, 0,
|
|
0, 2114, 0, 621, 0, 0, 0, 1112, 0, 0,
|
|
0, 1113, 611, 0, 0, 0, 0, 752, 1114, 1115,
|
|
0, 424, 0, 0, 1116, 1117, 1118, 1119, 0, 424,
|
|
1120, 1121, 1122, 1123, 1124, 1125, 1126, 1127, 0, 1128,
|
|
1129, 621, 2145, 0, 0, 0, 0, 0, 1649, 621,
|
|
0, 0, 0, 0, 0, 622, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 2164, 0, 0, 752, 752, 752, 0,
|
|
0, 0, 2169, 0, 0, 951, 0, 1180, 0, 952,
|
|
611, 0, 0, 622, 0, 0, 953, 954, 0, 2179,
|
|
2180, 622, 955, 956, 957, 958, 0, 0, 960, 961,
|
|
962, 963, 964, 965, 0, 966, 0, 967, 968, 0,
|
|
0, 0, 0, 0, 0, 0, 1104, 0, 1752, 0,
|
|
0, 0, 0, 0, 0, 0, 838, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 2210, 0, 951, 0,
|
|
0, 1246, 952, 611, 0, 0, 0, 0, 0, 953,
|
|
954, 0, 2220, 0, 2221, 955, 956, 957, 958, 0,
|
|
0, 960, 961, 962, 963, 964, 965, 0, 966, 0,
|
|
967, 968, 951, 0, 0, 1247, 952, 611, 0, 0,
|
|
0, 969, 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,
|
|
1250, 752, 0, 0, 752, 951, 1104, 1104, 1104, 952,
|
|
1149, 1149, 1250, 0, 0, 0, 953, 954, 1149, 1149,
|
|
0, 0, 955, 956, 957, 958, 0, 0, 960, 961,
|
|
962, 963, 964, 965, 0, 966, 0, 967, 968, 2296,
|
|
0, 0, 0, 0, 2298, 1346, 1346, 1346, 1346, 1346,
|
|
0, 0, 0, 0, 951, 2307, 1966, 1248, 952, 611,
|
|
2312, 0, 0, 0, 0, 953, 954, 0, 0, 0,
|
|
2315, 955, 956, 957, 958, 0, 2328, 960, 961, 962,
|
|
963, 964, 965, 0, 966, 951, 967, 968, 2260, 952,
|
|
611, 0, 0, 0, 0, 1250, 953, 954, 0, 0,
|
|
0, 1414, 955, 956, 957, 958, 0, 0, 960, 961,
|
|
962, 963, 964, 965, 0, 966, 0, 967, 968, 0,
|
|
2373, 1130, 0, 0, 0, 969, 0, 0, 951, 0,
|
|
0, 0, 952, 611, 752, 2183, 0, 0, 0, 953,
|
|
954, 0, 0, 0, 1319, 955, 956, 957, 958, 2379,
|
|
0, 960, 961, 962, 963, 964, 965, 812, 966, 0,
|
|
967, 968, 0, 0, 2386, 0, 0, 0, 1104, 0,
|
|
1609, 0, 969, 0, 0, 951, 0, 0, 0, 952,
|
|
611, 0, 0, 0, 969, 0, 953, 954, 0, 2217,
|
|
0, 1398, 955, 956, 957, 958, 0, 0, 960, 961,
|
|
962, 963, 964, 965, 0, 966, 2405, 967, 968, 0,
|
|
0, 0, 0, 0, 752, 2229, 0, 0, 0, 0,
|
|
0, 893, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 969, 969, 969, 969, 951, 969,
|
|
1406, 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, 1914, 966, 0,
|
|
967, 968, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 2449, 2298, 0, 0, 2451, 0,
|
|
2455, 969, 0, 969, 969, 969, 969, 2302, 0, 0,
|
|
752, 0, 2305, 0, 0, 2466, 2467, 0, 2471, 0,
|
|
951, 0, 1421, 0, 952, 611, 0, 0, 2481, 0,
|
|
0, 953, 954, 0, 0, 0, 2485, 955, 956, 957,
|
|
958, 0, 0, 960, 961, 962, 963, 964, 965, 0,
|
|
966, 0, 967, 968, 0, 2405, 0, 0, 0, 0,
|
|
0, 0, 969, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 1250, 2518, 969, 0, 0, 0, 0, 0,
|
|
0, 0, 2524, 2526, 969, 0, 0, 0, 0, 0,
|
|
951, 0, 0, 838, 952, 611, 2538, 0, 1250, 0,
|
|
2540, 953, 954, 0, 0, 969, 1433, 955, 956, 957,
|
|
958, 0, 0, 960, 961, 962, 963, 964, 965, 0,
|
|
966, 969, 967, 968, 0, 969, 969, 0, 0, 0,
|
|
0, 0, 0, 893, 0, 0, 0, 0, 0, 0,
|
|
2526, 0, 0, 0, 2568, 0, 0, 0, 2572, 0,
|
|
0, 0, 1764, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 1764, 2584, 2568, 0,
|
|
0, 0, 0, 0, 1104, 951, 0, 0, 1104, 952,
|
|
611, 0, 0, 969, 0, 0, 953, 954, 0, 0,
|
|
0, 1436, 955, 956, 957, 958, 0, 0, 960, 961,
|
|
962, 963, 964, 965, 0, 966, 951, 967, 968, 0,
|
|
952, 611, 0, 0, 0, 752, 752, 953, 954, 0,
|
|
0, 0, 1437, 955, 956, 957, 958, 0, 0, 960,
|
|
961, 962, 963, 964, 965, 0, 966, 0, 967, 968,
|
|
0, 969, 969, 0, 0, 0, 0, 0, 0, 0,
|
|
1104, 1104, 1104, 1104, 0, 951, 0, 0, 2183, 952,
|
|
611, 0, 0, 0, 0, 0, 953, 954, 752, 0,
|
|
0, 1472, 955, 956, 957, 958, 0, 0, 960, 961,
|
|
962, 963, 964, 965, 0, 966, 0, 967, 968, 0,
|
|
0, 951, 0, 0, 0, 952, 611, 0, 0, 0,
|
|
0, 0, 953, 954, 0, 0, 0, 1519, 955, 956,
|
|
957, 958, 0, 1104, 960, 961, 962, 963, 964, 965,
|
|
0, 966, 0, 967, 968, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 951, 0, 1727, 0, 952, 611, 1104,
|
|
1104, 0, 1104, 0, 953, 954, 0, 0, 0, 2183,
|
|
955, 956, 957, 958, 0, 0, 960, 961, 962, 963,
|
|
964, 965, 0, 966, 0, 967, 968, 969, 969, 969,
|
|
969, 969, 969, 969, 969, 969, 969, 969, 969, 969,
|
|
969, 969, 969, 969, 969, 969, 0, 0, 0, 0,
|
|
0, 0, 0, 1104, 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, 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,
|
|
0, 969, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 380, 381, 382, 383, 0,
|
|
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,
|
|
969, 434, 0, 0, 437, 438, 0, 0, 0, 0,
|
|
0, 0, 445, 446, 969, 0, 449, 0, 0, 0,
|
|
0, 0, 0, 455, 0, 457, 0, 458, 459, 0,
|
|
0, 0, 464, 465, 466, 969, 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, 0, 0, 0, 969, 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, 0, 553, 554, 555, 556,
|
|
557, 558, 559, 560, 951, 969, 0, 0, 952, 611,
|
|
0, 0, 0, 0, 0, 953, 954, 0, 0, 0,
|
|
1659, 955, 956, 957, 958, 0, 0, 960, 961, 962,
|
|
963, 964, 965, 0, 966, 0, 967, 968, 969, 0,
|
|
0, 0, 0, 0, 0, 969, 0, 0, 0, 0,
|
|
0, 969, 0, 0, 0, 0, 638, 0, 0, 651,
|
|
0, 654, 0, 0, 0, 951, 0, 0, 0, 952,
|
|
611, 0, 0, 0, 969, 0, 953, 954, 0, 0,
|
|
0, 1934, 955, 956, 957, 958, 969, 0, 960, 961,
|
|
962, 963, 964, 965, 969, 966, 0, 967, 968, 0,
|
|
0, 0, 0, 0, 969, 0, 0, 969, 0, 0,
|
|
0, 0, 951, 0, 0, 0, 952, 611, 0, 0,
|
|
0, 0, 969, 953, 954, 0, 0, 0, 1972, 955,
|
|
956, 957, 958, 0, 969, 960, 961, 962, 963, 964,
|
|
965, 0, 966, 0, 967, 968, 0, 951, 969, 1990,
|
|
0, 952, 611, 0, 969, 0, 0, 0, 953, 954,
|
|
969, 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, 2022, 955, 956, 957, 958, 0,
|
|
0, 960, 961, 962, 963, 964, 965, 0, 966, 0,
|
|
967, 968, 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, 0, 966, 0, 967, 968, 951, 0, 2181, 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, 969, 2272, 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, 0, 0, 0, 953, 954, 0, 0, 0,
|
|
2280, 955, 956, 957, 958, 0, 969, 960, 961, 962,
|
|
963, 964, 965, 0, 966, 0, 967, 968, 951, 0,
|
|
0, 0, 952, 611, 0, 0, 969, 0, 969, 953,
|
|
954, 0, 969, 0, 2295, 955, 956, 957, 958, 0,
|
|
0, 960, 961, 962, 963, 964, 965, 0, 966, 0,
|
|
967, 968, 0, 0, 0, 969, 0, 0, 969, 951,
|
|
0, 0, 2306, 952, 611, 0, 0, 0, 0, 0,
|
|
953, 954, 0, 941, 942, 0, 955, 956, 957, 958,
|
|
1130, 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, 2310, 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, 2369, 955, 956,
|
|
957, 958, 0, 0, 960, 961, 962, 963, 964, 965,
|
|
0, 966, 0, 967, 968, 0, 0, 0, 951, 969,
|
|
0, 0, 952, 611, 0, 0, 0, 0, 969, 953,
|
|
954, 0, 969, 969, 2370, 955, 956, 957, 958, 0,
|
|
969, 960, 961, 962, 963, 964, 965, 0, 966, 951,
|
|
967, 968, 2395, 952, 611, 0, 0, 0, 0, 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,
|
|
969, 0, 951, 0, 0, 969, 952, 611, 0, 0,
|
|
0, 0, 0, 953, 954, 969, 969, 0, 2402, 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, 969, 951, 0, 0,
|
|
2419, 952, 611, 0, 0, 0, 969, 969, 953, 954,
|
|
0, 0, 0, 0, 955, 956, 957, 958, 0, 0,
|
|
960, 961, 962, 963, 964, 965, 0, 966, 951, 967,
|
|
968, 2437, 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, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 969, 0, 969, 0, 0, 0, 0, 0,
|
|
0, 0, 951, 969, 0, 0, 952, 611, 969, 0,
|
|
0, 969, 0, 953, 954, 0, 0, 0, 2444, 955,
|
|
956, 957, 958, 0, 969, 960, 961, 962, 963, 964,
|
|
965, 0, 966, 951, 967, 968, 2493, 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, 969,
|
|
0, 952, 611, 0, 0, 969, 0, 0, 953, 954,
|
|
0, 0, 969, 2495, 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, 2506, 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, 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, 2507, 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, 0, 969, 0, 0, 0, 0, 0,
|
|
969, 0, 969, 0, 0, 0, 951, 0, 0, 2511,
|
|
952, 611, 9, 0, 969, 0, 969, 953, 954, 10,
|
|
0, 0, 0, 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, 0, 952,
|
|
611, 208, 0, 0, 0, 0, 953, 954, 0, 0,
|
|
0, 2516, 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, 2545, 955, 956, 957, 958, 0, 0, 960,
|
|
961, 962, 963, 964, 965, 0, 966, 951, 967, 968,
|
|
2559, 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, 2578, 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, 767, 381, 1031, 496, 497, 498, 499, 486,
|
|
390, 395, 378, 544, 1138, 894, 1460, 754, 894, 1340,
|
|
634, 659, 660, 975, 895, 433, 925, 1608, 660, 1638,
|
|
210, 62, 63, 404, 257, 1987, 638, 1498, 69, 262,
|
|
1494, 2027, 1311, 414, 881, 416, 1866, 1154, 1868, 257,
|
|
421, 422, 423, 1518, 262, 981, 76, 470, 429, 747,
|
|
2096, 432, 849, 434, 1373, 1311, 1614, 98, 118, 613,
|
|
436, 1614, 122, 259, 1005, 8, 262, 263, 1071, 99,
|
|
8, 63, 849, 1625, 1634, 1530, 7, 453, 483, 1639,
|
|
1528, 7, 1530, 471, 1532, 15, 116, 1915, 15, 1680,
|
|
7, 467, 5, 1530, 2206, 175, 472, 475, 71, 116,
|
|
476, 1530, 478, 1530, 1530, 659, 660, 391, 5, 116,
|
|
0, 1, 94, 1530, 144, 491, 974, 975, 37, 1530,
|
|
41, 16, 17, 8, 21, 182, 1528, 503, 1530, 505,
|
|
1532, 649, 191, 169, 129, 20, 512, 677, 1027, 15,
|
|
266, 1027, 1179, 15, 212, 58, 12, 5, 8, 7,
|
|
15, 8, 18, 1716, 1717, 1718, 409, 182, 15, 129,
|
|
20, 287, 28, 1166, 1050, 31, 5, 15, 34, 15,
|
|
16, 17, 208, 86, 242, 41, 552, 172, 116, 45,
|
|
15, 8, 3, 49, 225, 116, 5, 391, 8, 116,
|
|
116, 8, 315, 20, 147, 148, 166, 92, 37, 116,
|
|
21, 67, 129, 20, 437, 71, 72, 15, 15, 21,
|
|
129, 77, 78, 126, 191, 15, 15, 83, 84, 15,
|
|
86, 87, 88, 89, 137, 91, 8, 180, 351, 1560,
|
|
483, 116, 129, 466, 100, 208, 3, 129, 20, 105,
|
|
473, 107, 475, 129, 324, 111, 282, 637, 230, 115,
|
|
257, 117, 165, 129, 149, 314, 116, 475, 124, 26,
|
|
150, 318, 128, 641, 129, 2377, 132, 645, 134, 767,
|
|
8, 129, 129, 813, 652, 141, 142, 149, 480, 145,
|
|
146, 129, 1191, 129, 149, 151, 804, 153, 209, 116,
|
|
315, 157, 64, 318, 129, 1920, 1921, 2125, 1861, 116,
|
|
1919, 1864, 284, 149, 694, 282, 201, 228, 592, 129,
|
|
129, 254, 1446, 295, 516, 696, 246, 129, 184, 257,
|
|
186, 129, 129, 728, 822, 23, 257, 193, 194, 129,
|
|
257, 257, 700, 129, 116, 376, 377, 755, 1657, 37,
|
|
257, 382, 383, 384, 385, 258, 387, 388, 716, 15,
|
|
391, 2313, 393, 394, 395, 396, 1916, 1005, 399, 1615,
|
|
1616, 402, 8, 404, 976, 3, 1918, 257, 409, 1305,
|
|
1818, 412, 257, 414, 578, 416, 1831, 15, 116, 420,
|
|
421, 422, 423, 1831, 588, 589, 590, 591, 429, 1837,
|
|
431, 432, 1189, 434, 1831, 1093, 1867, 257, 191, 440,
|
|
441, 1438, 1831, 1178, 1831, 1831, 447, 448, 641, 1345,
|
|
815, 452, 645, 1190, 1831, 8, 1818, 8, 459, 652,
|
|
1831, 462, 1459, 641, 657, 803, 844, 645, 420, 1831,
|
|
257, 1994, 492, 474, 652, 1837, 477, 1378, 1379, 1380,
|
|
257, 3, 483, 484, 485, 486, 1304, 488, 489, 651,
|
|
15, 1005, 654, 92, 495, 496, 497, 498, 499, 183,
|
|
501, 1085, 1110, 504, 26, 506, 507, 191, 1110, 510,
|
|
116, 989, 513, 991, 678, 257, 517, 232, 233, 847,
|
|
998, 257, 1418, 238, 208, 8, 148, 547, 1605, 1606,
|
|
858, 8, 1495, 8, 64, 288, 21, 701, 128, 922,
|
|
2546, 2547, 8, 20, 191, 546, 299, 875, 2504, 129,
|
|
149, 2074, 2418, 573, 2139, 2140, 8, 2136, 180, 257,
|
|
580, 208, 8, 564, 8, 116, 1857, 157, 8, 149,
|
|
8, 572, 2494, 923, 575, 576, 577, 578, 23, 569,
|
|
570, 407, 583, 584, 912, 37, 587, 588, 589, 590,
|
|
591, 581, 37, 2017, 595, 596, 1110, 2028, 926, 129,
|
|
2118, 2036, 201, 8, 5, 2118, 8, 7, 9, 8,
|
|
803, 8, 8, 763, 8, 2127, 8, 773, 8, 149,
|
|
970, 47, 1528, 2413, 1530, 803, 1532, 217, 1534, 2551,
|
|
8, 8, 8, 116, 798, 282, 37, 2160, 285, 116,
|
|
802, 116, 804, 2509, 129, 37, 1528, 37, 1530, 669,
|
|
1532, 257, 1534, 8, 992, 993, 994, 995, 996, 8,
|
|
661, 662, 663, 664, 665, 666, 667, 687, 8, 670,
|
|
116, 1910, 116, 357, 358, 244, 1915, 678, 116, 843,
|
|
1158, 3, 846, 23, 129, 511, 1014, 880, 881, 5,
|
|
2563, 1019, 1042, 9, 1910, 696, 18, 37, 699, 128,
|
|
701, 894, 1052, 129, 2577, 8, 257, 2286, 16, 17,
|
|
1318, 116, 1561, 21, 116, 1561, 1318, 116, 21, 116,
|
|
116, 37, 116, 724, 3, 1460, 1461, 747, 157, 1536,
|
|
1537, 1538, 1060, 1540, 1541, 5, 15, 1444, 116, 116,
|
|
3, 2601, 2602, 3, 764, 15, 15, 84, 749, 84,
|
|
751, 177, 15, 754, 2614, 15, 5, 1653, 778, 1660,
|
|
1661, 1662, 331, 8, 3, 785, 767, 16, 17, 8,
|
|
1378, 1379, 1380, 22, 257, 24, 777, 346, 347, 348,
|
|
257, 43, 257, 3, 33, 786, 35, 788, 37, 5,
|
|
7, 7, 793, 8, 795, 15, 1692, 798, 15, 992,
|
|
993, 994, 995, 996, 1318, 67, 1320, 1000, 1001, 8,
|
|
811, 257, 8, 257, 992, 993, 994, 995, 996, 257,
|
|
82, 822, 21, 7, 8, 87, 88, 828, 3, 8,
|
|
8, 851, 94, 1439, 1027, 1441, 8, 22, 2389, 24,
|
|
15, 63, 843, 21, 191, 846, 68, 194, 33, 21,
|
|
35, 852, 257, 2376, 191, 257, 191, 1050, 257, 8,
|
|
257, 257, 882, 257, 1378, 1379, 1380, 887, 90, 91,
|
|
8, 208, 21, 208, 18, 8, 896, 897, 898, 257,
|
|
257, 901, 26, 21, 8, 886, 2125, 1365, 1366, 1367,
|
|
1368, 1369, 5, 8, 8, 1088, 9, 21, 5, 1277,
|
|
8, 902, 903, 16, 17, 2428, 21, 2338, 15, 7,
|
|
159, 95, 1818, 162, 904, 15, 8, 918, 16, 17,
|
|
8, 941, 144, 15, 37, 1831, 7, 8, 265, 919,
|
|
265, 1837, 154, 21, 8, 1841, 1818, 354, 8, 940,
|
|
124, 3, 359, 8, 129, 282, 8, 282, 285, 1831,
|
|
285, 21, 289, 290, 289, 1837, 21, 1285, 8, 1841,
|
|
257, 298, 299, 8, 299, 262, 228, 304, 683, 304,
|
|
1427, 21, 1429, 158, 159, 1303, 161, 162, 200, 8,
|
|
2411, 8, 8, 1905, 1906, 1907, 1908, 1909, 862, 863,
|
|
22, 865, 24, 2284, 21, 21, 2410, 259, 247, 8,
|
|
8, 33, 1352, 35, 1024, 8, 1354, 192, 1358, 7,
|
|
8, 195, 21, 21, 1860, 147, 148, 8, 202, 8,
|
|
7, 8, 1023, 1872, 1893, 41, 1872, 8, 1029, 1870,
|
|
1871, 1766, 21, 1740, 1035, 8, 89, 1878, 1879, 8,
|
|
21, 303, 8, 1939, 8, 1863, 7, 1048, 180, 234,
|
|
1398, 8, 1660, 1661, 1662, 71, 305, 306, 307, 1955,
|
|
15, 2155, 247, 1411, 21, 1961, 8, 1963, 7, 122,
|
|
8, 2502, 1073, 1093, 1424, 352, 353, 1078, 15, 21,
|
|
1652, 1101, 149, 21, 316, 317, 2500, 1905, 1906, 1907,
|
|
1908, 1909, 8, 1094, 920, 339, 1437, 44, 342, 343,
|
|
344, 15, 155, 8, 1432, 21, 1955, 8, 1109, 1955,
|
|
5, 355, 356, 15, 9, 1961, 21, 16, 17, 135,
|
|
21, 16, 17, 8, 8, 1145, 158, 159, 23, 161,
|
|
162, 1866, 185, 1868, 1470, 15, 21, 21, 8, 191,
|
|
87, 15, 37, 149, 1308, 860, 1660, 1661, 1662, 864,
|
|
8, 21, 15, 169, 869, 15, 208, 872, 873, 15,
|
|
192, 8, 8, 21, 15, 218, 5, 15, 1188, 37,
|
|
9, 8, 119, 15, 21, 191, 15, 16, 17, 15,
|
|
1373, 1517, 314, 315, 21, 15, 318, 319, 27, 15,
|
|
8, 8, 208, 209, 1020, 8, 143, 36, 145, 252,
|
|
1615, 1616, 234, 21, 21, 221, 8, 223, 224, 1559,
|
|
226, 1231, 5, 229, 7, 247, 931, 10, 933, 21,
|
|
15, 14, 15, 16, 17, 64, 1246, 1247, 1248, 8,
|
|
282, 178, 63, 285, 27, 8, 183, 68, 290, 15,
|
|
187, 34, 21, 36, 191, 8, 298, 194, 21, 8,
|
|
15, 410, 1272, 92, 8, 349, 350, 8, 21, 90,
|
|
91, 8, 21, 5, 248, 249, 282, 21, 10, 216,
|
|
21, 64, 14, 15, 16, 17, 15, 1278, 1279, 1780,
|
|
15, 1782, 1783, 230, 1477, 27, 15, 8, 15, 236,
|
|
129, 15, 34, 1794, 36, 15, 8, 1647, 15, 92,
|
|
21, 1302, 2396, 1804, 320, 1806, 322, 1308, 5, 21,
|
|
149, 1312, 9, 144, 15, 8, 8, 8, 1656, 16,
|
|
17, 1671, 64, 154, 21, 8, 23, 1520, 21, 21,
|
|
21, 1000, 1001, 1683, 15, 2332, 129, 1687, 21, 8,
|
|
37, 1669, 8, 1536, 1537, 1538, 8, 1540, 1541, 124,
|
|
92, 1544, 21, 1937, 8, 21, 149, 8, 15, 21,
|
|
15, 1702, 201, 522, 8, 524, 15, 21, 1561, 200,
|
|
21, 44, 531, 532, 533, 8, 8, 21, 537, 538,
|
|
539, 540, 1383, 542, 543, 2281, 2232, 129, 21, 21,
|
|
5, 8, 8, 15, 9, 2141, 2142, 2143, 8, 7,
|
|
231, 16, 17, 1731, 21, 21, 8, 149, 201, 2258,
|
|
2306, 21, 2258, 244, 87, 15, 8, 8, 8, 21,
|
|
93, 8, 37, 239, 166, 1426, 1427, 15, 1429, 21,
|
|
21, 21, 2597, 2598, 21, 8, 1437, 15, 1439, 8,
|
|
1441, 2476, 2477, 1444, 124, 5, 119, 3, 21, 9,
|
|
10, 252, 21, 15, 14, 15, 16, 17, 246, 201,
|
|
1286, 870, 871, 1656, 1657, 246, 1944, 27, 8, 8,
|
|
143, 15, 145, 1493, 34, 1476, 36, 26, 1656, 21,
|
|
8, 21, 21, 8, 1485, 1200, 1660, 1661, 1662, 8,
|
|
1491, 1206, 1512, 21, 1514, 1210, 21, 1212, 1213, 1214,
|
|
1501, 1216, 21, 1218, 64, 178, 8, 8, 15, 8,
|
|
183, 7, 240, 8, 187, 8, 8, 1518, 191, 1539,
|
|
21, 194, 21, 1716, 1717, 1718, 21, 15, 21, 5,
|
|
15, 8, 92, 1553, 10, 15, 8, 8, 14, 15,
|
|
16, 17, 8, 216, 21, 15, 8, 2544, 1549, 1569,
|
|
21, 27, 15, 149, 1574, 21, 5, 230, 34, 21,
|
|
36, 10, 1582, 236, 8, 14, 15, 16, 17, 129,
|
|
1590, 175, 15, 16, 17, 8, 15, 21, 27, 8,
|
|
1600, 8, 1602, 8, 27, 34, 8, 36, 64, 149,
|
|
8, 40, 21, 36, 1595, 15, 21, 8, 8, 2334,
|
|
8, 8, 5, 21, 8, 26, 9, 7, 1956, 15,
|
|
21, 21, 62, 16, 17, 64, 92, 21, 8, 22,
|
|
23, 64, 25, 1959, 1625, 28, 29, 30, 31, 32,
|
|
15, 21, 35, 15, 37, 38, 8, 1638, 8, 8,
|
|
21, 201, 8, 92, 8, 8, 2230, 287, 15, 92,
|
|
8, 21, 21, 129, 455, 21, 1657, 816, 21, 1660,
|
|
1661, 1662, 8, 21, 8, 8, 213, 1860, 1861, 1670,
|
|
8, 1864, 8, 149, 2028, 2410, 8, 2412, 2413, 1872,
|
|
129, 15, 5, 21, 7, 21, 129, 10, 8, 490,
|
|
166, 14, 15, 16, 17, 9, 64, 1412, 5, 500,
|
|
149, 1702, 9, 129, 27, 8, 149, 9, 5, 16,
|
|
17, 34, 9, 36, 21, 21, 23, 8, 21, 16,
|
|
17, 1722, 8, 8, 8, 201, 23, 8, 25, 37,
|
|
37, 28, 29, 30, 31, 32, 21, 21, 2473, 1740,
|
|
37, 64, 15, 204, 205, 206, 207, 208, 67, 15,
|
|
15, 15, 201, 554, 555, 556, 557, 558, 201, 2206,
|
|
15, 15, 1955, 15, 2499, 2500, 2116, 5, 1961, 92,
|
|
15, 9, 1487, 1774, 1775, 8, 2126, 8, 16, 17,
|
|
26, 129, 7, 15, 22, 23, 7, 25, 18, 37,
|
|
28, 29, 30, 31, 32, 21, 7, 5, 1799, 37,
|
|
15, 1994, 21, 21, 26, 7, 129, 15, 16, 17,
|
|
8, 15, 613, 614, 615, 15, 617, 26, 2553, 27,
|
|
8, 8, 21, 624, 5, 21, 149, 5, 36, 10,
|
|
15, 9, 15, 14, 15, 16, 17, 638, 16, 17,
|
|
15, 15, 1862, 21, 15, 23, 27, 15, 8, 21,
|
|
1851, 21, 8, 34, 15, 36, 64, 1877, 5, 37,
|
|
15, 1881, 2323, 2324, 15, 15, 16, 17, 62, 21,
|
|
8, 7, 15, 8, 8, 8, 8, 27, 201, 680,
|
|
255, 2074, 7, 64, 92, 15, 36, 437, 166, 15,
|
|
239, 15, 21, 16, 695, 15, 15, 208, 191, 21,
|
|
8, 7, 1061, 15, 15, 15, 315, 331, 15, 59,
|
|
63, 92, 15, 1072, 64, 68, 466, 1918, 1919, 1920,
|
|
1921, 129, 723, 473, 15, 15, 15, 332, 15, 730,
|
|
1931, 481, 15, 15, 15, 736, 737, 90, 91, 15,
|
|
15, 149, 92, 15, 15, 15, 15, 15, 129, 15,
|
|
7, 5, 2410, 2411, 1974, 2303, 10, 1958, 246, 246,
|
|
14, 15, 16, 17, 246, 5, 246, 2160, 149, 246,
|
|
8, 124, 15, 27, 5, 21, 1996, 21, 15, 10,
|
|
34, 782, 36, 14, 15, 16, 17, 8, 7, 21,
|
|
8, 144, 21, 201, 21, 15, 27, 21, 26, 149,
|
|
15, 154, 8, 34, 173, 36, 1165, 15, 15, 8,
|
|
64, 2012, 255, 7, 15, 2016, 21, 2018, 15, 208,
|
|
201, 71, 2042, 18, 8, 15, 15, 2028, 15, 15,
|
|
15, 2051, 15, 64, 2035, 2036, 149, 15, 92, 2232,
|
|
1199, 21, 21, 593, 21, 21, 1205, 200, 21, 2069,
|
|
1209, 201, 1211, 21, 855, 856, 1215, 5, 1217, 15,
|
|
15, 92, 10, 21, 21, 2258, 14, 15, 16, 17,
|
|
8, 15, 5, 15, 9, 129, 7, 20, 8, 27,
|
|
233, 21, 21, 8, 21, 26, 34, 21, 36, 21,
|
|
5, 244, 15, 21, 9, 149, 15, 26, 129, 26,
|
|
15, 16, 17, 21, 26, 21, 7, 657, 21, 21,
|
|
15, 8, 27, 254, 21, 26, 64, 15, 149, 21,
|
|
15, 36, 8, 132, 7, 21, 2127, 7, 21, 37,
|
|
21, 15, 7, 15, 7, 2136, 21, 2138, 2139, 2140,
|
|
2141, 2142, 2143, 21, 92, 15, 255, 201, 2168, 64,
|
|
951, 952, 953, 954, 955, 956, 957, 958, 959, 960,
|
|
961, 962, 963, 964, 965, 966, 967, 968, 969, 15,
|
|
201, 15, 15, 15, 15, 976, 15, 92, 15, 15,
|
|
981, 129, 2375, 2376, 15, 7, 21, 988, 8, 990,
|
|
15, 8, 8, 7, 21, 8, 7, 5, 8, 749,
|
|
92, 149, 21, 15, 1005, 2206, 2207, 15, 16, 17,
|
|
7, 7, 15, 78, 129, 21, 330, 767, 8, 27,
|
|
21, 7, 353, 7, 352, 17, 21, 15, 36, 2249,
|
|
1031, 781, 15, 15, 149, 2428, 1037, 15, 17, 789,
|
|
790, 21, 8, 15, 794, 7, 7, 15, 2268, 7,
|
|
903, 166, 1053, 201, 128, 1279, 64, 223, 1890, 911,
|
|
2014, 1600, 1192, 1097, 586, 2281, 1604, 1891, 594, 597,
|
|
1310, 1634, 822, 714, 2286, 1434, 940, 2138, 1918, 940,
|
|
830, 1910, 1501, 2118, 92, 2286, 201, 1741, 1161, 2188,
|
|
7, 2484, 2012, 10, 1485, 2207, 1033, 14, 15, 16,
|
|
17, 1053, 1421, 1400, 1095, 1713, 75, 2603, 1715, 859,
|
|
27, 861, 1939, 1961, 715, 1444, 1407, 34, 466, 36,
|
|
1042, 129, 2323, 2324, 1483, 1653, 247, 247, 796, 1656,
|
|
880, 881, 2333, 247, 1005, 1078, 661, 1138, 247, 1109,
|
|
1181, 149, 842, 664, 894, 895, 663, 64, 666, 665,
|
|
2333, 1423, 1425, 2167, 2551, 1156, 2016, 2396, 811, 1048,
|
|
1023, 1021, 2523, 1094, 1523, 1958, 2456, 1526, 1035, 792,
|
|
1529, 445, 1531, 1998, 1533, 92, 1535, 2409, 1179, 1180,
|
|
1181, 2553, 45, 46, 2579, 48, 49, 2599, 2341, 1499,
|
|
53, 2601, 1766, 201, 670, 1461, 2019, 385, 61, 2400,
|
|
765, 1963, 507, 66, 2424, 418, 69, 1553, 2023, 2410,
|
|
2411, 2313, 129, 2433, 77, 1818, 79, 1837, 81, 1841,
|
|
2440, 1793, 2442, 1798, 974, 975, 2364, 1831, 2049, 2048,
|
|
1238, 1231, 149, 2069, 2382, 1851, 884, 1549, 1569, 2232,
|
|
1574, 104, 5, 1582, 2445, 1590, 9, 10, 1249, 166,
|
|
1000, 1001, 115, 16, 17, 2268, 2476, 2477, -1, 22,
|
|
23, 24, 25, 26, -1, 28, 29, 30, 31, 32,
|
|
33, -1, 35, -1, 37, 38, 139, 1027, 45, 46,
|
|
-1, 48, 49, -1, 201, -1, 53, -1, -1, 152,
|
|
-1, -1, -1, -1, 61, -1, -1, -1, -1, 66,
|
|
1050, -1, 69, -1, 1305, -1, -1, 170, -1, -1,
|
|
77, -1, 79, 176, 81, -1, 1317, -1, -1, -1,
|
|
-1, 184, 2523, 186, 2525, 188, -1, 190, -1, -1,
|
|
-1, -1, -1, -1, 197, -1, -1, 104, 1088, -1,
|
|
-1, -1, -1, -1, 1345, -1, -1, -1, 115, -1,
|
|
-1, 214, 215, -1, -1, -1, 1357, -1, -1, -1,
|
|
-1, 2581, -1, -1, -1, -1, 2586, -1, -1, 232,
|
|
-1, -1, 139, -1, -1, -1, 239, -1, -1, 2599,
|
|
-1, 2601, 2602, -1, -1, 152, -1, -1, -1, -1,
|
|
253, -1, -1, 256, 2614, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 170, -1, 1406, 1407, -1, -1, 176,
|
|
-1, -1, -1, -1, -1, -1, -1, 184, -1, 186,
|
|
1421, 188, -1, 190, -1, -1, -1, 1428, 1178, -1,
|
|
197, 1790, -1, -1, -1, -1, 1795, 1438, -1, -1,
|
|
-1, -1, -1, 1444, -1, 1446, -1, 214, 215, 1808,
|
|
-1, -1, -1, 7, -1, -1, 10, -1, 1459, -1,
|
|
14, 15, 16, 17, -1, 232, -1, -1, -1, -1,
|
|
-1, 1830, 1473, 27, -1, -1, -1, 1836, -1, -1,
|
|
34, 1840, 36, 1484, 7, -1, 253, 10, -1, 256,
|
|
-1, 14, 15, 16, 17, -1, 1497, -1, -1, 7,
|
|
-1, 1502, 10, 1504, 27, -1, 14, 15, 16, 17,
|
|
64, 34, -1, 36, -1, -1, -1, -1, -1, 27,
|
|
-1, -1, 7, -1, 78, 10, 34, -1, 36, 14,
|
|
15, 16, 17, -1, -1, -1, -1, 7, 92, -1,
|
|
10, 64, 27, -1, 14, 15, 16, 17, -1, 34,
|
|
-1, 36, -1, -1, -1, -1, 64, 27, -1, 1309,
|
|
-1, -1, -1, -1, 34, -1, 36, -1, -1, 92,
|
|
-1, -1, -1, 7, -1, 129, 10, -1, -1, 64,
|
|
14, 15, 16, 17, 92, -1, -1, -1, -1, -1,
|
|
-1, -1, 5, 27, 64, 149, 9, -1, -1, -1,
|
|
34, -1, 36, 16, 17, -1, 129, 92, -1, 1610,
|
|
23, -1, 25, -1, -1, 28, 29, 30, 31, 32,
|
|
-1, 129, 92, 1373, 37, -1, 149, -1, -1, -1,
|
|
64, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, 149, -1, -1, 129, -1, -1, 201, -1, -1,
|
|
1651, 1652, 1653, -1, -1, -1, -1, -1, 92, 129,
|
|
-1, -1, -1, -1, 149, -1, 2025, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, 201, 149,
|
|
2039, 1682, -1, -1, 1685, 2044, -1, -1, 2047, 1439,
|
|
-1, 1441, 1693, 201, -1, 129, -1, -1, 2057, -1,
|
|
2059, -1, 2061, -1, 2063, -1, -1, -1, -1, -1,
|
|
1460, 1461, -1, -1, -1, 149, 201, -1, -1, -1,
|
|
-1, 1471, -1, -1, 1725, -1, 1727, 1477, -1, 1479,
|
|
-1, 201, 1482, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, 1494, -1, -1, -1, 1498, 1499,
|
|
-1, 7, -1, -1, 10, -1, -1, -1, 14, 15,
|
|
16, 17, -1, -1, -1, -1, -1, 201, -1, -1,
|
|
1520, 27, -1, -1, -1, -1, -1, 1527, 34, -1,
|
|
36, -1, -1, -1, -1, -1, 1536, 1537, 1538, -1,
|
|
1540, 1541, 10, -1, 1544, -1, 14, 15, 16, 17,
|
|
10, -1, -1, -1, 14, 15, 16, 17, 64, 27,
|
|
-1, 1561, -1, -1, -1, -1, 34, 27, 36, -1,
|
|
-1, -1, -1, -1, 34, -1, 36, -1, -1, -1,
|
|
-1, -1, -1, 5, -1, 7, 92, 9, 10, -1,
|
|
-1, -1, -1, -1, 16, 17, 64, -1, -1, 21,
|
|
22, 23, 24, 25, 64, -1, 28, 29, 30, 31,
|
|
32, 33, -1, 35, -1, 37, 38, -1, -1, -1,
|
|
-1, -1, 1873, 129, 92, 1625, -1, -1, -1, 1880,
|
|
-1, -1, 92, 1884, 1885, -1, -1, -1, -1, -1,
|
|
-1, 1892, -1, 149, -1, -1, -1, 5, -1, -1,
|
|
-1, 9, 10, -1, -1, -1, -1, 1657, 16, 17,
|
|
-1, 129, -1, -1, 22, 23, 24, 25, -1, 129,
|
|
28, 29, 30, 31, 32, 33, 34, 35, -1, 37,
|
|
38, 149, 1933, -1, -1, -1, -1, -1, 1939, 149,
|
|
-1, -1, -1, -1, -1, 201, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 1964, -1, -1, 1716, 1717, 1718, -1,
|
|
-1, -1, 1973, -1, -1, 5, -1, 7, -1, 9,
|
|
10, -1, -1, 201, -1, -1, 16, 17, -1, 1990,
|
|
1991, 201, 22, 23, 24, 25, -1, -1, 28, 29,
|
|
30, 31, 32, 33, -1, 35, -1, 37, 38, -1,
|
|
-1, -1, -1, -1, -1, -1, 1766, -1, 2019, -1,
|
|
-1, -1, -1, -1, -1, -1, 2027, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, 2037, -1, 5, -1,
|
|
-1, 8, 9, 10, -1, -1, -1, -1, -1, 16,
|
|
17, -1, 2053, -1, 2055, 22, 23, 24, 25, -1,
|
|
-1, 28, 29, 30, 31, 32, 33, -1, 35, -1,
|
|
37, 38, 5, -1, -1, 8, 9, 10, -1, -1,
|
|
-1, 625, -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,
|
|
1860, 1861, -1, -1, 1864, 5, 1866, 1867, 1868, 9,
|
|
1870, 1871, 1872, -1, -1, -1, 16, 17, 1878, 1879,
|
|
-1, -1, 22, 23, 24, 25, -1, -1, 28, 29,
|
|
30, 31, 32, 33, -1, 35, -1, 37, 38, 2150,
|
|
-1, -1, -1, -1, 2155, 1905, 1906, 1907, 1908, 1909,
|
|
-1, -1, -1, -1, 5, 2166, 2167, 8, 9, 10,
|
|
2171, -1, -1, -1, -1, 16, 17, -1, -1, -1,
|
|
2181, 22, 23, 24, 25, -1, 2187, 28, 29, 30,
|
|
31, 32, 33, -1, 35, 5, 37, 38, 8, 9,
|
|
10, -1, -1, -1, -1, 1955, 16, 17, -1, -1,
|
|
-1, 1961, 22, 23, 24, 25, -1, -1, 28, 29,
|
|
30, 31, 32, 33, -1, 35, -1, 37, 38, -1,
|
|
2231, 775, -1, -1, -1, 779, -1, -1, 5, -1,
|
|
-1, -1, 9, 10, 1994, 1995, -1, -1, -1, 16,
|
|
17, -1, -1, -1, 21, 22, 23, 24, 25, 2260,
|
|
-1, 28, 29, 30, 31, 32, 33, 2017, 35, -1,
|
|
37, 38, -1, -1, 2275, -1, -1, -1, 2028, -1,
|
|
2281, -1, 826, -1, -1, 5, -1, -1, -1, 9,
|
|
10, -1, -1, -1, 838, -1, 16, 17, -1, 2049,
|
|
-1, 21, 22, 23, 24, 25, -1, -1, 28, 29,
|
|
30, 31, 32, 33, -1, 35, 2317, 37, 38, -1,
|
|
-1, -1, -1, -1, 2074, 2075, -1, -1, -1, -1,
|
|
-1, 2332, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, 888, 889, 890, 891, 5, 893,
|
|
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, 2127, 35, -1,
|
|
37, 38, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, 2395, 2396, -1, -1, 2399, -1,
|
|
2401, 945, -1, 947, 948, 949, 950, 2157, -1, -1,
|
|
2160, -1, 2162, -1, -1, 2416, 2417, -1, 2419, -1,
|
|
5, -1, 7, -1, 9, 10, -1, -1, 2429, -1,
|
|
-1, 16, 17, -1, -1, -1, 2437, 22, 23, 24,
|
|
25, -1, -1, 28, 29, 30, 31, 32, 33, -1,
|
|
35, -1, 37, 38, -1, 2456, -1, -1, -1, -1,
|
|
-1, -1, 1006, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, 2232, 2484, 1028, -1, -1, -1, -1, -1,
|
|
-1, -1, 2493, 2494, 1038, -1, -1, -1, -1, -1,
|
|
5, -1, -1, 2504, 9, 10, 2507, -1, 2258, -1,
|
|
2511, 16, 17, -1, -1, 1059, 21, 22, 23, 24,
|
|
25, -1, -1, 28, 29, 30, 31, 32, 33, -1,
|
|
35, 1075, 37, 38, -1, 1079, 1080, -1, -1, -1,
|
|
-1, -1, -1, 2544, -1, -1, -1, -1, -1, -1,
|
|
2551, -1, -1, -1, 2555, -1, -1, -1, 2559, -1,
|
|
-1, -1, 2563, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, 2577, 2578, 2579, -1,
|
|
-1, -1, -1, -1, 2334, 5, -1, -1, 2338, 9,
|
|
10, -1, -1, 1137, -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, 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, 1195, 1196, -1, -1, -1, -1, -1, -1, -1,
|
|
2410, 2411, 2412, 2413, -1, 5, -1, -1, 2418, 9,
|
|
10, -1, -1, -1, -1, -1, 16, 17, 2428, -1,
|
|
-1, 21, 22, 23, 24, 25, -1, -1, 28, 29,
|
|
30, 31, 32, 33, -1, 35, -1, 37, 38, -1,
|
|
-1, 5, -1, -1, -1, 9, 10, -1, -1, -1,
|
|
-1, -1, 16, 17, -1, -1, -1, 21, 22, 23,
|
|
24, 25, -1, 2473, 28, 29, 30, 31, 32, 33,
|
|
-1, 35, -1, 37, 38, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 5, -1, 7, -1, 9, 10, 2499,
|
|
2500, -1, 2502, -1, 16, 17, -1, -1, -1, 2509,
|
|
22, 23, 24, 25, -1, -1, 28, 29, 30, 31,
|
|
32, 33, -1, 35, -1, 37, 38, 1321, 1322, 1323,
|
|
1324, 1325, 1326, 1327, 1328, 1329, 1330, 1331, 1332, 1333,
|
|
1334, 1335, 1336, 1337, 1338, 1339, -1, -1, -1, -1,
|
|
-1, -1, -1, 2553, -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, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, 1405, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, 14, 15, 16, 17, -1,
|
|
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,
|
|
1474, 70, -1, -1, 73, 74, -1, -1, -1, -1,
|
|
-1, -1, 81, 82, 1488, -1, 85, -1, -1, -1,
|
|
-1, -1, -1, 92, -1, 94, -1, 96, 97, -1,
|
|
-1, -1, 101, 102, 103, 1509, -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, -1, -1, -1, 1558, 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, -1, 195, 196, 197, 198,
|
|
199, 200, 201, 202, 5, 1609, -1, -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, 1642, -1,
|
|
-1, -1, -1, -1, -1, 1649, -1, -1, -1, -1,
|
|
-1, 1655, -1, -1, -1, -1, 255, -1, -1, 258,
|
|
-1, 260, -1, -1, -1, 5, -1, -1, -1, 9,
|
|
10, -1, -1, -1, 1678, -1, 16, 17, -1, -1,
|
|
-1, 21, 22, 23, 24, 25, 1690, -1, 28, 29,
|
|
30, 31, 32, 33, 1698, 35, -1, 37, 38, -1,
|
|
-1, -1, -1, -1, 1708, -1, -1, 1711, -1, -1,
|
|
-1, -1, 5, -1, -1, -1, 9, 10, -1, -1,
|
|
-1, -1, 1726, 16, 17, -1, -1, -1, 21, 22,
|
|
23, 24, 25, -1, 1738, 28, 29, 30, 31, 32,
|
|
33, -1, 35, -1, 37, 38, -1, 5, 1752, 7,
|
|
-1, 9, 10, -1, 1758, -1, -1, -1, 16, 17,
|
|
1764, -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, -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, 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, 1896, 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, -1, -1, -1, 16, 17, -1, -1, -1,
|
|
21, 22, 23, 24, 25, -1, 1940, 28, 29, 30,
|
|
31, 32, 33, -1, 35, -1, 37, 38, 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, 5,
|
|
-1, -1, 8, 9, 10, -1, -1, -1, -1, -1,
|
|
16, 17, -1, 602, 603, -1, 22, 23, 24, 25,
|
|
2014, -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, -1, 37, 38, -1, -1, -1, 5, 2093,
|
|
-1, -1, 9, 10, -1, -1, -1, -1, 2102, 16,
|
|
17, -1, 2106, 2107, 21, 22, 23, 24, 25, -1,
|
|
2114, 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, 2145, 28, 29, 30, 31, 32, 33, -1, 35,
|
|
-1, 37, 38, -1, -1, -1, -1, -1, -1, -1,
|
|
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, -1, -1, -1, 2210, 5, -1, -1,
|
|
8, 9, 10, -1, -1, -1, 2220, 2221, 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, -1,
|
|
37, 38, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, 2296, -1, 2298, -1, -1, -1, -1, -1,
|
|
-1, -1, 5, 2307, -1, -1, 9, 10, 2312, -1,
|
|
-1, 2315, -1, 16, 17, -1, -1, -1, 21, 22,
|
|
23, 24, 25, -1, 2328, 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, 2373,
|
|
-1, 9, 10, -1, -1, 2379, -1, -1, 16, 17,
|
|
-1, -1, 2386, 21, 22, 23, 24, 25, -1, -1,
|
|
28, 29, 30, 31, 32, 33, -1, 35, 5, 37,
|
|
38, 2405, 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, 2449, -1, 2451, -1, -1,
|
|
-1, 2455, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, 2466, 2467, -1, -1, -1, 2471, 5, -1,
|
|
-1, 8, 9, 10, -1, -1, -1, 2481, -1, 16,
|
|
17, 2485, -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, -1, 2518, -1, -1, -1, -1, -1,
|
|
2524, -1, 2526, -1, -1, -1, 5, -1, -1, 8,
|
|
9, 10, 6, -1, 2538, -1, 2540, 16, 17, 13,
|
|
-1, -1, -1, 22, 23, 24, 25, -1, -1, 28,
|
|
29, 30, 31, 32, 33, -1, 35, -1, 37, 38,
|
|
-1, -1, -1, -1, 2568, -1, -1, -1, 2572, 43,
|
|
44, 45, 46, -1, 48, 49, 50, 51, 52, 53,
|
|
2584, -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, -1, 9,
|
|
10, 345, -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, 363, 0, 1, 150, 257, 364, 365, 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, 366,
|
|
368, 371, 383, 384, 388, 389, 390, 396, 397, 398,
|
|
399, 401, 402, 404, 406, 407, 408, 409, 416, 417,
|
|
418, 419, 420, 421, 425, 426, 427, 431, 432, 470,
|
|
472, 485, 528, 529, 531, 532, 538, 539, 540, 541,
|
|
548, 549, 550, 551, 553, 556, 560, 561, 562, 563,
|
|
564, 565, 571, 572, 573, 584, 585, 586, 588, 591,
|
|
594, 599, 600, 602, 604, 606, 609, 610, 634, 635,
|
|
646, 647, 648, 649, 654, 657, 660, 663, 664, 714,
|
|
715, 716, 717, 718, 719, 720, 721, 727, 729, 731,
|
|
733, 735, 736, 737, 738, 739, 742, 744, 745, 746,
|
|
749, 750, 754, 755, 757, 758, 759, 760, 761, 762,
|
|
763, 766, 771, 776, 778, 779, 780, 781, 783, 784,
|
|
785, 786, 787, 788, 805, 808, 809, 810, 811, 817,
|
|
820, 825, 826, 827, 830, 831, 832, 833, 834, 835,
|
|
836, 837, 838, 839, 840, 841, 842, 843, 844, 849,
|
|
850, 851, 852, 853, 854, 864, 865, 866, 869, 873,
|
|
874, 875, 876, 877, 882, 902, 15, 495, 495, 557,
|
|
557, 557, 557, 557, 495, 557, 557, 367, 557, 557,
|
|
557, 495, 557, 495, 557, 557, 495, 557, 557, 557,
|
|
494, 557, 495, 557, 557, 7, 15, 496, 15, 495,
|
|
617, 557, 495, 380, 557, 557, 557, 557, 557, 557,
|
|
557, 557, 557, 557, 129, 373, 537, 537, 557, 557,
|
|
557, 495, 557, 373, 557, 495, 495, 557, 557, 494,
|
|
367, 495, 495, 64, 379, 557, 557, 495, 495, 557,
|
|
495, 495, 495, 495, 495, 557, 434, 557, 557, 557,
|
|
373, 471, 367, 495, 557, 557, 557, 495, 557, 495,
|
|
557, 557, 495, 557, 557, 557, 495, 367, 495, 380,
|
|
557, 557, 380, 557, 495, 557, 557, 557, 495, 557,
|
|
557, 495, 557, 495, 557, 557, 557, 557, 557, 557,
|
|
15, 495, 595, 495, 367, 495, 495, 557, 557, 557,
|
|
15, 8, 495, 495, 557, 557, 557, 495, 557, 557,
|
|
557, 557, 557, 557, 557, 557, 557, 557, 557, 557,
|
|
557, 557, 557, 557, 557, 557, 557, 557, 557, 557,
|
|
557, 557, 557, 557, 495, 557, 495, 557, 557, 557,
|
|
557, 495, 495, 557, 557, 557, 557, 557, 557, 557,
|
|
557, 908, 908, 908, 908, 908, 908, 257, 583, 124,
|
|
233, 404, 15, 376, 583, 8, 8, 8, 8, 7,
|
|
8, 124, 368, 391, 8, 373, 405, 8, 8, 8,
|
|
8, 8, 552, 8, 552, 8, 8, 8, 8, 552,
|
|
583, 7, 218, 252, 529, 531, 540, 541, 239, 549,
|
|
549, 10, 14, 15, 16, 17, 27, 34, 36, 64,
|
|
92, 149, 201, 373, 385, 501, 502, 504, 505, 506,
|
|
507, 513, 514, 515, 516, 517, 520, 15, 557, 5,
|
|
9, 15, 16, 17, 129, 503, 505, 513, 567, 581,
|
|
582, 557, 15, 567, 557, 5, 566, 567, 582, 567,
|
|
8, 8, 8, 8, 8, 8, 8, 8, 7, 8,
|
|
8, 5, 7, 373, 644, 645, 373, 637, 496, 15,
|
|
15, 149, 484, 373, 373, 747, 748, 8, 373, 661,
|
|
662, 748, 373, 375, 373, 15, 533, 579, 23, 37,
|
|
373, 423, 424, 15, 373, 607, 373, 675, 675, 373,
|
|
658, 659, 373, 536, 433, 15, 373, 587, 149, 753,
|
|
536, 7, 479, 480, 495, 618, 619, 373, 613, 619,
|
|
15, 558, 373, 589, 590, 536, 15, 15, 536, 753,
|
|
537, 536, 536, 536, 536, 373, 536, 376, 536, 15,
|
|
428, 496, 504, 505, 15, 370, 373, 373, 655, 656,
|
|
486, 487, 488, 489, 8, 676, 743, 15, 373, 601,
|
|
373, 592, 593, 580, 15, 15, 373, 496, 15, 501,
|
|
756, 15, 15, 373, 730, 732, 8, 373, 37, 422,
|
|
15, 505, 506, 496, 15, 15, 558, 484, 496, 505,
|
|
373, 722, 5, 15, 581, 582, 496, 373, 374, 496,
|
|
580, 15, 504, 638, 639, 613, 617, 373, 605, 373,
|
|
702, 702, 15, 373, 603, 722, 501, 512, 496, 380,
|
|
15, 373, 708, 708, 708, 708, 708, 7, 501, 596,
|
|
597, 373, 598, 496, 369, 373, 496, 373, 728, 730,
|
|
373, 495, 496, 373, 473, 15, 15, 580, 373, 15,
|
|
619, 15, 619, 619, 619, 619, 791, 847, 619, 619,
|
|
619, 619, 619, 619, 791, 373, 380, 855, 856, 857,
|
|
15, 15, 8, 870, 871, 872, 496, 15, 501, 501,
|
|
501, 501, 500, 501, 15, 15, 15, 15, 15, 373,
|
|
900, 15, 367, 367, 124, 5, 21, 373, 377, 378,
|
|
372, 380, 373, 373, 373, 424, 7, 380, 367, 124,
|
|
373, 373, 5, 15, 411, 412, 373, 424, 424, 424,
|
|
424, 423, 504, 422, 373, 373, 428, 435, 436, 438,
|
|
439, 557, 557, 239, 414, 501, 502, 501, 501, 501,
|
|
501, 5, 9, 16, 17, 22, 23, 24, 25, 26,
|
|
28, 29, 30, 31, 32, 33, 35, 37, 38, 385,
|
|
15, 246, 3, 15, 246, 246, 15, 510, 511, 21,
|
|
554, 579, 512, 5, 9, 166, 568, 569, 570, 581,
|
|
26, 581, 5, 9, 23, 37, 503, 580, 581, 580,
|
|
8, 15, 505, 574, 575, 15, 501, 502, 517, 576,
|
|
577, 578, 576, 587, 373, 601, 603, 605, 607, 373,
|
|
7, 380, 728, 8, 21, 639, 424, 526, 501, 240,
|
|
552, 15, 380, 15, 478, 8, 579, 7, 501, 534,
|
|
535, 536, 15, 373, 478, 424, 483, 484, 8, 435,
|
|
526, 478, 15, 8, 21, 5, 7, 481, 482, 501,
|
|
373, 8, 21, 5, 58, 86, 126, 137, 165, 258,
|
|
620, 616, 617, 175, 608, 501, 149, 547, 8, 501,
|
|
501, 372, 373, 429, 430, 504, 509, 373, 26, 373,
|
|
542, 543, 545, 376, 8, 8, 15, 231, 404, 490,
|
|
380, 8, 743, 373, 504, 712, 722, 740, 741, 8,
|
|
567, 26, 5, 9, 16, 17, 22, 23, 24, 25,
|
|
28, 29, 30, 31, 32, 33, 34, 35, 37, 38,
|
|
385, 386, 387, 373, 380, 394, 504, 501, 15, 380,
|
|
373, 373, 504, 504, 527, 8, 677, 734, 373, 504,
|
|
665, 373, 468, 469, 547, 424, 18, 580, 581, 580,
|
|
400, 403, 644, 639, 7, 617, 619, 712, 722, 723,
|
|
724, 423, 424, 462, 463, 62, 504, 767, 15, 15,
|
|
7, 8, 21, 595, 424, 376, 424, 478, 8, 674,
|
|
699, 21, 380, 373, 8, 501, 501, 478, 504, 552,
|
|
812, 504, 287, 824, 824, 552, 821, 824, 15, 552,
|
|
789, 552, 828, 789, 789, 552, 806, 552, 818, 478,
|
|
147, 148, 180, 314, 315, 318, 319, 381, 858, 859,
|
|
860, 8, 21, 505, 680, 861, 21, 861, 380, 872,
|
|
373, 867, 868, 380, 764, 765, 8, 8, 8, 8,
|
|
504, 507, 508, 782, 665, 380, 883, 884, 885, 886,
|
|
887, 888, 889, 380, 892, 893, 894, 895, 896, 380,
|
|
897, 898, 8, 380, 903, 904, 373, 369, 367, 8,
|
|
21, 213, 381, 478, 44, 87, 93, 119, 143, 145,
|
|
178, 183, 187, 191, 194, 216, 230, 236, 392, 393,
|
|
395, 373, 367, 495, 558, 579, 405, 478, 552, 552,
|
|
8, 37, 15, 373, 441, 446, 380, 15, 521, 21,
|
|
8, 501, 501, 501, 501, 501, 501, 501, 501, 501,
|
|
501, 501, 501, 501, 501, 501, 501, 501, 501, 501,
|
|
579, 64, 129, 497, 499, 579, 504, 515, 518, 64,
|
|
518, 512, 8, 21, 5, 501, 555, 570, 8, 21,
|
|
5, 9, 501, 21, 501, 581, 581, 581, 581, 581,
|
|
21, 574, 574, 8, 501, 502, 577, 578, 8, 8,
|
|
8, 478, 478, 495, 43, 67, 82, 87, 88, 94,
|
|
228, 259, 303, 648, 645, 380, 508, 524, 21, 373,
|
|
15, 500, 67, 479, 662, 501, 7, 8, 21, 554,
|
|
37, 8, 21, 659, 504, 507, 523, 525, 579, 751,
|
|
481, 7, 478, 619, 15, 15, 15, 15, 15, 15,
|
|
608, 619, 373, 21, 559, 590, 21, 21, 15, 8,
|
|
21, 8, 511, 505, 8, 544, 26, 372, 656, 487,
|
|
129, 491, 492, 493, 409, 169, 208, 282, 380, 15,
|
|
7, 8, 21, 593, 576, 21, 21, 147, 148, 180,
|
|
21, 18, 21, 7, 501, 519, 175, 324, 37, 8,
|
|
21, 380, 8, 21, 26, 8, 21, 559, 501, 21,
|
|
464, 465, 464, 21, 7, 619, 608, 15, 7, 8,
|
|
21, 8, 15, 15, 26, 709, 710, 712, 500, 501,
|
|
597, 380, 8, 699, 8, 674, 405, 395, 382, 21,
|
|
21, 21, 619, 552, 21, 619, 552, 848, 619, 552,
|
|
619, 552, 619, 552, 619, 552, 15, 15, 15, 15,
|
|
15, 15, 380, 857, 8, 21, 21, 191, 859, 8,
|
|
182, 315, 318, 8, 21, 380, 380, 380, 501, 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, 380, 244, 331, 346, 347, 348,
|
|
8, 21, 376, 373, 378, 15, 410, 411, 478, 495,
|
|
15, 7, 8, 373, 478, 15, 515, 5, 413, 501,
|
|
570, 424, 504, 438, 15, 16, 17, 27, 36, 59,
|
|
64, 92, 149, 201, 437, 439, 449, 450, 451, 452,
|
|
453, 454, 455, 456, 441, 446, 447, 448, 15, 442,
|
|
443, 62, 501, 576, 502, 497, 21, 8, 498, 501,
|
|
519, 570, 7, 579, 484, 501, 579, 8, 575, 21,
|
|
8, 8, 8, 502, 578, 502, 578, 502, 578, 373,
|
|
255, 8, 21, 484, 483, 21, 7, 21, 501, 534,
|
|
21, 484, 552, 8, 21, 570, 752, 8, 21, 482,
|
|
501, 620, 579, 15, 622, 373, 621, 621, 501, 621,
|
|
478, 619, 239, 536, 500, 430, 430, 373, 501, 543,
|
|
21, 501, 519, 8, 21, 16, 15, 15, 15, 500,
|
|
740, 741, 496, 504, 772, 7, 501, 7, 21, 21,
|
|
373, 615, 505, 504, 191, 504, 619, 666, 501, 469,
|
|
552, 8, 47, 177, 373, 467, 380, 636, 638, 608,
|
|
7, 7, 501, 725, 726, 723, 724, 463, 501, 5,
|
|
622, 768, 769, 775, 501, 632, 8, 21, 15, 21,
|
|
71, 208, 380, 380, 496, 172, 373, 476, 477, 505,
|
|
191, 208, 282, 285, 290, 298, 792, 793, 794, 801,
|
|
813, 814, 815, 619, 266, 822, 823, 824, 619, 37,
|
|
504, 845, 846, 84, 265, 289, 299, 304, 790, 792,
|
|
793, 794, 795, 796, 797, 799, 800, 801, 619, 792,
|
|
793, 794, 795, 796, 797, 799, 800, 801, 814, 815,
|
|
829, 619, 792, 793, 794, 801, 807, 619, 792, 793,
|
|
819, 619, 861, 861, 861, 380, 862, 863, 861, 861,
|
|
505, 15, 868, 765, 331, 315, 332, 579, 497, 508,
|
|
15, 15, 15, 15, 15, 884, 15, 15, 15, 893,
|
|
15, 15, 15, 15, 898, 352, 353, 15, 15, 15,
|
|
15, 15, 904, 373, 18, 26, 415, 15, 394, 7,
|
|
380, 410, 559, 559, 414, 5, 501, 452, 453, 454,
|
|
457, 453, 455, 453, 455, 246, 246, 246, 246, 246,
|
|
8, 37, 373, 440, 504, 5, 442, 443, 8, 15,
|
|
16, 17, 149, 373, 440, 444, 445, 458, 459, 460,
|
|
461, 15, 443, 15, 21, 522, 21, 21, 511, 579,
|
|
501, 512, 555, 569, 581, 545, 546, 502, 546, 546,
|
|
546, 478, 373, 640, 643, 579, 8, 21, 7, 414,
|
|
501, 579, 501, 579, 570, 633, 501, 623, 624, 21,
|
|
21, 21, 21, 8, 8, 254, 530, 536, 21, 492,
|
|
493, 680, 680, 680, 21, 21, 373, 15, 21, 501,
|
|
7, 7, 501, 478, 15, 173, 8, 670, 671, 672,
|
|
673, 674, 676, 677, 678, 681, 683, 684, 685, 699,
|
|
707, 545, 465, 15, 15, 466, 255, 8, 7, 8,
|
|
21, 21, 21, 8, 21, 21, 710, 711, 15, 15,
|
|
373, 373, 474, 475, 477, 18, 8, 26, 791, 15,
|
|
791, 791, 15, 619, 813, 791, 619, 822, 373, 8,
|
|
21, 15, 791, 15, 791, 15, 619, 790, 619, 829,
|
|
619, 807, 619, 819, 21, 21, 21, 316, 317, 8,
|
|
21, 21, 21, 867, 15, 15, 497, 21, 508, 890,
|
|
891, 680, 380, 703, 515, 680, 709, 723, 709, 665,
|
|
665, 508, 901, 501, 899, 15, 15, 380, 905, 906,
|
|
665, 665, 501, 380, 907, 21, 501, 501, 650, 651,
|
|
21, 393, 415, 5, 501, 405, 8, 21, 8, 518,
|
|
518, 518, 518, 518, 449, 5, 15, 439, 450, 443,
|
|
373, 440, 448, 458, 459, 459, 8, 21, 7, 16,
|
|
17, 5, 37, 9, 458, 501, 20, 511, 498, 21,
|
|
26, 21, 21, 21, 21, 15, 508, 570, 484, 661,
|
|
496, 523, 570, 752, 501, 21, 7, 8, 21, 501,
|
|
380, 15, 21, 21, 21, 7, 773, 774, 775, 501,
|
|
501, 7, 680, 504, 667, 380, 672, 26, 467, 26,
|
|
386, 640, 638, 373, 611, 612, 613, 614, 726, 769,
|
|
619, 78, 596, 373, 675, 723, 700, 8, 373, 477,
|
|
501, 619, 802, 380, 619, 619, 847, 504, 845, 380,
|
|
501, 501, 619, 619, 619, 619, 863, 21, 680, 504,
|
|
21, 26, 8, 21, 21, 22, 24, 33, 35, 158,
|
|
159, 161, 162, 192, 234, 247, 704, 705, 706, 8,
|
|
21, 21, 21, 21, 21, 21, 21, 21, 8, 21,
|
|
8, 21, 380, 878, 879, 878, 315, 351, 8, 21,
|
|
21, 21, 21, 349, 350, 8, 8, 21, 7, 21,
|
|
21, 579, 457, 450, 579, 440, 26, 21, 458, 445,
|
|
459, 459, 460, 460, 460, 21, 501, 5, 501, 519,
|
|
641, 642, 504, 8, 680, 504, 8, 501, 624, 380,
|
|
21, 254, 501, 8, 21, 501, 21, 15, 41, 135,
|
|
209, 221, 223, 224, 226, 229, 320, 322, 501, 466,
|
|
21, 21, 15, 8, 132, 770, 21, 21, 7, 21,
|
|
702, 704, 475, 5, 16, 17, 22, 24, 33, 35,
|
|
37, 159, 162, 247, 305, 306, 307, 804, 21, 94,
|
|
230, 284, 295, 816, 37, 191, 288, 299, 798, 21,
|
|
21, 21, 21, 501, 891, 15, 15, 380, 508, 501,
|
|
354, 359, 8, 21, 21, 906, 501, 7, 7, 413,
|
|
21, 497, 444, 458, 21, 8, 8, 21, 484, 570,
|
|
255, 15, 21, 774, 5, 501, 668, 669, 15, 686,
|
|
15, 15, 15, 15, 708, 708, 15, 15, 15, 8,
|
|
500, 612, 712, 713, 15, 723, 701, 701, 7, 8,
|
|
21, 848, 21, 8, 505, 680, 704, 8, 15, 879,
|
|
8, 880, 8, 881, 21, 7, 414, 21, 21, 501,
|
|
642, 501, 373, 625, 626, 501, 8, 21, 687, 686,
|
|
722, 740, 722, 723, 712, 709, 501, 501, 679, 667,
|
|
682, 501, 21, 8, 380, 21, 7, 8, 21, 680,
|
|
803, 501, 380, 21, 8, 501, 92, 380, 380, 373,
|
|
652, 653, 21, 8, 15, 21, 669, 148, 180, 688,
|
|
7, 21, 7, 21, 15, 21, 21, 8, 21, 8,
|
|
21, 8, 712, 78, 703, 703, 21, 330, 501, 505,
|
|
21, 353, 352, 8, 501, 40, 501, 627, 628, 775,
|
|
7, 7, 689, 690, 712, 740, 723, 596, 501, 667,
|
|
501, 21, 21, 21, 15, 21, 15, 15, 653, 373,
|
|
629, 8, 21, 8, 21, 15, 21, 21, 21, 8,
|
|
500, 878, 878, 17, 630, 631, 628, 690, 501, 691,
|
|
692, 21, 501, 21, 21, 21, 632, 17, 7, 8,
|
|
21, 8, 777, 632, 501, 692, 15, 380, 380, 693,
|
|
694, 695, 696, 697, 182, 318, 128, 157, 217, 8,
|
|
21, 7, 7, 15, 698, 698, 698, 694, 380, 696,
|
|
697, 380, 697, 499, 7, 21, 697
|
|
};
|
|
|
|
/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
|
|
static const yytype_uint16 yyr1[] =
|
|
{
|
|
0, 362, 363, 363, 364, 364, 364, 364, 364, 364,
|
|
364, 365, 366, 366, 366, 366, 366, 366, 366, 366,
|
|
367, 368, 368, 368, 369, 370, 371, 371, 371, 371,
|
|
372, 372, 373, 374, 374, 375, 375, 376, 376, 376,
|
|
377, 377, 378, 378, 379, 380, 381, 382, 383, 383,
|
|
383, 383, 383, 383, 383, 383, 383, 383, 383, 383,
|
|
383, 383, 383, 383, 383, 383, 383, 383, 383, 383,
|
|
383, 383, 383, 383, 383, 383, 383, 383, 384, 384,
|
|
384, 384, 384, 385, 386, 386, 387, 387, 387, 387,
|
|
387, 387, 387, 387, 387, 387, 387, 387, 387, 387,
|
|
387, 387, 387, 387, 388, 388, 389, 389, 390, 390,
|
|
391, 391, 391, 392, 392, 393, 393, 393, 393, 393,
|
|
393, 393, 393, 393, 393, 393, 393, 394, 394, 394,
|
|
395, 395, 396, 396, 397, 397, 398, 398, 399, 399,
|
|
400, 401, 402, 402, 403, 404, 404, 405, 406, 406,
|
|
407, 407, 408, 409, 409, 409, 409, 409, 409, 409,
|
|
410, 410, 411, 411, 411, 412, 412, 412, 412, 413,
|
|
413, 413, 413, 414, 415, 415, 415, 416, 416, 417,
|
|
417, 418, 418, 419, 419, 420, 420, 420, 420, 421,
|
|
421, 421, 422, 423, 423, 424, 425, 425, 426, 426,
|
|
427, 427, 428, 429, 429, 430, 430, 430, 431, 432,
|
|
432, 433, 434, 435, 436, 436, 437, 437, 438, 438,
|
|
438, 438, 438, 439, 440, 441, 442, 443, 444, 444,
|
|
445, 445, 446, 447, 447, 448, 448, 448, 448, 449,
|
|
449, 449, 450, 450, 450, 450, 450, 450, 450, 450,
|
|
450, 450, 450, 451, 452, 452, 452, 453, 453, 454,
|
|
454, 454, 455, 455, 455, 455, 456, 457, 457, 458,
|
|
458, 458, 458, 458, 459, 459, 459, 460, 460, 461,
|
|
461, 461, 462, 462, 463, 463, 464, 464, 465, 466,
|
|
467, 467, 467, 468, 468, 469, 470, 471, 471, 472,
|
|
472, 472, 472, 473, 474, 474, 475, 475, 476, 476,
|
|
477, 478, 478, 480, 479, 479, 481, 481, 481, 481,
|
|
482, 482, 483, 483, 484, 485, 485, 486, 486, 487,
|
|
489, 488, 490, 490, 491, 491, 492, 492, 493, 494,
|
|
495, 496, 496, 497, 497, 498, 498, 498, 499, 499,
|
|
500, 500, 501, 501, 501, 502, 502, 502, 502, 502,
|
|
502, 502, 502, 502, 502, 502, 502, 502, 502, 502,
|
|
502, 502, 502, 502, 502, 502, 502, 502, 502, 502,
|
|
503, 503, 504, 505, 505, 505, 506, 506, 506, 506,
|
|
507, 508, 508, 508, 508, 509, 510, 510, 511, 512,
|
|
512, 513, 513, 513, 513, 513, 514, 514, 514, 514,
|
|
515, 516, 516, 516, 517, 518, 518, 519, 519, 519,
|
|
519, 519, 519, 519, 519, 521, 522, 520, 523, 523,
|
|
524, 524, 524, 525, 525, 525, 526, 527, 527, 528,
|
|
528, 528, 528, 528, 528, 528, 528, 528, 528, 528,
|
|
528, 528, 528, 528, 528, 528, 528, 528, 528, 528,
|
|
528, 528, 528, 529, 529, 530, 530, 530, 531, 531,
|
|
532, 532, 532, 532, 532, 533, 534, 534, 534, 534,
|
|
535, 535, 536, 536, 537, 537, 538, 539, 540, 541,
|
|
542, 542, 543, 544, 544, 545, 546, 546, 547, 547,
|
|
548, 548, 548, 548, 548, 549, 549, 549, 549, 549,
|
|
549, 549, 549, 549, 549, 549, 549, 549, 549, 549,
|
|
549, 549, 549, 550, 551, 551, 551, 551, 552, 552,
|
|
553, 554, 554, 555, 555, 555, 556, 556, 557, 558,
|
|
559, 560, 560, 560, 560, 560, 560, 560, 560, 560,
|
|
560, 560, 560, 560, 560, 561, 562, 562, 562, 563,
|
|
564, 564, 565, 565, 566, 566, 567, 567, 568, 568,
|
|
569, 569, 569, 569, 569, 569, 570, 571, 572, 573,
|
|
573, 574, 574, 575, 575, 576, 576, 576, 577, 577,
|
|
577, 577, 577, 577, 578, 578, 578, 578, 578, 579,
|
|
580, 581, 581, 582, 582, 582, 582, 582, 582, 582,
|
|
582, 582, 583, 583, 584, 584, 584, 584, 584, 584,
|
|
584, 584, 584, 584, 584, 584, 584, 584, 584, 584,
|
|
584, 584, 584, 585, 585, 585, 585, 585, 585, 585,
|
|
585, 585, 585, 585, 585, 585, 585, 585, 585, 585,
|
|
585, 585, 585, 585, 585, 585, 585, 585, 585, 585,
|
|
585, 585, 585, 585, 585, 585, 585, 585, 585, 585,
|
|
585, 585, 585, 585, 585, 585, 585, 586, 586, 587,
|
|
588, 589, 589, 590, 591, 592, 592, 593, 594, 595,
|
|
596, 596, 597, 597, 597, 598, 599, 599, 599, 600,
|
|
600, 601, 602, 602, 603, 604, 604, 605, 606, 606,
|
|
607, 608, 608, 609, 610, 610, 611, 611, 612, 612,
|
|
613, 614, 615, 616, 616, 617, 618, 618, 619, 620,
|
|
620, 620, 620, 620, 620, 620, 620, 621, 622, 623,
|
|
623, 624, 624, 625, 625, 626, 627, 627, 628, 628,
|
|
628, 629, 630, 630, 631, 631, 632, 633, 633, 634,
|
|
635, 635, 636, 636, 637, 638, 639, 640, 641, 641,
|
|
642, 642, 642, 643, 644, 644, 645, 645, 645, 646,
|
|
646, 647, 647, 648, 648, 648, 648, 648, 648, 648,
|
|
648, 648, 648, 648, 649, 651, 650, 650, 652, 652,
|
|
653, 654, 655, 655, 656, 657, 658, 658, 659, 660,
|
|
660, 661, 661, 662, 663, 664, 665, 665, 666, 666,
|
|
667, 668, 668, 669, 669, 670, 670, 671, 671, 672,
|
|
672, 672, 672, 672, 672, 672, 672, 672, 672, 672,
|
|
673, 673, 674, 674, 675, 676, 676, 677, 678, 679,
|
|
679, 679, 680, 680, 681, 682, 682, 683, 683, 684,
|
|
685, 685, 686, 687, 688, 688, 688, 689, 689, 690,
|
|
690, 690, 691, 691, 692, 693, 693, 694, 694, 694,
|
|
694, 694, 694, 694, 695, 696, 697, 698, 699, 699,
|
|
699, 700, 701, 702, 703, 703, 704, 704, 705, 705,
|
|
705, 705, 705, 705, 705, 705, 705, 706, 706, 707,
|
|
707, 707, 707, 707, 708, 709, 709, 710, 710, 710,
|
|
710, 711, 712, 713, 713, 714, 714, 715, 715, 716,
|
|
717, 718, 719, 720, 721, 721, 722, 723, 723, 724,
|
|
724, 725, 725, 726, 726, 727, 727, 728, 729, 729,
|
|
729, 729, 729, 730, 731, 732, 732, 733, 734, 734,
|
|
735, 736, 736, 737, 738, 739, 739, 740, 740, 741,
|
|
741, 742, 742, 742, 742, 743, 744, 745, 746, 747,
|
|
748, 748, 749, 750, 750, 751, 751, 752, 753, 754,
|
|
755, 756, 756, 757, 758, 759, 760, 761, 762, 763,
|
|
764, 764, 765, 765, 765, 766, 767, 768, 768, 769,
|
|
769, 770, 770, 771, 772, 772, 773, 773, 774, 774,
|
|
775, 776, 777, 777, 777, 778, 779, 779, 780, 781,
|
|
782, 782, 783, 784, 785, 785, 785, 785, 785, 785,
|
|
785, 785, 785, 785, 785, 785, 785, 785, 785, 785,
|
|
785, 785, 785, 785, 785, 785, 785, 785, 785, 785,
|
|
786, 787, 788, 788, 789, 789, 790, 790, 790, 790,
|
|
790, 790, 790, 790, 790, 791, 792, 793, 794, 795,
|
|
796, 797, 798, 798, 798, 799, 800, 801, 802, 803,
|
|
804, 804, 804, 804, 804, 804, 804, 804, 804, 804,
|
|
804, 804, 804, 804, 805, 805, 806, 806, 807, 807,
|
|
807, 807, 808, 808, 809, 810, 810, 811, 811, 812,
|
|
812, 813, 813, 813, 813, 813, 813, 814, 815, 815,
|
|
816, 816, 816, 816, 817, 817, 818, 818, 819, 819,
|
|
820, 820, 821, 821, 822, 822, 823, 824, 825, 826,
|
|
826, 827, 827, 828, 828, 829, 829, 829, 829, 829,
|
|
829, 829, 829, 829, 829, 829, 830, 831, 831, 832,
|
|
833, 833, 834, 835, 836, 837, 838, 839, 840, 841,
|
|
842, 842, 843, 843, 844, 844, 845, 846, 846, 846,
|
|
846, 847, 848, 849, 849, 850, 850, 850, 850, 850,
|
|
850, 851, 852, 853, 853, 853, 854, 854, 854, 855,
|
|
855, 856, 856, 857, 857, 857, 858, 858, 858, 858,
|
|
858, 859, 860, 861, 862, 862, 863, 863, 864, 865,
|
|
866, 867, 867, 868, 869, 870, 870, 871, 871, 872,
|
|
872, 873, 873, 873, 873, 873, 873, 874, 875, 876,
|
|
877, 877, 877, 878, 878, 879, 879, 880, 880, 881,
|
|
881, 882, 883, 883, 884, 884, 884, 884, 884, 885,
|
|
886, 887, 888, 889, 890, 890, 891, 892, 892, 893,
|
|
893, 893, 894, 895, 896, 897, 897, 898, 898, 898,
|
|
898, 898, 898, 898, 898, 899, 900, 901, 901, 902,
|
|
903, 903, 904, 904, 904, 904, 904, 905, 905, 906,
|
|
906, 907, 907, 908
|
|
};
|
|
|
|
/* 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, 5, 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 <stdio.h> /* 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 797 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = BFNULL; }
|
|
#line 4460 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 3:
|
|
#line 799 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = set_stat_list((yyvsp[-2].bf_node),(yyvsp[-1].bf_node)); }
|
|
#line 4466 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 4:
|
|
#line 803 "gram1.y" /* yacc.c:1646 */
|
|
{ lastwasbranch = NO; (yyval.bf_node) = BFNULL; }
|
|
#line 4472 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 5:
|
|
#line 805 "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 4490 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 6:
|
|
#line 819 "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 4525 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 7:
|
|
#line 850 "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 4538 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 8:
|
|
#line 859 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
err("Unclassifiable statement", 10);
|
|
flline();
|
|
(yyval.bf_node) = BFNULL;
|
|
}
|
|
#line 4548 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 9:
|
|
#line 865 "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 4571 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 10:
|
|
#line 885 "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 4582 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 11:
|
|
#line 894 "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 4600 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 12:
|
|
#line 910 "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 4615 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 13:
|
|
#line 922 "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 4628 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 14:
|
|
#line 932 "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 4638 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 15:
|
|
#line 939 "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 4648 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 16:
|
|
#line 945 "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 4657 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 17:
|
|
#line 950 "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 4666 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 18:
|
|
#line 955 "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 4694 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 19:
|
|
#line 979 "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 4723 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 20:
|
|
#line 1005 "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 4740 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 21:
|
|
#line 1020 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi, RECURSIVE_OP, LLNULL, LLNULL, SMNULL); }
|
|
#line 4746 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 22:
|
|
#line 1022 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi, PURE_OP, LLNULL, LLNULL, SMNULL); }
|
|
#line 4752 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 23:
|
|
#line 1024 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi, ELEMENTAL_OP, LLNULL, LLNULL, SMNULL); }
|
|
#line 4758 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 24:
|
|
#line 1028 "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 4777 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 25:
|
|
#line 1045 "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 4793 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 26:
|
|
#line 1059 "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 4821 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 27:
|
|
#line 1083 "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 4841 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 28:
|
|
#line 1099 "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 4859 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 29:
|
|
#line 1113 "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 4879 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 30:
|
|
#line 1131 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL; }
|
|
#line 4885 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 31:
|
|
#line 1133 "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 4894 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 32:
|
|
#line 1140 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = look_up_sym(yytext); }
|
|
#line 4900 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 33:
|
|
#line 1143 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.symbol) = make_program(look_up_sym("_MAIN")); }
|
|
#line 4906 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 34:
|
|
#line 1145 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.symbol) = make_program((yyvsp[0].hash_entry));
|
|
(yyval.symbol)->decl = YES; /* variable declaration has been seen. */
|
|
}
|
|
#line 4915 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 35:
|
|
#line 1151 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.symbol) = make_program(look_up_sym("_BLOCK")); }
|
|
#line 4921 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 36:
|
|
#line 1153 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.symbol) = make_program((yyvsp[0].hash_entry));
|
|
(yyval.symbol)->decl = YES; /* variable declaration has been seen. */
|
|
}
|
|
#line 4930 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 37:
|
|
#line 1160 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.symbol) = SMNULL; }
|
|
#line 4936 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 38:
|
|
#line 1162 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.symbol) = SMNULL; }
|
|
#line 4942 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 39:
|
|
#line 1164 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.symbol) = (yyvsp[-1].symbol); }
|
|
#line 4948 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 41:
|
|
#line 1169 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.symbol) = set_id_list((yyvsp[-2].symbol), (yyvsp[0].symbol)); }
|
|
#line 4954 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 42:
|
|
#line 1173 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.symbol) = make_scalar((yyvsp[0].hash_entry), TYNULL, IO);
|
|
}
|
|
#line 4962 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 43:
|
|
#line 1177 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.symbol) = make_scalar(look_up_sym("*"), TYNULL, IO); }
|
|
#line 4968 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 44:
|
|
#line 1183 "gram1.y" /* yacc.c:1646 */
|
|
{ char *s;
|
|
|
|
s = copyn(yyleng+1, yytext);
|
|
s[yyleng] = '\0';
|
|
(yyval.charp) = s;
|
|
}
|
|
#line 4979 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 45:
|
|
#line 1192 "gram1.y" /* yacc.c:1646 */
|
|
{ needkwd = 1; }
|
|
#line 4985 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 46:
|
|
#line 1196 "gram1.y" /* yacc.c:1646 */
|
|
{ needkwd = NO; }
|
|
#line 4991 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 47:
|
|
#line 1201 "gram1.y" /* yacc.c:1646 */
|
|
{ colon_flag = YES; }
|
|
#line 4997 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 62:
|
|
#line 1223 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
saveall = YES;
|
|
(yyval.bf_node) = get_bfnd(fi,SAVE_DECL, SMNULL, LLNULL, LLNULL, LLNULL);
|
|
}
|
|
#line 5006 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 63:
|
|
#line 1228 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = get_bfnd(fi,SAVE_DECL, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL);
|
|
}
|
|
#line 5014 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 64:
|
|
#line 1233 "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 5025 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 65:
|
|
#line 1240 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,PARAM_DECL, SMNULL, (yyvsp[-1].ll_node), LLNULL, LLNULL); }
|
|
#line 5031 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 78:
|
|
#line 1256 "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 5039 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 79:
|
|
#line 1260 "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 5051 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 80:
|
|
#line 1268 "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 5063 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 81:
|
|
#line 1276 "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 5076 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 82:
|
|
#line 1285 "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 5086 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 83:
|
|
#line 1293 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = look_up_sym(yytext); }
|
|
#line 5092 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 84:
|
|
#line 1297 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = (yyvsp[0].hash_entry); }
|
|
#line 5098 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 85:
|
|
#line 1299 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = (yyvsp[0].hash_entry); }
|
|
#line 5104 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 86:
|
|
#line 1303 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = look_up_op(PLUS); }
|
|
#line 5110 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 87:
|
|
#line 1305 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = look_up_op(MINUS); }
|
|
#line 5116 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 88:
|
|
#line 1307 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = look_up_op(ASTER); }
|
|
#line 5122 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 89:
|
|
#line 1309 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = look_up_op(DASTER); }
|
|
#line 5128 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 90:
|
|
#line 1311 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = look_up_op(SLASH); }
|
|
#line 5134 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 91:
|
|
#line 1313 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = look_up_op(DSLASH); }
|
|
#line 5140 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 92:
|
|
#line 1315 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = look_up_op(AND); }
|
|
#line 5146 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 93:
|
|
#line 1317 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = look_up_op(OR); }
|
|
#line 5152 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 94:
|
|
#line 1319 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = look_up_op(XOR); }
|
|
#line 5158 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 95:
|
|
#line 1321 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = look_up_op(NOT); }
|
|
#line 5164 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 96:
|
|
#line 1323 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = look_up_op(EQ); }
|
|
#line 5170 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 97:
|
|
#line 1325 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = look_up_op(NE); }
|
|
#line 5176 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 98:
|
|
#line 1327 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = look_up_op(GT); }
|
|
#line 5182 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 99:
|
|
#line 1329 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = look_up_op(GE); }
|
|
#line 5188 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 100:
|
|
#line 1331 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = look_up_op(LT); }
|
|
#line 5194 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 101:
|
|
#line 1333 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = look_up_op(LE); }
|
|
#line 5200 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 102:
|
|
#line 1335 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = look_up_op(NEQV); }
|
|
#line 5206 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 103:
|
|
#line 1337 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = look_up_op(EQV); }
|
|
#line 5212 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 104:
|
|
#line 1342 "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 5224 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 105:
|
|
#line 1351 "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 5236 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 106:
|
|
#line 1361 "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 5248 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 107:
|
|
#line 1369 "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 5260 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 108:
|
|
#line 1379 "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 5285 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 109:
|
|
#line 1400 "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 5306 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 110:
|
|
#line 1419 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL; }
|
|
#line 5312 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 111:
|
|
#line 1421 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL; }
|
|
#line 5318 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 112:
|
|
#line 1423 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[-2].ll_node); }
|
|
#line 5324 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 113:
|
|
#line 1427 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); }
|
|
#line 5330 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 114:
|
|
#line 1429 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-3].ll_node), (yyvsp[0].ll_node), EXPR_LIST); }
|
|
#line 5336 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 115:
|
|
#line 1433 "gram1.y" /* yacc.c:1646 */
|
|
{ type_options = type_options | PARAMETER_BIT;
|
|
(yyval.ll_node) = make_llnd(fi, PARAMETER_OP, LLNULL, LLNULL, SMNULL);
|
|
}
|
|
#line 5344 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 116:
|
|
#line 1437 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 5350 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 117:
|
|
#line 1439 "gram1.y" /* yacc.c:1646 */
|
|
{ type_options = type_options | ALLOCATABLE_BIT;
|
|
(yyval.ll_node) = make_llnd(fi, ALLOCATABLE_OP, LLNULL, LLNULL, SMNULL);
|
|
}
|
|
#line 5358 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 118:
|
|
#line 1443 "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 5368 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 119:
|
|
#line 1449 "gram1.y" /* yacc.c:1646 */
|
|
{ type_options = type_options | EXTERNAL_BIT;
|
|
(yyval.ll_node) = make_llnd(fi, EXTERNAL_OP, LLNULL, LLNULL, SMNULL);
|
|
}
|
|
#line 5376 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 120:
|
|
#line 1453 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[-1].ll_node); }
|
|
#line 5382 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 121:
|
|
#line 1455 "gram1.y" /* yacc.c:1646 */
|
|
{ type_options = type_options | INTRINSIC_BIT;
|
|
(yyval.ll_node) = make_llnd(fi, INTRINSIC_OP, LLNULL, LLNULL, SMNULL);
|
|
}
|
|
#line 5390 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 122:
|
|
#line 1459 "gram1.y" /* yacc.c:1646 */
|
|
{ type_options = type_options | OPTIONAL_BIT;
|
|
(yyval.ll_node) = make_llnd(fi, OPTIONAL_OP, LLNULL, LLNULL, SMNULL);
|
|
}
|
|
#line 5398 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 123:
|
|
#line 1463 "gram1.y" /* yacc.c:1646 */
|
|
{ type_options = type_options | POINTER_BIT;
|
|
(yyval.ll_node) = make_llnd(fi, POINTER_OP, LLNULL, LLNULL, SMNULL);
|
|
}
|
|
#line 5406 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 124:
|
|
#line 1467 "gram1.y" /* yacc.c:1646 */
|
|
{ type_options = type_options | SAVE_BIT;
|
|
(yyval.ll_node) = make_llnd(fi, SAVE_OP, LLNULL, LLNULL, SMNULL);
|
|
}
|
|
#line 5414 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 125:
|
|
#line 1471 "gram1.y" /* yacc.c:1646 */
|
|
{ type_options = type_options | SAVE_BIT;
|
|
(yyval.ll_node) = make_llnd(fi, STATIC_OP, LLNULL, LLNULL, SMNULL);
|
|
}
|
|
#line 5422 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 126:
|
|
#line 1475 "gram1.y" /* yacc.c:1646 */
|
|
{ type_options = type_options | TARGET_BIT;
|
|
(yyval.ll_node) = make_llnd(fi, TARGET_OP, LLNULL, LLNULL, SMNULL);
|
|
}
|
|
#line 5430 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 127:
|
|
#line 1481 "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 5438 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 128:
|
|
#line 1485 "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 5446 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 129:
|
|
#line 1489 "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 5454 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 130:
|
|
#line 1495 "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 5463 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 131:
|
|
#line 1500 "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 5472 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 132:
|
|
#line 1507 "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 5487 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 133:
|
|
#line 1518 "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 5502 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 134:
|
|
#line 1531 "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 5517 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 135:
|
|
#line 1542 "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 5532 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 136:
|
|
#line 1555 "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 5546 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 137:
|
|
#line 1565 "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 5560 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 138:
|
|
#line 1578 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
privateall = 1;
|
|
(yyval.bf_node) = get_bfnd(fi, PRIVATE_STMT, SMNULL, LLNULL, LLNULL, LLNULL);
|
|
}
|
|
#line 5569 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 139:
|
|
#line 1583 "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 5578 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 140:
|
|
#line 1589 "gram1.y" /* yacc.c:1646 */
|
|
{type_opt = PRIVATE_BIT;}
|
|
#line 5584 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 141:
|
|
#line 1593 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = get_bfnd(fi, SEQUENCE_STMT, SMNULL, LLNULL, LLNULL, LLNULL);
|
|
}
|
|
#line 5592 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 142:
|
|
#line 1598 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
/*saveall = YES;*/ /*14.03.03*/
|
|
(yyval.bf_node) = get_bfnd(fi, PUBLIC_STMT, SMNULL, LLNULL, LLNULL, LLNULL);
|
|
}
|
|
#line 5601 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 143:
|
|
#line 1603 "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 5610 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 144:
|
|
#line 1609 "gram1.y" /* yacc.c:1646 */
|
|
{type_opt = PUBLIC_BIT;}
|
|
#line 5616 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 145:
|
|
#line 1613 "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 5630 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 146:
|
|
#line 1623 "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 5645 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 147:
|
|
#line 1636 "gram1.y" /* yacc.c:1646 */
|
|
{opt_kwd_hedr = YES;}
|
|
#line 5651 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 148:
|
|
#line 1641 "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 5672 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 149:
|
|
#line 1660 "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 5700 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 150:
|
|
#line 1686 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.token) = ATT_GLOBAL; }
|
|
#line 5706 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 151:
|
|
#line 1688 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.token) = ATT_CLUSTER; }
|
|
#line 5712 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 152:
|
|
#line 1700 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
/* varleng = ($1<0 || $1==TYLONG ? 0 : typesize[$1]); */
|
|
vartype = (yyvsp[0].data_type);
|
|
}
|
|
#line 5721 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 153:
|
|
#line 1707 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.data_type) = global_int; }
|
|
#line 5727 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 154:
|
|
#line 1708 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.data_type) = global_float; }
|
|
#line 5733 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 155:
|
|
#line 1709 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.data_type) = global_complex; }
|
|
#line 5739 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 156:
|
|
#line 1710 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.data_type) = global_double; }
|
|
#line 5745 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 157:
|
|
#line 1711 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.data_type) = global_dcomplex; }
|
|
#line 5751 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 158:
|
|
#line 1712 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.data_type) = global_bool; }
|
|
#line 5757 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 159:
|
|
#line 1713 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.data_type) = global_string; }
|
|
#line 5763 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 160:
|
|
#line 1718 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL; }
|
|
#line 5769 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 161:
|
|
#line 1720 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 5775 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 162:
|
|
#line 1724 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi, LEN_OP, (yyvsp[-2].ll_node), LLNULL, SMNULL); }
|
|
#line 5781 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 163:
|
|
#line 1726 "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 5792 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 164:
|
|
#line 1733 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.ll_node) = make_llnd(fi, LEN_OP, (yyvsp[-1].ll_node), (yyvsp[-1].ll_node), SMNULL);}
|
|
#line 5798 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 165:
|
|
#line 1737 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL; }
|
|
#line 5804 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 166:
|
|
#line 1739 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 5810 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 167:
|
|
#line 1741 "gram1.y" /* yacc.c:1646 */
|
|
{ /*$$ = make_llnd(fi, PAREN_OP, $2, LLNULL, SMNULL);*/ (yyval.ll_node) = (yyvsp[-2].ll_node); }
|
|
#line 5816 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 168:
|
|
#line 1749 "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 5825 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 169:
|
|
#line 1756 "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 5835 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 170:
|
|
#line 1762 "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 5845 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 171:
|
|
#line 1768 "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 5858 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 172:
|
|
#line 1777 "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 5868 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 173:
|
|
#line 1785 "gram1.y" /* yacc.c:1646 */
|
|
{endioctl();}
|
|
#line 5874 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 174:
|
|
#line 1798 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL; }
|
|
#line 5880 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 175:
|
|
#line 1800 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 5886 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 176:
|
|
#line 1803 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi, POINTST_OP, LLNULL, (yyvsp[0].ll_node), SMNULL); }
|
|
#line 5892 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 177:
|
|
#line 1807 "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 5911 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 178:
|
|
#line 1822 "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 5928 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 179:
|
|
#line 1838 "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 5949 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 180:
|
|
#line 1856 "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 5971 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 181:
|
|
#line 1876 "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 5995 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 182:
|
|
#line 1896 "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 6019 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 183:
|
|
#line 1918 "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 6040 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 184:
|
|
#line 1935 "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 6060 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 185:
|
|
#line 1953 "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 6071 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 186:
|
|
#line 1960 "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 6082 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 187:
|
|
#line 1967 "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 6093 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 188:
|
|
#line 1974 "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 6107 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 189:
|
|
#line 1987 "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 6118 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 190:
|
|
#line 1994 "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 6129 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 191:
|
|
#line 2001 "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 6142 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 192:
|
|
#line 2012 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.symbol) = make_local_entity((yyvsp[-1].hash_entry), NAMELIST_NAME,global_default,LOCAL); }
|
|
#line 6148 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 193:
|
|
#line 2016 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.symbol) = NULL; /*make_common(look_up_sym("*"));*/ }
|
|
#line 6154 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 194:
|
|
#line 2018 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.symbol) = make_common((yyvsp[-1].hash_entry)); }
|
|
#line 6160 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 195:
|
|
#line 2023 "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 6179 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 196:
|
|
#line 2041 "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 6193 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 197:
|
|
#line 2052 "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 6207 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 198:
|
|
#line 2064 "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 6222 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 199:
|
|
#line 2076 "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 6236 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 200:
|
|
#line 2090 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = get_bfnd(fi,EQUI_STAT, SMNULL, (yyvsp[0].ll_node),
|
|
LLNULL, LLNULL);
|
|
}
|
|
#line 6245 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 201:
|
|
#line 2096 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
add_to_lowLevelList((yyvsp[0].ll_node), (yyvsp[-2].bf_node)->entry.Template.ll_ptr1);
|
|
}
|
|
#line 6253 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 202:
|
|
#line 2103 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,EQUI_LIST, (yyvsp[-1].ll_node), LLNULL, SMNULL);
|
|
}
|
|
#line 6261 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 203:
|
|
#line 2109 "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 6270 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 204:
|
|
#line 2115 "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 6280 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 205:
|
|
#line 2123 "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 6291 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 206:
|
|
#line 2130 "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 6302 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 208:
|
|
#line 2149 "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 6314 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 211:
|
|
#line 2163 "gram1.y" /* yacc.c:1646 */
|
|
{data_stat = YES;}
|
|
#line 6320 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 212:
|
|
#line 2167 "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 6343 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 223:
|
|
#line 2212 "gram1.y" /* yacc.c:1646 */
|
|
{;}
|
|
#line 6349 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 224:
|
|
#line 2216 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.symbol)= make_scalar((yyvsp[0].hash_entry), TYNULL, LOCAL);}
|
|
#line 6355 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 225:
|
|
#line 2220 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.symbol)= make_scalar((yyvsp[0].hash_entry), TYNULL, LOCAL);
|
|
(yyval.symbol)->attr = (yyval.symbol)->attr | DATA_BIT;
|
|
}
|
|
#line 6363 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 226:
|
|
#line 2226 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi, DATA_SUBS, (yyvsp[-1].ll_node), LLNULL, SMNULL); }
|
|
#line 6369 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 227:
|
|
#line 2230 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi, DATA_RANGE, (yyvsp[-3].ll_node), (yyvsp[-1].ll_node), SMNULL); }
|
|
#line 6375 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 228:
|
|
#line 2234 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 6381 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 229:
|
|
#line 2236 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = add_to_lowLevelList((yyvsp[0].ll_node), (yyvsp[-2].ll_node)); }
|
|
#line 6387 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 230:
|
|
#line 2240 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL; }
|
|
#line 6393 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 231:
|
|
#line 2242 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 6399 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 232:
|
|
#line 2246 "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 6405 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 233:
|
|
#line 2250 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 6411 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 234:
|
|
#line 2252 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = add_to_lowLevelList((yyvsp[0].ll_node), (yyvsp[-2].ll_node)); }
|
|
#line 6417 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 235:
|
|
#line 2256 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi, DATA_ELT, (yyvsp[0].ll_node), LLNULL, (yyvsp[-1].symbol)); }
|
|
#line 6423 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 236:
|
|
#line 2258 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi, DATA_ELT, (yyvsp[0].ll_node), LLNULL, (yyvsp[-1].symbol)); }
|
|
#line 6429 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 237:
|
|
#line 2260 "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 6438 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 238:
|
|
#line 2265 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi, DATA_ELT, (yyvsp[0].ll_node), LLNULL, SMNULL); }
|
|
#line 6444 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 252:
|
|
#line 2289 "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 6452 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 269:
|
|
#line 2334 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,ICON_EXPR, (yyvsp[0].ll_node), LLNULL, SMNULL); }
|
|
#line 6458 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 270:
|
|
#line 2336 "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 6469 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 271:
|
|
#line 2343 "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 6480 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 272:
|
|
#line 2350 "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 6491 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 273:
|
|
#line 2357 "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 6502 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 274:
|
|
#line 2366 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 6508 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 275:
|
|
#line 2368 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node("*", MULT_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
|
|
#line 6514 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 276:
|
|
#line 2370 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node("/", DIV_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
|
|
#line 6520 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 277:
|
|
#line 2374 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 6526 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 278:
|
|
#line 2376 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node("**", EXP_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
|
|
#line 6532 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 279:
|
|
#line 2380 "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 6545 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 280:
|
|
#line 2389 "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 6556 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 281:
|
|
#line 2396 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,EXPR_LIST, (yyvsp[-1].ll_node), LLNULL, SMNULL);
|
|
}
|
|
#line 6564 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 282:
|
|
#line 2403 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL); }
|
|
#line 6570 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 283:
|
|
#line 2405 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); }
|
|
#line 6576 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 284:
|
|
#line 2409 "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 6584 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 285:
|
|
#line 2413 "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 6592 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 286:
|
|
#line 2419 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node), LLNULL, EXPR_LIST); }
|
|
#line 6598 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 287:
|
|
#line 2421 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-4].ll_node), (yyvsp[-1].ll_node), EXPR_LIST); }
|
|
#line 6604 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 288:
|
|
#line 2425 "gram1.y" /* yacc.c:1646 */
|
|
{ as_op_kwd_ = YES; }
|
|
#line 6610 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 289:
|
|
#line 2429 "gram1.y" /* yacc.c:1646 */
|
|
{ as_op_kwd_ = NO; }
|
|
#line 6616 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 290:
|
|
#line 2434 "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 6627 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 291:
|
|
#line 2441 "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 6638 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 292:
|
|
#line 2448 "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 6649 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 293:
|
|
#line 2458 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); }
|
|
#line 6655 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 294:
|
|
#line 2460 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); }
|
|
#line 6661 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 295:
|
|
#line 2464 "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 6675 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 296:
|
|
#line 2476 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi, MODULE_PROC_STMT, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL); }
|
|
#line 6681 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 297:
|
|
#line 2479 "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 6694 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 298:
|
|
#line 2488 "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 6708 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 299:
|
|
#line 2501 "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 6718 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 300:
|
|
#line 2507 "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 6728 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 301:
|
|
#line 2513 "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 6738 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 302:
|
|
#line 2519 "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 6748 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 303:
|
|
#line 2527 "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 6760 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 304:
|
|
#line 2537 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); }
|
|
#line 6766 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 305:
|
|
#line 2539 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); }
|
|
#line 6772 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 306:
|
|
#line 2543 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 6778 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 307:
|
|
#line 2545 "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 6812 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 308:
|
|
#line 2578 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); }
|
|
#line 6818 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 309:
|
|
#line 2580 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); }
|
|
#line 6824 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 310:
|
|
#line 2584 "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 6856 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 311:
|
|
#line 2622 "gram1.y" /* yacc.c:1646 */
|
|
{ ndim = 0; explicit_shape = 1; (yyval.ll_node) = LLNULL; }
|
|
#line 6862 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 312:
|
|
#line 2624 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[-1].ll_node); }
|
|
#line 6868 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 313:
|
|
#line 2627 "gram1.y" /* yacc.c:1646 */
|
|
{ ndim = 0; explicit_shape = 1;}
|
|
#line 6874 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 314:
|
|
#line 2628 "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 6883 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 315:
|
|
#line 2633 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); }
|
|
#line 6889 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 316:
|
|
#line 2637 "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 6901 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 317:
|
|
#line 2645 "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 6914 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 318:
|
|
#line 2654 "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 6927 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 319:
|
|
#line 2663 "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 6939 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 320:
|
|
#line 2673 "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 6949 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 322:
|
|
#line 2682 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); }
|
|
#line 6955 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 323:
|
|
#line 2684 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); }
|
|
#line 6961 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 324:
|
|
#line 2688 "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 6971 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 325:
|
|
#line 2696 "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 6982 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 326:
|
|
#line 2711 "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 6991 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 327:
|
|
#line 2718 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); }
|
|
#line 6997 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 328:
|
|
#line 2720 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); }
|
|
#line 7003 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 329:
|
|
#line 2724 "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 7013 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 330:
|
|
#line 2739 "gram1.y" /* yacc.c:1646 */
|
|
{ implkwd = YES; }
|
|
#line 7019 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 331:
|
|
#line 2740 "gram1.y" /* yacc.c:1646 */
|
|
{ vartype = (yyvsp[0].data_type); }
|
|
#line 7025 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 332:
|
|
#line 2744 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.data_type) = (yyvsp[0].data_type); }
|
|
#line 7031 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 333:
|
|
#line 2746 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.data_type) = (yyvsp[0].data_type);}
|
|
#line 7037 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 334:
|
|
#line 2758 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); }
|
|
#line 7043 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 335:
|
|
#line 2760 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); }
|
|
#line 7049 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 336:
|
|
#line 2764 "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 7059 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 337:
|
|
#line 2770 "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 7073 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 338:
|
|
#line 2782 "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 7086 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 339:
|
|
#line 2793 "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 7105 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 340:
|
|
#line 2810 "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 7136 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 343:
|
|
#line 2848 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL; endioctl(); }
|
|
#line 7142 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 344:
|
|
#line 2850 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); endioctl();}
|
|
#line 7148 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 345:
|
|
#line 2854 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 7154 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 346:
|
|
#line 2856 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 7160 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 347:
|
|
#line 2858 "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 7170 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 348:
|
|
#line 2869 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST);
|
|
endioctl();
|
|
}
|
|
#line 7178 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 349:
|
|
#line 2873 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-3].ll_node), (yyvsp[0].ll_node), EXPR_LIST);
|
|
endioctl();
|
|
}
|
|
#line 7186 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 350:
|
|
#line 2879 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); }
|
|
#line 7192 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 351:
|
|
#line 2881 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); }
|
|
#line 7198 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 352:
|
|
#line 2885 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 7204 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 353:
|
|
#line 2887 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[-1].ll_node); }
|
|
#line 7210 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 354:
|
|
#line 2889 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 7216 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 355:
|
|
#line 2893 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 7222 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 356:
|
|
#line 2895 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 7228 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 357:
|
|
#line 2899 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 7234 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 358:
|
|
#line 2901 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node("+", ADD_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
|
|
#line 7240 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 359:
|
|
#line 2903 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node("-", SUBT_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
|
|
#line 7246 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 360:
|
|
#line 2905 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node("*", MULT_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
|
|
#line 7252 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 361:
|
|
#line 2907 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node("/", DIV_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
|
|
#line 7258 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 362:
|
|
#line 2909 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node("**", EXP_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
|
|
#line 7264 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 363:
|
|
#line 2911 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = defined_op_node((yyvsp[-1].hash_entry), (yyvsp[0].ll_node), LLNULL); }
|
|
#line 7270 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 364:
|
|
#line 2913 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node("+", UNARY_ADD_OP, (yyvsp[0].ll_node), LLNULL); }
|
|
#line 7276 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 365:
|
|
#line 2915 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node("-", MINUS_OP, (yyvsp[0].ll_node), LLNULL); }
|
|
#line 7282 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 366:
|
|
#line 2917 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node(".eq.", EQ_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
|
|
#line 7288 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 367:
|
|
#line 2919 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node(".gt.", GT_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
|
|
#line 7294 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 368:
|
|
#line 2921 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node(".lt.", LT_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
|
|
#line 7300 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 369:
|
|
#line 2923 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node(".ge.", GTEQL_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
|
|
#line 7306 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 370:
|
|
#line 2925 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node(".ge.", LTEQL_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
|
|
#line 7312 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 371:
|
|
#line 2927 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node(".ne.", NOTEQL_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
|
|
#line 7318 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 372:
|
|
#line 2929 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node(".eqv.", EQV_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
|
|
#line 7324 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 373:
|
|
#line 2931 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node(".neqv.", NEQV_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
|
|
#line 7330 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 374:
|
|
#line 2933 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node(".xor.", XOR_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
|
|
#line 7336 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 375:
|
|
#line 2935 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node(".or.", OR_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
|
|
#line 7342 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 376:
|
|
#line 2937 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node(".and.", AND_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
|
|
#line 7348 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 377:
|
|
#line 2939 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node(".not.", NOT_OP, (yyvsp[0].ll_node), LLNULL); }
|
|
#line 7354 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 378:
|
|
#line 2941 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node("//", CONCAT_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
|
|
#line 7360 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 379:
|
|
#line 2943 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = defined_op_node((yyvsp[-1].hash_entry), (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
|
|
#line 7366 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 380:
|
|
#line 2946 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.token) = ADD_OP; }
|
|
#line 7372 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 381:
|
|
#line 2947 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.token) = SUBT_OP; }
|
|
#line 7378 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 382:
|
|
#line 2959 "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 7454 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 383:
|
|
#line 3033 "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 7470 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 384:
|
|
#line 3045 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 7476 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 385:
|
|
#line 3047 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 7482 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 386:
|
|
#line 3051 "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 7617 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 387:
|
|
#line 3182 "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 7671 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 388:
|
|
#line 3232 "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 7718 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 389:
|
|
#line 3276 "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 7761 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 390:
|
|
#line 3318 "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 7811 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 391:
|
|
#line 3376 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 7817 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 392:
|
|
#line 3378 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 7823 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 393:
|
|
#line 3380 "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 7866 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 394:
|
|
#line 3420 "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 7910 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 395:
|
|
#line 3462 "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 7922 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 396:
|
|
#line 3472 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL; }
|
|
#line 7928 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 397:
|
|
#line 3474 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 7934 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 398:
|
|
#line 3478 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi, DDOT, (yyvsp[-3].ll_node), (yyvsp[-1].ll_node), SMNULL); }
|
|
#line 7940 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 399:
|
|
#line 3482 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL; }
|
|
#line 7946 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 400:
|
|
#line 3484 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 7952 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 401:
|
|
#line 3488 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 7958 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 402:
|
|
#line 3490 "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 7968 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 403:
|
|
#line 3496 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 7974 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 404:
|
|
#line 3498 "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 7984 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 405:
|
|
#line 3504 "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 7998 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 406:
|
|
#line 3517 "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 8008 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 407:
|
|
#line 3523 "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 8018 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 408:
|
|
#line 3530 "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 8028 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 409:
|
|
#line 3536 "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 8038 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 410:
|
|
#line 3544 "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 8048 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 411:
|
|
#line 3552 "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 8068 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 412:
|
|
#line 3568 "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 8082 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 413:
|
|
#line 3578 "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 8096 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 414:
|
|
#line 3591 "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 8105 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 415:
|
|
#line 3598 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 8111 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 416:
|
|
#line 3600 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 8117 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 417:
|
|
#line 3623 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,DDOT,(yyvsp[-2].ll_node),(yyvsp[0].ll_node),SMNULL); }
|
|
#line 8123 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 418:
|
|
#line 3625 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,DDOT,(yyvsp[-1].ll_node),LLNULL,SMNULL); }
|
|
#line 8129 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 419:
|
|
#line 3627 "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 8135 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 420:
|
|
#line 3629 "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 8141 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 421:
|
|
#line 3631 "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 8147 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 422:
|
|
#line 3633 "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 8153 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 423:
|
|
#line 3635 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,DDOT,LLNULL,(yyvsp[0].ll_node),SMNULL); }
|
|
#line 8159 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 424:
|
|
#line 3637 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,DDOT,LLNULL,LLNULL,SMNULL); }
|
|
#line 8165 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 425:
|
|
#line 3640 "gram1.y" /* yacc.c:1646 */
|
|
{in_vec=YES;}
|
|
#line 8171 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 426:
|
|
#line 3640 "gram1.y" /* yacc.c:1646 */
|
|
{in_vec=NO;}
|
|
#line 8177 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 427:
|
|
#line 3641 "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 8193 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 428:
|
|
#line 3655 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 8199 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 429:
|
|
#line 3657 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 8205 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 430:
|
|
#line 3680 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); }
|
|
#line 8211 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 431:
|
|
#line 3682 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-3].ll_node), (yyvsp[0].ll_node), EXPR_LIST); endioctl(); }
|
|
#line 8217 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 432:
|
|
#line 3684 "gram1.y" /* yacc.c:1646 */
|
|
{ stat_alloc = make_llnd(fi, SPEC_PAIR, (yyvsp[-1].ll_node), (yyvsp[0].ll_node), SMNULL);
|
|
endioctl();
|
|
}
|
|
#line 8225 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 433:
|
|
#line 3700 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); }
|
|
#line 8231 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 434:
|
|
#line 3702 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-3].ll_node), (yyvsp[0].ll_node), EXPR_LIST); endioctl(); }
|
|
#line 8237 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 435:
|
|
#line 3704 "gram1.y" /* yacc.c:1646 */
|
|
{ stat_alloc = make_llnd(fi, SPEC_PAIR, (yyvsp[-1].ll_node), (yyvsp[0].ll_node), SMNULL);
|
|
endioctl();
|
|
}
|
|
#line 8245 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 436:
|
|
#line 3717 "gram1.y" /* yacc.c:1646 */
|
|
{stat_alloc = LLNULL;}
|
|
#line 8251 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 437:
|
|
#line 3721 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); }
|
|
#line 8257 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 438:
|
|
#line 3723 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); }
|
|
#line 8263 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 439:
|
|
#line 3731 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = (yyvsp[0].bf_node); }
|
|
#line 8269 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 440:
|
|
#line 3733 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = (yyvsp[0].bf_node); }
|
|
#line 8275 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 441:
|
|
#line 3735 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = (yyvsp[0].bf_node); }
|
|
#line 8281 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 442:
|
|
#line 3737 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = (yyvsp[0].bf_node);
|
|
(yyval.bf_node)->entry.Template.ll_ptr3 = (yyvsp[-1].ll_node);
|
|
}
|
|
#line 8290 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 443:
|
|
#line 3791 "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 8314 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 444:
|
|
#line 3813 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
make_extend((yyvsp[0].symbol));
|
|
(yyval.bf_node) = BFNULL;
|
|
/* delete_beyond_scope_level(pred_bfnd); */
|
|
}
|
|
#line 8324 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 445:
|
|
#line 3826 "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 8334 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 446:
|
|
#line 3835 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = (yyvsp[0].bf_node); }
|
|
#line 8340 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 447:
|
|
#line 3838 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = (yyvsp[0].bf_node);
|
|
(yyval.bf_node)->entry.Template.ll_ptr3 = (yyvsp[-1].ll_node);
|
|
}
|
|
#line 8349 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 448:
|
|
#line 3888 "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 8359 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 449:
|
|
#line 3894 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = (yyvsp[-1].bf_node);
|
|
set_blobs((yyval.bf_node), pred_bfnd, NEW_GROUP1);
|
|
}
|
|
#line 8368 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 450:
|
|
#line 3899 "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 8378 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 451:
|
|
#line 3917 "gram1.y" /* yacc.c:1646 */
|
|
{ make_elseif((yyvsp[-3].ll_node),(yyvsp[0].symbol)); lastwasbranch = NO; (yyval.bf_node) = BFNULL;}
|
|
#line 8384 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 452:
|
|
#line 3919 "gram1.y" /* yacc.c:1646 */
|
|
{ make_else((yyvsp[0].symbol)); lastwasbranch = NO; (yyval.bf_node) = BFNULL; }
|
|
#line 8390 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 453:
|
|
#line 3921 "gram1.y" /* yacc.c:1646 */
|
|
{ make_endif((yyvsp[0].symbol)); (yyval.bf_node) = BFNULL; }
|
|
#line 8396 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 454:
|
|
#line 3923 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = (yyvsp[0].bf_node); }
|
|
#line 8402 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 455:
|
|
#line 3925 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi, CONTAINS_STMT, SMNULL, LLNULL, LLNULL, LLNULL); }
|
|
#line 8408 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 456:
|
|
#line 3928 "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 8418 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 457:
|
|
#line 3934 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = (yyvsp[0].bf_node); }
|
|
#line 8424 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 458:
|
|
#line 3936 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = (yyvsp[0].bf_node); (yyval.bf_node)->entry.Template.ll_ptr3 = (yyvsp[-1].ll_node);}
|
|
#line 8430 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 459:
|
|
#line 3938 "gram1.y" /* yacc.c:1646 */
|
|
{ make_endforall((yyvsp[0].symbol)); (yyval.bf_node) = BFNULL; }
|
|
#line 8436 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 460:
|
|
#line 3941 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = (yyvsp[0].bf_node); }
|
|
#line 8442 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 461:
|
|
#line 3943 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = (yyvsp[0].bf_node); }
|
|
#line 8448 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 462:
|
|
#line 3945 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = (yyvsp[0].bf_node); }
|
|
#line 8454 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 463:
|
|
#line 3972 "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 8465 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 464:
|
|
#line 3981 "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 8475 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 465:
|
|
#line 3989 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL; }
|
|
#line 8481 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 466:
|
|
#line 3991 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[-1].ll_node);}
|
|
#line 8487 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 467:
|
|
#line 3993 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[-1].ll_node);}
|
|
#line 8493 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 468:
|
|
#line 3998 "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 8503 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 469:
|
|
#line 4005 "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 8513 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 470:
|
|
#line 4013 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi, CASE_NODE, (yyvsp[0].symbol), (yyvsp[-1].ll_node), LLNULL, LLNULL); }
|
|
#line 8519 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 471:
|
|
#line 4015 "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 8527 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 472:
|
|
#line 4019 "gram1.y" /* yacc.c:1646 */
|
|
{ make_endselect((yyvsp[0].symbol)); (yyval.bf_node) = BFNULL; }
|
|
#line 8533 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 473:
|
|
#line 4022 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi, SWITCH_NODE, SMNULL, (yyvsp[-1].ll_node), LLNULL, LLNULL) ; }
|
|
#line 8539 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 474:
|
|
#line 4024 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi, SWITCH_NODE, SMNULL, (yyvsp[-1].ll_node), LLNULL, (yyvsp[-7].ll_node)) ; }
|
|
#line 8545 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 475:
|
|
#line 4028 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[-1].ll_node); }
|
|
#line 8551 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 476:
|
|
#line 4034 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 8557 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 477:
|
|
#line 4036 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi, DDOT, (yyvsp[-1].ll_node), LLNULL, SMNULL); }
|
|
#line 8563 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 478:
|
|
#line 4038 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi, DDOT, LLNULL, (yyvsp[0].ll_node), SMNULL); }
|
|
#line 8569 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 479:
|
|
#line 4040 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi, DDOT, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), SMNULL); }
|
|
#line 8575 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 480:
|
|
#line 4044 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi, EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL); }
|
|
#line 8581 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 481:
|
|
#line 4046 "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 8591 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 482:
|
|
#line 4054 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.symbol) = SMNULL; }
|
|
#line 8597 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 483:
|
|
#line 4056 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.symbol) = make_local_entity((yyvsp[0].hash_entry), CONSTRUCT_NAME, global_default,
|
|
LOCAL); }
|
|
#line 8604 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 484:
|
|
#line 4062 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.hash_entry) = HSNULL;}
|
|
#line 8610 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 485:
|
|
#line 4064 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = (yyvsp[0].hash_entry);}
|
|
#line 8616 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 486:
|
|
#line 4068 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.hash_entry) = look_up_sym(yytext);}
|
|
#line 8622 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 487:
|
|
#line 4072 "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 8631 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 488:
|
|
#line 4093 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = make_if((yyvsp[-1].ll_node)); }
|
|
#line 8637 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 489:
|
|
#line 4096 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = make_forall((yyvsp[-2].ll_node),(yyvsp[-1].ll_node)); }
|
|
#line 8643 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 490:
|
|
#line 4100 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi, EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL); }
|
|
#line 8649 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 491:
|
|
#line 4102 "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 8658 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 492:
|
|
#line 4109 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.ll_node) = make_llnd(fi, FORALL_OP, (yyvsp[0].ll_node), LLNULL, (yyvsp[-2].symbol)); }
|
|
#line 8664 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 493:
|
|
#line 4113 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node)=LLNULL;}
|
|
#line 8670 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 494:
|
|
#line 4115 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node)=(yyvsp[0].ll_node);}
|
|
#line 8676 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 495:
|
|
#line 4126 "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 8690 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 496:
|
|
#line 4139 "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 8716 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 497:
|
|
#line 4162 "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 8741 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 498:
|
|
#line 4185 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.label) = LBNULL; }
|
|
#line 8747 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 499:
|
|
#line 4187 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.label) = make_label_node(fi,convci(yyleng, yytext));
|
|
(yyval.label)->scope = cur_scope();
|
|
}
|
|
#line 8756 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 500:
|
|
#line 4194 "gram1.y" /* yacc.c:1646 */
|
|
{ make_endwhere((yyvsp[0].symbol)); (yyval.bf_node) = BFNULL; }
|
|
#line 8762 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 501:
|
|
#line 4196 "gram1.y" /* yacc.c:1646 */
|
|
{ make_elsewhere((yyvsp[0].symbol)); lastwasbranch = NO; (yyval.bf_node) = BFNULL; }
|
|
#line 8768 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 502:
|
|
#line 4198 "gram1.y" /* yacc.c:1646 */
|
|
{ make_elsewhere_mask((yyvsp[-2].ll_node),(yyvsp[0].symbol)); lastwasbranch = NO; (yyval.bf_node) = BFNULL; }
|
|
#line 8774 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 503:
|
|
#line 4200 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi, WHERE_BLOCK_STMT, SMNULL, (yyvsp[-1].ll_node), LLNULL, LLNULL); }
|
|
#line 8780 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 504:
|
|
#line 4202 "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 8786 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 505:
|
|
#line 4207 "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 8866 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 506:
|
|
#line 4283 "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 8876 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 507:
|
|
#line 4295 "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 8887 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 508:
|
|
#line 4302 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,CONT_STAT,SMNULL,LLNULL,LLNULL,LLNULL); }
|
|
#line 8893 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 510:
|
|
#line 4305 "gram1.y" /* yacc.c:1646 */
|
|
{ inioctl = NO; }
|
|
#line 8899 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 511:
|
|
#line 4307 "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 8912 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 512:
|
|
#line 4316 "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 8923 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 513:
|
|
#line 4323 "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 8934 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 514:
|
|
#line 4330 "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 8945 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 515:
|
|
#line 4338 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = get_bfnd(fi,RETURN_STAT,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL);
|
|
thiswasbranch = YES;
|
|
}
|
|
#line 8954 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 516:
|
|
#line 4343 "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 8963 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 517:
|
|
#line 4348 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi, CYCLE_STMT, (yyvsp[0].symbol), LLNULL, LLNULL, LLNULL); }
|
|
#line 8969 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 518:
|
|
#line 4351 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi, EXIT_STMT, (yyvsp[0].symbol), LLNULL, LLNULL, LLNULL); }
|
|
#line 8975 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 519:
|
|
#line 4354 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi, ALLOCATE_STMT, SMNULL, (yyvsp[-1].ll_node), stat_alloc, LLNULL); }
|
|
#line 8981 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 520:
|
|
#line 4357 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi, DEALLOCATE_STMT, SMNULL, (yyvsp[-1].ll_node), stat_alloc , LLNULL); }
|
|
#line 8987 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 521:
|
|
#line 4360 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi, NULLIFY_STMT, SMNULL, (yyvsp[-1].ll_node), LLNULL, LLNULL); }
|
|
#line 8993 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 522:
|
|
#line 4363 "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 8999 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 523:
|
|
#line 4381 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.ll_node) = LLNULL;}
|
|
#line 9005 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 524:
|
|
#line 4385 "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 9014 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 525:
|
|
#line 4390 "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 9037 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 526:
|
|
#line 4409 "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 9060 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 527:
|
|
#line 4428 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,COMGOTO_NODE, SMNULL, (yyvsp[-3].ll_node), (yyvsp[0].ll_node), LLNULL); }
|
|
#line 9066 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 530:
|
|
#line 4436 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.symbol) = make_procedure((yyvsp[-1].hash_entry), LOCAL); }
|
|
#line 9072 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 531:
|
|
#line 4440 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST);
|
|
endioctl();
|
|
}
|
|
#line 9081 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 532:
|
|
#line 4445 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = set_ll_list((yyvsp[-3].ll_node), (yyvsp[0].ll_node), EXPR_LIST);
|
|
endioctl();
|
|
}
|
|
#line 9090 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 533:
|
|
#line 4452 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 9096 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 534:
|
|
#line 4454 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi, KEYWORD_ARG, (yyvsp[-1].ll_node), (yyvsp[0].ll_node), SMNULL); }
|
|
#line 9102 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 535:
|
|
#line 4456 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,LABEL_ARG,(yyvsp[0].ll_node),LLNULL,SMNULL); }
|
|
#line 9108 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 536:
|
|
#line 4459 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.token) = PAUSE_NODE; }
|
|
#line 9114 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 537:
|
|
#line 4460 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.token) = STOP_STAT; }
|
|
#line 9120 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 538:
|
|
#line 4471 "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 9137 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 539:
|
|
#line 4486 "gram1.y" /* yacc.c:1646 */
|
|
{ intonly = YES; }
|
|
#line 9143 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 540:
|
|
#line 4490 "gram1.y" /* yacc.c:1646 */
|
|
{ intonly = NO; }
|
|
#line 9149 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 541:
|
|
#line 4498 "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 9156 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 542:
|
|
#line 4501 "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 9170 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 543:
|
|
#line 4511 "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 9187 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 544:
|
|
#line 4524 "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 9204 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 545:
|
|
#line 4537 "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 9211 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 546:
|
|
#line 4540 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = (yyvsp[0].bf_node); }
|
|
#line 9217 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 547:
|
|
#line 4542 "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 9224 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 548:
|
|
#line 4545 "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 9231 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 549:
|
|
#line 4548 "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 9239 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 550:
|
|
#line 4552 "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 9247 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 551:
|
|
#line 4561 "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 9254 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 552:
|
|
#line 4564 "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 9262 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 553:
|
|
#line 4568 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = (yyvsp[0].bf_node); }
|
|
#line 9268 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 554:
|
|
#line 4570 "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 9275 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 555:
|
|
#line 4576 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = (yyvsp[-2].bf_node); }
|
|
#line 9281 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 556:
|
|
#line 4580 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.bf_node) = get_bfnd(fi, BACKSPACE_STAT, SMNULL, LLNULL, LLNULL, LLNULL);}
|
|
#line 9287 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 557:
|
|
#line 4582 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.bf_node) = get_bfnd(fi, REWIND_STAT, SMNULL, LLNULL, LLNULL, LLNULL);}
|
|
#line 9293 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 558:
|
|
#line 4584 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.bf_node) = get_bfnd(fi, ENDFILE_STAT, SMNULL, LLNULL, LLNULL, LLNULL);}
|
|
#line 9299 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 559:
|
|
#line 4591 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = (yyvsp[-2].bf_node); }
|
|
#line 9305 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 560:
|
|
#line 4595 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.bf_node) = get_bfnd(fi, OPEN_STAT, SMNULL, LLNULL, LLNULL, LLNULL);}
|
|
#line 9311 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 561:
|
|
#line 4597 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.bf_node) = get_bfnd(fi, CLOSE_STAT, SMNULL, LLNULL, LLNULL, LLNULL);}
|
|
#line 9317 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 562:
|
|
#line 4601 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi, INQUIRE_STAT, SMNULL, LLNULL, (yyvsp[0].ll_node), LLNULL);}
|
|
#line 9323 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 563:
|
|
#line 4603 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi, INQUIRE_STAT, SMNULL, (yyvsp[0].ll_node), (yyvsp[-1].ll_node), LLNULL);}
|
|
#line 9329 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 564:
|
|
#line 4607 "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 9352 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 565:
|
|
#line 4626 "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 9369 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 566:
|
|
#line 4642 "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 9382 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 567:
|
|
#line 4653 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = (yyvsp[-1].ll_node);
|
|
endioctl();
|
|
}
|
|
#line 9391 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 568:
|
|
#line 4660 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); endioctl();}
|
|
#line 9397 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 569:
|
|
#line 4662 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-3].ll_node), (yyvsp[0].ll_node), EXPR_LIST); endioctl();}
|
|
#line 9403 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 570:
|
|
#line 4666 "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 9433 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 571:
|
|
#line 4692 "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 9452 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 572:
|
|
#line 4707 "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 9471 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 573:
|
|
#line 4722 "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 9492 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 574:
|
|
#line 4739 "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 9504 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 575:
|
|
#line 4747 "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 9515 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 576:
|
|
#line 4756 "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 9524 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 577:
|
|
#line 4764 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.bf_node) = get_bfnd(fi, READ_STAT, SMNULL, LLNULL, LLNULL, LLNULL);}
|
|
#line 9530 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 578:
|
|
#line 4769 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.bf_node) = get_bfnd(fi, WRITE_STAT, SMNULL, LLNULL, LLNULL, LLNULL);}
|
|
#line 9536 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 579:
|
|
#line 4774 "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 9562 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 580:
|
|
#line 4796 "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 9579 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 581:
|
|
#line 4812 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST);}
|
|
#line 9585 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 582:
|
|
#line 4814 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST);}
|
|
#line 9591 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 583:
|
|
#line 4818 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 9597 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 584:
|
|
#line 4820 "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 9606 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 585:
|
|
#line 4827 "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 9612 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 586:
|
|
#line 4829 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 9618 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 587:
|
|
#line 4831 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 9624 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 588:
|
|
#line 4835 "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 9630 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 589:
|
|
#line 4837 "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 9636 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 590:
|
|
#line 4839 "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 9642 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 591:
|
|
#line 4841 "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 9648 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 592:
|
|
#line 4843 "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 9654 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 593:
|
|
#line 4845 "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 9660 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 594:
|
|
#line 4849 "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 9667 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 595:
|
|
#line 4852 "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 9674 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 596:
|
|
#line 4855 "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 9684 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 597:
|
|
#line 4861 "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 9694 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 598:
|
|
#line 4867 "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 9704 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 599:
|
|
#line 4875 "gram1.y" /* yacc.c:1646 */
|
|
{ inioctl = YES; }
|
|
#line 9710 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 600:
|
|
#line 4879 "gram1.y" /* yacc.c:1646 */
|
|
{ startioctl();}
|
|
#line 9716 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 601:
|
|
#line 4887 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 9722 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 602:
|
|
#line 4889 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[-1].ll_node); }
|
|
#line 9728 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 603:
|
|
#line 4893 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 9734 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 604:
|
|
#line 4895 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 9740 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 605:
|
|
#line 4897 "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 9749 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 606:
|
|
#line 4902 "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 9758 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 607:
|
|
#line 4907 "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 9767 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 608:
|
|
#line 4912 "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 9776 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 609:
|
|
#line 4917 "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 9789 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 610:
|
|
#line 4926 "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 9798 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 611:
|
|
#line 4931 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL; }
|
|
#line 9804 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 612:
|
|
#line 4936 "gram1.y" /* yacc.c:1646 */
|
|
{ comments = cur_comment = CMNULL; }
|
|
#line 9810 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 613:
|
|
#line 4938 "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 9828 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 677:
|
|
#line 5021 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,HPF_TEMPLATE_STAT, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL); }
|
|
#line 9834 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 678:
|
|
#line 5023 "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 9847 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 679:
|
|
#line 5034 "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 9870 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 680:
|
|
#line 5055 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_DYNAMIC_DIR, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL);}
|
|
#line 9876 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 681:
|
|
#line 5059 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 9882 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 682:
|
|
#line 5061 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 9888 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 683:
|
|
#line 5065 "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 9903 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 684:
|
|
#line 5078 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_INHERIT_DIR, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL);}
|
|
#line 9909 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 685:
|
|
#line 5082 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 9915 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 686:
|
|
#line 5084 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 9921 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 687:
|
|
#line 5088 "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 9934 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 688:
|
|
#line 5099 "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 9944 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 689:
|
|
#line 5110 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[-1].ll_node);}
|
|
#line 9950 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 690:
|
|
#line 5114 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 9956 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 691:
|
|
#line 5116 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 9962 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 692:
|
|
#line 5120 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 9968 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 693:
|
|
#line 5122 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,DDOT, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), SMNULL);}
|
|
#line 9974 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 694:
|
|
#line 5124 "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 9984 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 695:
|
|
#line 5139 "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 9999 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 696:
|
|
#line 5151 "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 10023 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 697:
|
|
#line 5171 "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 10047 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 698:
|
|
#line 5191 "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 10071 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 699:
|
|
#line 5213 "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 10081 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 700:
|
|
#line 5219 "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 10092 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 701:
|
|
#line 5228 "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 10102 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 702:
|
|
#line 5236 "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 10112 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 703:
|
|
#line 5242 "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 10122 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 704:
|
|
#line 5250 "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 10131 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 705:
|
|
#line 5257 "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 10141 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 706:
|
|
#line 5263 "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 10152 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 707:
|
|
#line 5272 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.symbol) = make_local_entity((yyvsp[0].hash_entry), REDUCTION_GROUP_NAME,global_default,LOCAL);}
|
|
#line 10158 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 708:
|
|
#line 5276 "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 10168 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 709:
|
|
#line 5282 "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 710:
|
|
#line 5290 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.symbol) = make_local_entity((yyvsp[0].hash_entry), CONSISTENT_GROUP_NAME,global_default,LOCAL);}
|
|
#line 10184 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 711:
|
|
#line 5304 "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 10201 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 712:
|
|
#line 5317 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL; opt_kwd_ = NO;}
|
|
#line 10207 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 713:
|
|
#line 5323 "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 10220 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 714:
|
|
#line 5339 "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 10238 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 715:
|
|
#line 5354 "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 10253 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 716:
|
|
#line 5382 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 10259 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 717:
|
|
#line 5384 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 10265 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 718:
|
|
#line 5388 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 10271 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 719:
|
|
#line 5390 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 10277 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 720:
|
|
#line 5394 "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 10308 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 721:
|
|
#line 5423 "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 10332 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 722:
|
|
#line 5446 "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 10344 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 723:
|
|
#line 5466 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL; }
|
|
#line 10350 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 724:
|
|
#line 5468 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[-1].ll_node);}
|
|
#line 10356 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 725:
|
|
#line 5472 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[-1].ll_node);}
|
|
#line 10362 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 726:
|
|
#line 5493 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 10368 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 727:
|
|
#line 5495 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-3].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 10374 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 728:
|
|
#line 5498 "gram1.y" /* yacc.c:1646 */
|
|
{ opt_kwd_ = YES; }
|
|
#line 10380 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 729:
|
|
#line 5507 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,BLOCK_OP, LLNULL, LLNULL, SMNULL);
|
|
}
|
|
#line 10388 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 730:
|
|
#line 5511 "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 10397 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 731:
|
|
#line 5516 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,BLOCK_OP, LLNULL, LLNULL, (yyvsp[-1].symbol)); }
|
|
#line 10403 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 732:
|
|
#line 5518 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,BLOCK_OP, (yyvsp[-1].ll_node), LLNULL, (yyvsp[-3].symbol)); }
|
|
#line 10409 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 733:
|
|
#line 5520 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,BLOCK_OP, LLNULL, (yyvsp[-1].ll_node), SMNULL); }
|
|
#line 10415 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 734:
|
|
#line 5522 "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 10425 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 735:
|
|
#line 5528 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,INDIRECT_OP, LLNULL, LLNULL, (yyvsp[-1].symbol)); }
|
|
#line 10431 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 736:
|
|
#line 5530 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,INDIRECT_OP, (yyvsp[-1].ll_node), LLNULL, SMNULL); }
|
|
#line 10437 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 737:
|
|
#line 5534 "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 10449 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 738:
|
|
#line 5544 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,DERIVED_OP, (yyvsp[-4].ll_node), (yyvsp[0].ll_node), SMNULL); }
|
|
#line 10455 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 739:
|
|
#line 5548 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 10461 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 740:
|
|
#line 5550 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 10467 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 741:
|
|
#line 5555 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 10473 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 742:
|
|
#line 5557 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,DDOT, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), SMNULL);}
|
|
#line 10479 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 743:
|
|
#line 5561 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,ARRAY_REF, LLNULL, LLNULL, (yyvsp[0].symbol));
|
|
}
|
|
#line 10487 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 744:
|
|
#line 5565 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,ARRAY_REF, (yyvsp[-1].ll_node), LLNULL, (yyvsp[-3].symbol));
|
|
}
|
|
#line 10495 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 745:
|
|
#line 5571 "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 10507 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 746:
|
|
#line 5581 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 10513 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 747:
|
|
#line 5583 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 10519 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 748:
|
|
#line 5587 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 10525 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 749:
|
|
#line 5589 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 10531 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 750:
|
|
#line 5591 "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 10540 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 751:
|
|
#line 5598 "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 10550 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 752:
|
|
#line 5615 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL; }
|
|
#line 10556 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 753:
|
|
#line 5617 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 10562 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 754:
|
|
#line 5621 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 10568 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 755:
|
|
#line 5623 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 10574 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 756:
|
|
#line 5627 "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 10583 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 757:
|
|
#line 5634 "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 10597 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 758:
|
|
#line 5644 "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 10618 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 759:
|
|
#line 5673 "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 10628 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 760:
|
|
#line 5688 "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 10639 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 761:
|
|
#line 5695 "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 10649 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 762:
|
|
#line 5713 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 10655 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 763:
|
|
#line 5715 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 10661 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 764:
|
|
#line 5719 "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 10677 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 765:
|
|
#line 5733 "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 10705 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 766:
|
|
#line 5759 "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 10720 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 767:
|
|
#line 5772 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,ARRAY_REF, (yyvsp[-1].ll_node), LLNULL, (yyvsp[-3].symbol));
|
|
}
|
|
#line 10728 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 768:
|
|
#line 5788 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 10734 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 769:
|
|
#line 5790 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 10740 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 770:
|
|
#line 5793 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 10746 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 771:
|
|
#line 5795 "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 10756 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 772:
|
|
#line 5801 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 10762 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 773:
|
|
#line 5805 "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 10792 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 774:
|
|
#line 5833 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 10798 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 775:
|
|
#line 5835 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 10804 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 776:
|
|
#line 5839 "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 10816 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 777:
|
|
#line 5847 "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 10826 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 778:
|
|
#line 5853 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,DDOT, LLNULL, LLNULL, SMNULL); }
|
|
#line 10832 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 779:
|
|
#line 5856 "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 10894 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 780:
|
|
#line 5914 "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 10954 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 781:
|
|
#line 5978 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); type_options = type_opt; }
|
|
#line 10960 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 782:
|
|
#line 5980 "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 10966 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 783:
|
|
#line 5983 "gram1.y" /* yacc.c:1646 */
|
|
{ type_opt = TEMPLATE_BIT;
|
|
(yyval.ll_node) = make_llnd(fi,TEMPLATE_OP,LLNULL,LLNULL,SMNULL);
|
|
}
|
|
#line 10974 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 784:
|
|
#line 5987 "gram1.y" /* yacc.c:1646 */
|
|
{ type_opt = PROCESSORS_BIT;
|
|
(yyval.ll_node) = make_llnd(fi,PROCESSORS_OP,LLNULL,LLNULL,SMNULL);
|
|
}
|
|
#line 10982 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 785:
|
|
#line 5991 "gram1.y" /* yacc.c:1646 */
|
|
{ type_opt = PROCESSORS_BIT;
|
|
(yyval.ll_node) = make_llnd(fi,PROCESSORS_OP,LLNULL,LLNULL,SMNULL);
|
|
}
|
|
#line 10990 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 786:
|
|
#line 5995 "gram1.y" /* yacc.c:1646 */
|
|
{ type_opt = DYNAMIC_BIT;
|
|
(yyval.ll_node) = make_llnd(fi,DYNAMIC_OP,LLNULL,LLNULL,SMNULL);
|
|
}
|
|
#line 10998 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 787:
|
|
#line 6012 "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 11014 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 788:
|
|
#line 6024 "gram1.y" /* yacc.c:1646 */
|
|
{ type_opt = SHADOW_BIT;
|
|
(yyval.ll_node) = make_llnd(fi,SHADOW_OP,(yyvsp[0].ll_node),LLNULL,SMNULL);
|
|
}
|
|
#line 11022 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 789:
|
|
#line 6028 "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 11030 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 790:
|
|
#line 6032 "gram1.y" /* yacc.c:1646 */
|
|
{ type_opt = ALIGN_BIT;
|
|
(yyval.ll_node) = make_llnd(fi,ALIGN_OP,LLNULL,SMNULL,SMNULL);
|
|
}
|
|
#line 11038 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 791:
|
|
#line 6042 "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 11047 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 792:
|
|
#line 6047 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
type_opt = DISTRIBUTE_BIT;
|
|
(yyval.ll_node) = make_llnd(fi,DISTRIBUTE_OP,LLNULL,LLNULL,SMNULL);
|
|
}
|
|
#line 11056 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 793:
|
|
#line 6052 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
type_opt = COMMON_BIT;
|
|
(yyval.ll_node) = make_llnd(fi,COMMON_OP, LLNULL, LLNULL, SMNULL);
|
|
}
|
|
#line 11065 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 794:
|
|
#line 6059 "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 11076 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 795:
|
|
#line 6067 "gram1.y" /* yacc.c:1646 */
|
|
{ndim = 0;}
|
|
#line 11082 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 796:
|
|
#line 6068 "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 11097 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 797:
|
|
#line 6079 "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 11110 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 798:
|
|
#line 6090 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 11116 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 799:
|
|
#line 6092 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 11122 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 800:
|
|
#line 6096 "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 11135 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 801:
|
|
#line 6107 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_HEAP_DIR, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL);}
|
|
#line 11141 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 802:
|
|
#line 6111 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 11147 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 803:
|
|
#line 6113 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 11153 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 804:
|
|
#line 6117 "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 11166 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 805:
|
|
#line 6128 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_CONSISTENT_DIR, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL);}
|
|
#line 11172 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 806:
|
|
#line 6132 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 11178 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 807:
|
|
#line 6134 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 11184 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 808:
|
|
#line 6138 "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 11197 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 809:
|
|
#line 6150 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_ASYNCID_DIR, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL);}
|
|
#line 11203 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 810:
|
|
#line 6152 "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 11212 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 811:
|
|
#line 6159 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 11218 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 812:
|
|
#line 6161 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 11224 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 813:
|
|
#line 6165 "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 11241 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 814:
|
|
#line 6181 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_NEW_VALUE_DIR,SMNULL, LLNULL, LLNULL,LLNULL);}
|
|
#line 11247 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 815:
|
|
#line 6191 "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 11257 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 816:
|
|
#line 6200 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 11263 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 817:
|
|
#line 6202 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 11269 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 818:
|
|
#line 6206 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 11275 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 819:
|
|
#line 6209 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL; opt_kwd_ = NO;}
|
|
#line 11281 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 820:
|
|
#line 6214 "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 11293 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 821:
|
|
#line 6224 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 11299 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 822:
|
|
#line 6226 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 11305 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 823:
|
|
#line 6230 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 11311 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 824:
|
|
#line 6232 "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 11321 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 825:
|
|
#line 6240 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL;}
|
|
#line 11327 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 826:
|
|
#line 6242 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 11333 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 827:
|
|
#line 6246 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 11339 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 828:
|
|
#line 6248 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 11345 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 840:
|
|
#line 6266 "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 11354 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 841:
|
|
#line 6271 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,REMOTE_ACCESS_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 11360 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 842:
|
|
#line 6275 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,CONSISTENT_OP,(yyvsp[-1].ll_node),LLNULL,(yyvsp[-3].symbol));
|
|
}
|
|
#line 11368 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 843:
|
|
#line 6279 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,CONSISTENT_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 11374 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 844:
|
|
#line 6283 "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 11388 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 845:
|
|
#line 6296 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.ll_node) = make_llnd(fi,NEW_SPEC_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 11394 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 846:
|
|
#line 6300 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.ll_node) = make_llnd(fi,NEW_SPEC_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 11400 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 847:
|
|
#line 6304 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,ACC_PRIVATE_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 11406 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 848:
|
|
#line 6308 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,ACC_CUDA_BLOCK_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 11412 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 849:
|
|
#line 6311 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST);}
|
|
#line 11418 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 850:
|
|
#line 6313 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST);}
|
|
#line 11424 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 851:
|
|
#line 6315 "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 11430 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 852:
|
|
#line 6319 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST);}
|
|
#line 11436 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 853:
|
|
#line 6321 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST);}
|
|
#line 11442 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 854:
|
|
#line 6325 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,ACC_TIE_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 11448 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 855:
|
|
#line 6329 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST);}
|
|
#line 11454 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 856:
|
|
#line 6331 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST);}
|
|
#line 11460 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 857:
|
|
#line 6335 "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 11469 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 858:
|
|
#line 6340 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,INDIRECT_ACCESS_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 11475 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 859:
|
|
#line 6344 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.ll_node) = make_llnd(fi,STAGE_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 11481 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 860:
|
|
#line 6348 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.ll_node) = make_llnd(fi,ACROSS_OP,(yyvsp[0].ll_node),LLNULL,SMNULL);}
|
|
#line 11487 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 861:
|
|
#line 6350 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.ll_node) = make_llnd(fi,ACROSS_OP,(yyvsp[-1].ll_node),(yyvsp[0].ll_node),SMNULL);}
|
|
#line 11493 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 862:
|
|
#line 6354 "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 11503 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 863:
|
|
#line 6362 "gram1.y" /* yacc.c:1646 */
|
|
{ opt_in_out = YES; }
|
|
#line 11509 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 864:
|
|
#line 6366 "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 11519 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 865:
|
|
#line 6372 "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 11529 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 866:
|
|
#line 6378 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL; opt_in_out = NO;}
|
|
#line 11535 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 867:
|
|
#line 6382 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST);}
|
|
#line 11541 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 868:
|
|
#line 6384 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST);}
|
|
#line 11547 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 869:
|
|
#line 6388 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 11553 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 870:
|
|
#line 6390 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[-3].ll_node);
|
|
(yyval.ll_node)-> entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);
|
|
}
|
|
#line 11561 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 871:
|
|
#line 6394 "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 11574 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 872:
|
|
#line 6406 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST);}
|
|
#line 11580 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 873:
|
|
#line 6408 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST);}
|
|
#line 11586 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 874:
|
|
#line 6412 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,DDOT, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), SMNULL);}
|
|
#line 11592 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 875:
|
|
#line 6416 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST);}
|
|
#line 11598 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 876:
|
|
#line 6418 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST);}
|
|
#line 11604 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 877:
|
|
#line 6422 "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 11610 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 878:
|
|
#line 6424 "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 11616 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 879:
|
|
#line 6426 "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 11622 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 880:
|
|
#line 6428 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,DDOT,(yyvsp[0].ll_node),LLNULL,SMNULL); }
|
|
#line 11628 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 881:
|
|
#line 6430 "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 11634 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 882:
|
|
#line 6432 "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 11640 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 883:
|
|
#line 6434 "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 11646 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 884:
|
|
#line 6438 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 11652 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 885:
|
|
#line 6442 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 11658 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 886:
|
|
#line 6446 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 11664 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 887:
|
|
#line 6450 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[-1].ll_node);}
|
|
#line 11670 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 888:
|
|
#line 6454 "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 11681 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 889:
|
|
#line 6461 "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 11690 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 890:
|
|
#line 6467 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,REDUCTION_OP,(yyvsp[-1].ll_node),LLNULL,(yyvsp[-4].symbol)); }
|
|
#line 11696 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 891:
|
|
#line 6471 "gram1.y" /* yacc.c:1646 */
|
|
{ opt_kwd_r = YES; }
|
|
#line 11702 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 892:
|
|
#line 6474 "gram1.y" /* yacc.c:1646 */
|
|
{ opt_kwd_r = NO; }
|
|
#line 11708 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 893:
|
|
#line 6478 "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 11722 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 894:
|
|
#line 6491 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST);}
|
|
#line 11728 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 895:
|
|
#line 6493 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.ll_node) = set_ll_list((yyvsp[-3].ll_node),(yyvsp[0].ll_node),EXPR_LIST);}
|
|
#line 11734 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 896:
|
|
#line 6497 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.ll_node) = make_llnd(fi,ARRAY_OP,(yyvsp[-3].ll_node),(yyvsp[-1].ll_node),SMNULL);}
|
|
#line 11740 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 897:
|
|
#line 6499 "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 11747 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 898:
|
|
#line 6504 "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 11757 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 899:
|
|
#line 6510 "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 11767 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 900:
|
|
#line 6516 "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 11777 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 901:
|
|
#line 6522 "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 11787 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 902:
|
|
#line 6528 "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 11797 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 903:
|
|
#line 6534 "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 11807 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 904:
|
|
#line 6540 "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 11817 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 905:
|
|
#line 6546 "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 11827 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 906:
|
|
#line 6552 "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 11838 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 907:
|
|
#line 6561 "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 11848 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 908:
|
|
#line 6567 "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 11858 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 909:
|
|
#line 6584 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SHADOW_RENEW_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 11864 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 910:
|
|
#line 6592 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SHADOW_START_OP,LLNULL,LLNULL,(yyvsp[0].symbol));}
|
|
#line 11870 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 911:
|
|
#line 6600 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SHADOW_WAIT_OP,LLNULL,LLNULL,(yyvsp[0].symbol));}
|
|
#line 11876 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 912:
|
|
#line 6602 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SHADOW_COMP_OP,LLNULL,LLNULL,SMNULL);}
|
|
#line 11882 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 913:
|
|
#line 6604 "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 11888 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 914:
|
|
#line 6608 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.symbol) = make_local_entity((yyvsp[0].hash_entry), SHADOW_GROUP_NAME,global_default,LOCAL);}
|
|
#line 11894 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 915:
|
|
#line 6612 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST);}
|
|
#line 11900 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 916:
|
|
#line 6614 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST);}
|
|
#line 11906 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 917:
|
|
#line 6618 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 11912 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 918:
|
|
#line 6620 "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 11923 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 919:
|
|
#line 6628 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[-4].ll_node);
|
|
(yyval.ll_node)-> entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);
|
|
}
|
|
#line 11931 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 920:
|
|
#line 6632 "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 11943 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 921:
|
|
#line 6643 "gram1.y" /* yacc.c:1646 */
|
|
{ optcorner = YES; }
|
|
#line 11949 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 922:
|
|
#line 6647 "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 11969 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 923:
|
|
#line 6665 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 11975 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 924:
|
|
#line 6667 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 11981 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 925:
|
|
#line 6671 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_SHADOW_START_DIR,(yyvsp[0].symbol),LLNULL,LLNULL,LLNULL);}
|
|
#line 11987 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 926:
|
|
#line 6673 "gram1.y" /* yacc.c:1646 */
|
|
{errstr("Missing DVM directive prefix", 49);}
|
|
#line 11993 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 927:
|
|
#line 6677 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_SHADOW_WAIT_DIR,(yyvsp[0].symbol),LLNULL,LLNULL,LLNULL);}
|
|
#line 11999 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 928:
|
|
#line 6679 "gram1.y" /* yacc.c:1646 */
|
|
{errstr("Missing DVM directive prefix", 49);}
|
|
#line 12005 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 929:
|
|
#line 6683 "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 12011 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 930:
|
|
#line 6687 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_REDUCTION_START_DIR,(yyvsp[0].symbol),LLNULL,LLNULL,LLNULL);}
|
|
#line 12017 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 931:
|
|
#line 6691 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_REDUCTION_WAIT_DIR,(yyvsp[0].symbol),LLNULL,LLNULL,LLNULL);}
|
|
#line 12023 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 932:
|
|
#line 6700 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_CONSISTENT_START_DIR,(yyvsp[0].symbol),LLNULL,LLNULL,LLNULL);}
|
|
#line 12029 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 933:
|
|
#line 6704 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_CONSISTENT_WAIT_DIR,(yyvsp[0].symbol),LLNULL,LLNULL,LLNULL);}
|
|
#line 12035 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 934:
|
|
#line 6708 "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 12044 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 935:
|
|
#line 6713 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_REMOTE_ACCESS_DIR,SMNULL,(yyvsp[-1].ll_node),LLNULL,LLNULL);}
|
|
#line 12050 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 936:
|
|
#line 6717 "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 12064 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 937:
|
|
#line 6729 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 12070 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 938:
|
|
#line 6731 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 12076 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 939:
|
|
#line 6735 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = (yyvsp[-3].ll_node);
|
|
(yyval.ll_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);
|
|
}
|
|
#line 12085 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 940:
|
|
#line 6740 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 12091 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 941:
|
|
#line 6744 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 12097 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 942:
|
|
#line 6746 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 12103 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 943:
|
|
#line 6750 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 12109 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 944:
|
|
#line 6752 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,DDOT, LLNULL, LLNULL, SMNULL);}
|
|
#line 12115 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 945:
|
|
#line 6756 "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 12124 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 946:
|
|
#line 6761 "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 12133 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 947:
|
|
#line 6768 "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 12158 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 948:
|
|
#line 6791 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.bf_node) = get_bfnd(fi,DVM_TASK_REGION_DIR,(yyvsp[0].symbol),LLNULL,LLNULL,LLNULL);}
|
|
#line 12164 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 949:
|
|
#line 6793 "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 12170 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 950:
|
|
#line 6795 "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 12176 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 951:
|
|
#line 6797 "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 12182 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 952:
|
|
#line 6799 "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 12188 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 953:
|
|
#line 6803 "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 12201 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 954:
|
|
#line 6814 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_END_TASK_REGION_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
|
|
#line 12207 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 955:
|
|
#line 6818 "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 12226 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 956:
|
|
#line 6833 "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 12235 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 957:
|
|
#line 6840 "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 12243 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 958:
|
|
#line 6846 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.ll_node) = LLNULL;}
|
|
#line 12249 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 959:
|
|
#line 6848 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 12255 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 960:
|
|
#line 6852 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.bf_node) = get_bfnd(fi,DVM_END_ON_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
|
|
#line 12261 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 961:
|
|
#line 6856 "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 12273 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 962:
|
|
#line 6864 "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 12279 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 963:
|
|
#line 6868 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_PREFETCH_DIR,(yyvsp[0].symbol),LLNULL,LLNULL,LLNULL);}
|
|
#line 12285 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 964:
|
|
#line 6872 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_RESET_DIR,(yyvsp[0].symbol),LLNULL,LLNULL,LLNULL);}
|
|
#line 12291 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 965:
|
|
#line 6880 "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 12300 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 966:
|
|
#line 6885 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_INDIRECT_ACCESS_DIR,SMNULL,(yyvsp[-1].ll_node),LLNULL,LLNULL);}
|
|
#line 12306 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 967:
|
|
#line 6899 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 12312 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 968:
|
|
#line 6901 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 12318 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 969:
|
|
#line 6905 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 12324 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 970:
|
|
#line 6907 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[-3].ll_node); (yyval.ll_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);}
|
|
#line 12330 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 971:
|
|
#line 6916 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,HPF_INDEPENDENT_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
|
|
#line 12336 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 972:
|
|
#line 6918 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,HPF_INDEPENDENT_DIR,SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL);}
|
|
#line 12342 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 973:
|
|
#line 6920 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,HPF_INDEPENDENT_DIR,SMNULL, LLNULL, (yyvsp[0].ll_node), LLNULL);}
|
|
#line 12348 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 974:
|
|
#line 6922 "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 12354 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 975:
|
|
#line 6958 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.ll_node) = make_llnd(fi,REDUCTION_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 12360 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 976:
|
|
#line 6962 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_ASYNCHRONOUS_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL);}
|
|
#line 12366 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 977:
|
|
#line 6966 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_ENDASYNCHRONOUS_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
|
|
#line 12372 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 978:
|
|
#line 6970 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_ASYNCWAIT_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL);}
|
|
#line 12378 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 979:
|
|
#line 6974 "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 12392 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 980:
|
|
#line 6986 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,VAR_REF, LLNULL, LLNULL, (yyvsp[0].symbol));}
|
|
#line 12398 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 981:
|
|
#line 6988 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,ARRAY_REF, (yyvsp[-1].ll_node), LLNULL, (yyvsp[-3].symbol));}
|
|
#line 12404 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 982:
|
|
#line 6992 "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 12410 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 983:
|
|
#line 6995 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_DEBUG_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL);}
|
|
#line 12416 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 984:
|
|
#line 6997 "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 12422 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 985:
|
|
#line 7001 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST);
|
|
endioctl();
|
|
}
|
|
#line 12431 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 986:
|
|
#line 7006 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = set_ll_list((yyvsp[-3].ll_node), (yyvsp[0].ll_node), EXPR_LIST);
|
|
endioctl();
|
|
}
|
|
#line 12440 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 987:
|
|
#line 7013 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi, KEYWORD_ARG, (yyvsp[-1].ll_node), (yyvsp[0].ll_node), SMNULL); }
|
|
#line 12446 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 988:
|
|
#line 7016 "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 12456 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 989:
|
|
#line 7024 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_ENDDEBUG_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL);}
|
|
#line 12462 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 990:
|
|
#line 7028 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_INTERVAL_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL);}
|
|
#line 12468 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 991:
|
|
#line 7032 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL;}
|
|
#line 12474 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 992:
|
|
#line 7035 "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 12483 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 993:
|
|
#line 7043 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_EXIT_INTERVAL_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL);}
|
|
#line 12489 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 994:
|
|
#line 7047 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_ENDINTERVAL_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
|
|
#line 12495 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 995:
|
|
#line 7051 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_TRACEON_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
|
|
#line 12501 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 996:
|
|
#line 7055 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_TRACEOFF_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
|
|
#line 12507 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 997:
|
|
#line 7059 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_BARRIER_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
|
|
#line 12513 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 998:
|
|
#line 7063 "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 12519 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 999:
|
|
#line 7067 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_IO_MODE_DIR,SMNULL,(yyvsp[-1].ll_node),LLNULL,LLNULL);}
|
|
#line 12525 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1000:
|
|
#line 7070 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 12531 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1001:
|
|
#line 7072 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 12537 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1002:
|
|
#line 7076 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,ACC_ASYNC_OP,LLNULL,LLNULL,SMNULL);}
|
|
#line 12543 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1003:
|
|
#line 7078 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,ACC_LOCAL_OP, LLNULL,LLNULL,SMNULL);}
|
|
#line 12549 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1004:
|
|
#line 7080 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,PARALLEL_OP, LLNULL,LLNULL,SMNULL);}
|
|
#line 12555 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1005:
|
|
#line 7084 "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 12561 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1006:
|
|
#line 7088 "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 12575 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1007:
|
|
#line 7100 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 12581 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1008:
|
|
#line 7102 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 12587 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1009:
|
|
#line 7106 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 12593 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1010:
|
|
#line 7108 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 12599 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1011:
|
|
#line 7112 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 12605 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1012:
|
|
#line 7114 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL; opt_kwd_ = NO;}
|
|
#line 12611 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1013:
|
|
#line 7118 "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 12617 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1014:
|
|
#line 7122 "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 12627 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1015:
|
|
#line 7128 "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 12640 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1016:
|
|
#line 7140 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 12646 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1017:
|
|
#line 7142 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 12652 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1018:
|
|
#line 7146 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 12658 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1019:
|
|
#line 7148 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,DDOT, LLNULL, LLNULL, SMNULL);}
|
|
#line 12664 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1020:
|
|
#line 7152 "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 12674 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1021:
|
|
#line 7160 "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 12687 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1022:
|
|
#line 7171 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL; }
|
|
#line 12693 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1023:
|
|
#line 7173 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi, PARALLEL_OP, LLNULL, LLNULL, SMNULL); }
|
|
#line 12699 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1024:
|
|
#line 7175 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,ACC_LOCAL_OP, LLNULL, LLNULL, SMNULL); }
|
|
#line 12705 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1025:
|
|
#line 7179 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_CP_LOAD_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL); }
|
|
#line 12711 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1026:
|
|
#line 7183 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_CP_SAVE_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL); }
|
|
#line 12717 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1027:
|
|
#line 7185 "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 12727 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1028:
|
|
#line 7193 "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 12733 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1029:
|
|
#line 7197 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_TEMPLATE_CREATE_DIR,SMNULL,(yyvsp[-1].ll_node),LLNULL,LLNULL); }
|
|
#line 12739 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1030:
|
|
#line 7200 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); }
|
|
#line 12745 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1031:
|
|
#line 7202 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); }
|
|
#line 12751 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1032:
|
|
#line 7206 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_TEMPLATE_DELETE_DIR,SMNULL,(yyvsp[-1].ll_node),LLNULL,LLNULL); }
|
|
#line 12757 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1060:
|
|
#line 7240 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = get_bfnd(fi,OMP_ONETHREAD_DIR,SMNULL,LLNULL,LLNULL,LLNULL);
|
|
}
|
|
#line 12765 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1061:
|
|
#line 7246 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_endparallel();
|
|
}
|
|
#line 12773 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1062:
|
|
#line 7252 "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 12783 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1063:
|
|
#line 7258 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_parallel();
|
|
opt_kwd_ = NO;
|
|
}
|
|
#line 12792 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1064:
|
|
#line 7264 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node),LLNULL,EXPR_LIST);
|
|
}
|
|
#line 12800 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1065:
|
|
#line 7268 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = set_ll_list((yyvsp[-4].ll_node),(yyvsp[-1].ll_node),EXPR_LIST);
|
|
}
|
|
#line 12808 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1075:
|
|
#line 7285 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = (yyvsp[-1].ll_node);
|
|
}
|
|
#line 12816 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1076:
|
|
#line 7290 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,OMP_PRIVATE,(yyvsp[0].ll_node),LLNULL,SMNULL);
|
|
}
|
|
#line 12824 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1077:
|
|
#line 7295 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,OMP_FIRSTPRIVATE,(yyvsp[0].ll_node),LLNULL,SMNULL);
|
|
}
|
|
#line 12832 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1078:
|
|
#line 7301 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,OMP_LASTPRIVATE,(yyvsp[0].ll_node),LLNULL,SMNULL);
|
|
}
|
|
#line 12840 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1079:
|
|
#line 7307 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,OMP_COPYIN,(yyvsp[0].ll_node),LLNULL,SMNULL);
|
|
}
|
|
#line 12848 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1080:
|
|
#line 7313 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,OMP_SHARED,(yyvsp[0].ll_node),LLNULL,SMNULL);
|
|
}
|
|
#line 12856 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1081:
|
|
#line 7318 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,OMP_DEFAULT,(yyvsp[-1].ll_node),LLNULL,SMNULL);
|
|
}
|
|
#line 12864 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1082:
|
|
#line 7324 "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 12874 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1083:
|
|
#line 7330 "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 12884 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1084:
|
|
#line 7336 "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 12894 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1085:
|
|
#line 7343 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,OMP_IF,(yyvsp[-1].ll_node),LLNULL,SMNULL);
|
|
}
|
|
#line 12902 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1086:
|
|
#line 7349 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,OMP_NUM_THREADS,(yyvsp[-1].ll_node),LLNULL,SMNULL);
|
|
}
|
|
#line 12910 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1087:
|
|
#line 7355 "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 12920 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1088:
|
|
#line 7362 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.ll_node) = make_llnd(fi,DDOT,(yyvsp[-2].ll_node),(yyvsp[0].ll_node),SMNULL);}
|
|
#line 12926 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1090:
|
|
#line 7368 "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 12936 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1091:
|
|
#line 7374 "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 12946 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1092:
|
|
#line 7381 "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 12956 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1093:
|
|
#line 7387 "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 12966 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1094:
|
|
#line 7393 "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 12976 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1095:
|
|
#line 7399 "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 12986 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1096:
|
|
#line 7405 "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 12996 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1097:
|
|
#line 7411 "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 13006 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1098:
|
|
#line 7417 "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 13016 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1099:
|
|
#line 7423 "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 13026 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1100:
|
|
#line 7429 "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 13036 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1101:
|
|
#line 7435 "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 13046 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1102:
|
|
#line 7441 "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 13056 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1103:
|
|
#line 7447 "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 13067 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1104:
|
|
#line 7457 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_sections((yyvsp[0].ll_node));
|
|
opt_kwd_ = NO;
|
|
}
|
|
#line 13076 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1105:
|
|
#line 7462 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_sections(LLNULL);
|
|
opt_kwd_ = NO;
|
|
}
|
|
#line 13085 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1106:
|
|
#line 7468 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node),LLNULL,EXPR_LIST);
|
|
}
|
|
#line 13093 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1107:
|
|
#line 7472 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = set_ll_list((yyvsp[-4].ll_node),(yyvsp[-1].ll_node),EXPR_LIST);
|
|
}
|
|
#line 13101 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1112:
|
|
#line 7484 "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 13113 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1113:
|
|
#line 7492 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_endsections();
|
|
opt_kwd_ = NO;
|
|
}
|
|
#line 13122 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1114:
|
|
#line 7498 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_ompsection();
|
|
}
|
|
#line 13130 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1115:
|
|
#line 7504 "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 13139 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1116:
|
|
#line 7509 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = get_bfnd(fi,OMP_DO_DIR,SMNULL,LLNULL,LLNULL,LLNULL);
|
|
opt_kwd_ = NO;
|
|
}
|
|
#line 13148 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1117:
|
|
#line 7515 "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 13159 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1118:
|
|
#line 7522 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = get_bfnd(fi,OMP_END_DO_DIR,SMNULL,LLNULL,LLNULL,LLNULL);
|
|
opt_kwd_ = NO;
|
|
}
|
|
#line 13168 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1119:
|
|
#line 7528 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node),LLNULL,EXPR_LIST);
|
|
}
|
|
#line 13176 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1120:
|
|
#line 7532 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = set_ll_list((yyvsp[-4].ll_node),(yyvsp[-1].ll_node),EXPR_LIST);
|
|
}
|
|
#line 13184 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1127:
|
|
#line 7546 "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 13195 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1128:
|
|
#line 7555 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,OMP_SCHEDULE,(yyvsp[-3].ll_node),(yyvsp[-1].ll_node),SMNULL);
|
|
}
|
|
#line 13203 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1129:
|
|
#line 7559 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,OMP_SCHEDULE,(yyvsp[-1].ll_node),LLNULL,SMNULL);
|
|
}
|
|
#line 13211 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1130:
|
|
#line 7565 "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 13222 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1131:
|
|
#line 7572 "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 13233 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1132:
|
|
#line 7579 "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 13244 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1133:
|
|
#line 7586 "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 13255 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1134:
|
|
#line 7595 "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 13265 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1135:
|
|
#line 7601 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_single();
|
|
opt_kwd_ = NO;
|
|
}
|
|
#line 13274 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1136:
|
|
#line 7607 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node),LLNULL,EXPR_LIST);
|
|
}
|
|
#line 13282 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1137:
|
|
#line 7611 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = set_ll_list((yyvsp[-4].ll_node),(yyvsp[-1].ll_node),EXPR_LIST);
|
|
}
|
|
#line 13290 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1140:
|
|
#line 7621 "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 13300 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1141:
|
|
#line 7627 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_endsingle();
|
|
opt_kwd_ = NO;
|
|
}
|
|
#line 13309 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1142:
|
|
#line 7633 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node),LLNULL,EXPR_LIST);
|
|
}
|
|
#line 13317 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1143:
|
|
#line 7637 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = set_ll_list((yyvsp[-4].ll_node),(yyvsp[-1].ll_node),EXPR_LIST);
|
|
}
|
|
#line 13325 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1146:
|
|
#line 7648 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,OMP_COPYPRIVATE,(yyvsp[0].ll_node),LLNULL,SMNULL);
|
|
}
|
|
#line 13333 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1147:
|
|
#line 7654 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,OMP_NOWAIT,LLNULL,LLNULL,SMNULL);
|
|
}
|
|
#line 13341 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1148:
|
|
#line 7660 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_workshare();
|
|
}
|
|
#line 13349 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1149:
|
|
#line 7665 "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 13361 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1150:
|
|
#line 7673 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_endworkshare();
|
|
opt_kwd_ = NO;
|
|
}
|
|
#line 13370 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1151:
|
|
#line 7679 "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 13379 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1152:
|
|
#line 7684 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = get_bfnd(fi,OMP_PARALLEL_DO_DIR,SMNULL,LLNULL,LLNULL,LLNULL);
|
|
opt_kwd_ = NO;
|
|
}
|
|
#line 13388 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1153:
|
|
#line 7691 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node),LLNULL,EXPR_LIST);
|
|
}
|
|
#line 13396 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1154:
|
|
#line 7695 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = set_ll_list((yyvsp[-4].ll_node),(yyvsp[-1].ll_node),EXPR_LIST);
|
|
}
|
|
#line 13404 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1166:
|
|
#line 7715 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = get_bfnd(fi,OMP_END_PARALLEL_DO_DIR,SMNULL,LLNULL,LLNULL,LLNULL);
|
|
}
|
|
#line 13412 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1167:
|
|
#line 7720 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_parallelsections((yyvsp[0].ll_node));
|
|
opt_kwd_ = NO;
|
|
}
|
|
#line 13421 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1168:
|
|
#line 7725 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_parallelsections(LLNULL);
|
|
opt_kwd_ = NO;
|
|
}
|
|
#line 13430 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1169:
|
|
#line 7732 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_endparallelsections();
|
|
}
|
|
#line 13438 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1170:
|
|
#line 7737 "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 13448 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1171:
|
|
#line 7743 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_parallelworkshare();
|
|
opt_kwd_ = NO;
|
|
}
|
|
#line 13457 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1172:
|
|
#line 7749 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_endparallelworkshare();
|
|
}
|
|
#line 13465 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1173:
|
|
#line 7754 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = get_bfnd(fi,OMP_THREADPRIVATE_DIR, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL);
|
|
}
|
|
#line 13473 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1174:
|
|
#line 7759 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_master();
|
|
}
|
|
#line 13481 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1175:
|
|
#line 7764 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_endmaster();
|
|
}
|
|
#line 13489 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1176:
|
|
#line 7768 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_ordered();
|
|
}
|
|
#line 13497 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1177:
|
|
#line 7773 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_endordered();
|
|
}
|
|
#line 13505 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1178:
|
|
#line 7778 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = get_bfnd(fi,OMP_BARRIER_DIR,SMNULL,LLNULL,LLNULL,LLNULL);
|
|
}
|
|
#line 13513 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1179:
|
|
#line 7782 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = get_bfnd(fi,OMP_ATOMIC_DIR,SMNULL,LLNULL,LLNULL,LLNULL);
|
|
}
|
|
#line 13521 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1180:
|
|
#line 7787 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = get_bfnd(fi,OMP_FLUSH_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL);
|
|
}
|
|
#line 13529 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1181:
|
|
#line 7791 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = get_bfnd(fi,OMP_FLUSH_DIR,SMNULL,LLNULL,LLNULL,LLNULL);
|
|
}
|
|
#line 13537 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1182:
|
|
#line 7797 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_critical();
|
|
(yyval.bf_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);
|
|
}
|
|
#line 13546 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1183:
|
|
#line 7802 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_critical();
|
|
}
|
|
#line 13554 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1184:
|
|
#line 7808 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_endcritical();
|
|
(yyval.bf_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);
|
|
}
|
|
#line 13563 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1185:
|
|
#line 7813 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_endcritical();
|
|
}
|
|
#line 13571 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1186:
|
|
#line 7819 "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 13583 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1187:
|
|
#line 7829 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST);
|
|
}
|
|
#line 13591 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1188:
|
|
#line 7833 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST);
|
|
}
|
|
#line 13599 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1189:
|
|
#line 7837 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST);
|
|
}
|
|
#line 13607 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1190:
|
|
#line 7841 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST);
|
|
}
|
|
#line 13615 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1191:
|
|
#line 7846 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
operator_slash = 1;
|
|
}
|
|
#line 13623 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1192:
|
|
#line 7849 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
operator_slash = 0;
|
|
}
|
|
#line 13631 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1201:
|
|
#line 7865 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,ACC_REGION_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL);}
|
|
#line 13637 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1202:
|
|
#line 7869 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,ACC_CHECKSECTION_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
|
|
#line 13643 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1203:
|
|
#line 7873 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,ACC_GET_ACTUAL_DIR,SMNULL,(yyvsp[-1].ll_node),LLNULL,LLNULL);}
|
|
#line 13649 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1204:
|
|
#line 7875 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,ACC_GET_ACTUAL_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
|
|
#line 13655 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1205:
|
|
#line 7877 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,ACC_GET_ACTUAL_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
|
|
#line 13661 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1206:
|
|
#line 7881 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,ACC_ACTUAL_DIR,SMNULL,(yyvsp[-1].ll_node),LLNULL,LLNULL);}
|
|
#line 13667 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1207:
|
|
#line 7883 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,ACC_ACTUAL_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
|
|
#line 13673 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1208:
|
|
#line 7885 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,ACC_ACTUAL_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
|
|
#line 13679 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1209:
|
|
#line 7889 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL;}
|
|
#line 13685 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1210:
|
|
#line 7891 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 13691 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1211:
|
|
#line 7895 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 13697 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1212:
|
|
#line 7897 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 13703 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1213:
|
|
#line 7901 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 13709 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1214:
|
|
#line 7904 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 13715 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1215:
|
|
#line 7907 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 13721 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1216:
|
|
#line 7912 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,ACC_INOUT_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 13727 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1217:
|
|
#line 7914 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,ACC_IN_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 13733 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1218:
|
|
#line 7916 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,ACC_OUT_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 13739 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1219:
|
|
#line 7918 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,ACC_LOCAL_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 13745 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1220:
|
|
#line 7920 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,ACC_INLOCAL_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 13751 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1221:
|
|
#line 7924 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,ACC_TARGETS_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 13757 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1222:
|
|
#line 7928 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,ACC_ASYNC_OP,LLNULL,LLNULL,SMNULL);}
|
|
#line 13763 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1223:
|
|
#line 7933 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 13769 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1224:
|
|
#line 7937 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 13775 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1225:
|
|
#line 7939 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 13781 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1226:
|
|
#line 7943 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,ACC_HOST_OP, LLNULL,LLNULL,SMNULL);}
|
|
#line 13787 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1227:
|
|
#line 7945 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,ACC_CUDA_OP, LLNULL,LLNULL,SMNULL);}
|
|
#line 13793 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1228:
|
|
#line 7949 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,ACC_END_REGION_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
|
|
#line 13799 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1229:
|
|
#line 7953 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,ACC_END_CHECKSECTION_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
|
|
#line 13805 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1230:
|
|
#line 7957 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = get_bfnd(fi,ACC_DECLARE_DIR, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL);
|
|
}
|
|
#line 13813 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1231:
|
|
#line 7962 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL); }
|
|
#line 13819 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1232:
|
|
#line 7964 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); }
|
|
#line 13825 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1233:
|
|
#line 7968 "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 13837 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1234:
|
|
#line 7978 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,ACC_ROUTINE_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL);}
|
|
#line 13843 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1235:
|
|
#line 7982 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL;}
|
|
#line 13849 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1236:
|
|
#line 7984 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 13855 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1237:
|
|
#line 7988 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 13861 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1238:
|
|
#line 7990 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 13867 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1239:
|
|
#line 7994 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,ACC_PRIVATE_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 13873 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1240:
|
|
#line 7996 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 13879 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1247:
|
|
#line 8007 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,SPF_ANALYSIS_DIR,SMNULL,(yyvsp[-1].ll_node),LLNULL,LLNULL);}
|
|
#line 13885 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1248:
|
|
#line 8011 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,SPF_PARALLEL_DIR,SMNULL,(yyvsp[-1].ll_node),LLNULL,LLNULL);}
|
|
#line 13891 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1249:
|
|
#line 8015 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,SPF_TRANSFORM_DIR,SMNULL,(yyvsp[-1].ll_node),LLNULL,LLNULL);}
|
|
#line 13897 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1250:
|
|
#line 8019 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,SPF_PARALLEL_REG_DIR,(yyvsp[0].symbol),LLNULL,LLNULL,LLNULL);}
|
|
#line 13903 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1251:
|
|
#line 8021 "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 13909 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1252:
|
|
#line 8023 "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 13915 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1253:
|
|
#line 8027 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 13921 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1254:
|
|
#line 8029 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 13927 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1255:
|
|
#line 8033 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SPF_CODE_COVERAGE_OP,LLNULL,LLNULL,SMNULL);}
|
|
#line 13933 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1256:
|
|
#line 8035 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
PTR_LLND w;
|
|
w = make_llnd(fi,DOUBLE_VAL, LLNULL, LLNULL, SMNULL);
|
|
w->entry.string_val = copys(yytext);
|
|
w->type = global_double;
|
|
(yyval.ll_node) = make_llnd(fi,SPF_WEIGHT_OP,w,LLNULL,SMNULL);
|
|
}
|
|
#line 13945 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1257:
|
|
#line 8045 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL;}
|
|
#line 13951 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1258:
|
|
#line 8047 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[-1].ll_node);}
|
|
#line 13957 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1259:
|
|
#line 8051 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL;}
|
|
#line 13963 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1260:
|
|
#line 8053 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[-1].ll_node);}
|
|
#line 13969 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1261:
|
|
#line 8057 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,SPF_END_PARALLEL_REG_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
|
|
#line 13975 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1262:
|
|
#line 8061 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 13981 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1263:
|
|
#line 8063 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 13987 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1269:
|
|
#line 8074 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,REDUCTION_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL); }
|
|
#line 13993 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1270:
|
|
#line 8078 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,ACC_PRIVATE_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 13999 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1271:
|
|
#line 8082 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SPF_PROCESS_PRIVATE_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 14005 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1272:
|
|
#line 8086 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SPF_COVER_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 14011 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1273:
|
|
#line 8090 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SPF_PARAMETER_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 14017 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1274:
|
|
#line 8093 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); }
|
|
#line 14023 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1275:
|
|
#line 8095 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); }
|
|
#line 14029 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1276:
|
|
#line 8099 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi, ASSGN_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), SMNULL); }
|
|
#line 14035 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1277:
|
|
#line 8103 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 14041 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1278:
|
|
#line 8105 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 14047 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1282:
|
|
#line 8114 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SHADOW_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 14053 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1283:
|
|
#line 8118 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,ACROSS_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 14059 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1284:
|
|
#line 8122 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,REMOTE_ACCESS_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 14065 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1285:
|
|
#line 8126 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 14071 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1286:
|
|
#line 8128 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 14077 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1287:
|
|
#line 8132 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SPF_NOINLINE_OP,LLNULL,LLNULL,SMNULL);}
|
|
#line 14083 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1288:
|
|
#line 8134 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SPF_FISSION_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 14089 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1289:
|
|
#line 8136 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SPF_EXPAND_OP,LLNULL,LLNULL,SMNULL);}
|
|
#line 14095 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1290:
|
|
#line 8138 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SPF_EXPAND_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 14101 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1291:
|
|
#line 8141 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SPF_SHRINK_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 14107 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1292:
|
|
#line 8143 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SPF_UNROLL_OP,LLNULL,LLNULL,SMNULL);}
|
|
#line 14113 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1293:
|
|
#line 8145 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SPF_UNROLL_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 14119 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1294:
|
|
#line 8147 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SPF_MERGE_OP,LLNULL,LLNULL,SMNULL);}
|
|
#line 14125 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1295:
|
|
#line 8151 "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 14134 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1296:
|
|
#line 8158 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.symbol) = make_parallel_region((yyvsp[0].hash_entry));}
|
|
#line 14140 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1297:
|
|
#line 8162 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); }
|
|
#line 14146 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1298:
|
|
#line 8164 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); }
|
|
#line 14152 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1299:
|
|
#line 8168 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,SPF_CHECKPOINT_DIR,SMNULL,(yyvsp[-1].ll_node),LLNULL,LLNULL);}
|
|
#line 14158 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1300:
|
|
#line 8172 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 14164 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1301:
|
|
#line 8174 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 14170 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1302:
|
|
#line 8178 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SPF_TYPE_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 14176 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1303:
|
|
#line 8180 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SPF_VARLIST_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 14182 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1304:
|
|
#line 8182 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SPF_EXCEPT_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 14188 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1305:
|
|
#line 8184 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SPF_FILES_COUNT_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 14194 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1306:
|
|
#line 8186 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SPF_INTERVAL_OP,(yyvsp[-3].ll_node),(yyvsp[-1].ll_node),SMNULL);}
|
|
#line 14200 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1307:
|
|
#line 8190 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 14206 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1308:
|
|
#line 8192 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 14212 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1309:
|
|
#line 8196 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,ACC_ASYNC_OP, LLNULL,LLNULL,SMNULL);}
|
|
#line 14218 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1310:
|
|
#line 8198 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SPF_FLEXIBLE_OP, LLNULL,LLNULL,SMNULL);}
|
|
#line 14224 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1311:
|
|
#line 8202 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SPF_TIME_OP, LLNULL,LLNULL,SMNULL);}
|
|
#line 14230 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1312:
|
|
#line 8204 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SPF_ITER_OP, LLNULL,LLNULL,SMNULL);}
|
|
#line 14236 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1313:
|
|
#line 8208 "gram1.y" /* yacc.c:1646 */
|
|
{ if(position==IN_OUTSIDE)
|
|
err("Misplaced SPF-directive",103);
|
|
}
|
|
#line 14244 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
|
|
#line 14248 "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;
|
|
}
|