14519 lines
564 KiB
C
14519 lines
564 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 358 "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,
|
|
BINARY_OP = 359,
|
|
UNARY_OP = 360
|
|
};
|
|
#endif
|
|
|
|
/* Value type. */
|
|
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
|
|
|
|
union YYSTYPE
|
|
{
|
|
#line 439 "gram1.y" /* yacc.c:355 */
|
|
|
|
int token;
|
|
char charv;
|
|
char *charp;
|
|
PTR_BFND bf_node;
|
|
PTR_LLND ll_node;
|
|
PTR_SYMB symbol;
|
|
PTR_TYPE data_type;
|
|
PTR_HASH hash_entry;
|
|
PTR_LABEL label;
|
|
|
|
#line 560 "gram1.tab.c" /* yacc.c:355 */
|
|
};
|
|
|
|
typedef union YYSTYPE YYSTYPE;
|
|
# define YYSTYPE_IS_TRIVIAL 1
|
|
# define YYSTYPE_IS_DECLARED 1
|
|
#endif
|
|
|
|
|
|
extern YYSTYPE yylval;
|
|
|
|
int yyparse (void);
|
|
|
|
#endif /* !YY_YY_GRAM1_TAB_H_INCLUDED */
|
|
|
|
/* Copy the second part of user declarations. */
|
|
#line 649 "gram1.y" /* yacc.c:358 */
|
|
|
|
void add_scope_level();
|
|
void delete_beyond_scope_level();
|
|
PTR_HASH look_up_sym();
|
|
PTR_HASH just_look_up_sym();
|
|
PTR_HASH just_look_up_sym_in_scope();
|
|
PTR_HASH look_up_op();
|
|
PTR_SYMB make_constant();
|
|
PTR_SYMB make_scalar();
|
|
PTR_SYMB make_array();
|
|
PTR_SYMB make_pointer();
|
|
PTR_SYMB make_function();
|
|
PTR_SYMB make_external();
|
|
PTR_SYMB make_intrinsic();
|
|
PTR_SYMB make_procedure();
|
|
PTR_SYMB make_process();
|
|
PTR_SYMB make_program();
|
|
PTR_SYMB make_module();
|
|
PTR_SYMB make_common();
|
|
PTR_SYMB make_parallel_region();
|
|
PTR_SYMB make_derived_type();
|
|
PTR_SYMB make_local_entity();
|
|
PTR_SYMB make_global_entity();
|
|
PTR_TYPE make_type_node();
|
|
PTR_TYPE lookup_type(), make_type();
|
|
void process_type();
|
|
void process_interface();
|
|
void bind();
|
|
void late_bind_if_needed();
|
|
PTR_SYMB component();
|
|
PTR_SYMB lookup_type_symbol();
|
|
PTR_SYMB resolve_overloading();
|
|
PTR_BFND cur_scope();
|
|
PTR_BFND subroutine_call();
|
|
PTR_BFND process_call();
|
|
PTR_LLND deal_with_options();
|
|
PTR_LLND intrinsic_op_node();
|
|
PTR_LLND defined_op_node();
|
|
int is_substring_ref();
|
|
int is_array_section_ref();
|
|
PTR_LLND dim_expr();
|
|
PTR_BFND exit_stat();
|
|
PTR_BFND make_do();
|
|
PTR_BFND make_pardo();
|
|
PTR_BFND make_enddoall();
|
|
PTR_TYPE install_array();
|
|
PTR_SYMB install_entry();
|
|
void install_param_list();
|
|
PTR_LLND construct_entry_list();
|
|
void copy_sym_data();
|
|
PTR_LLND check_and_install();
|
|
PTR_HASH look_up();
|
|
PTR_BFND get_bfnd();
|
|
PTR_BLOB make_blob();
|
|
PTR_LABEL make_label();
|
|
PTR_LABEL make_label_node();
|
|
int is_interface_stat();
|
|
PTR_LLND make_llnd ();
|
|
PTR_LLND make_llnd_label ();
|
|
PTR_TYPE make_sa_type();
|
|
PTR_SYMB procedure_call();
|
|
PTR_BFND proc_list();
|
|
PTR_SYMB set_id_list();
|
|
PTR_LLND set_ll_list();
|
|
PTR_LLND add_to_lowLevelList(), add_to_lowList();
|
|
PTR_BFND set_stat_list() ;
|
|
PTR_BLOB follow_blob();
|
|
PTR_SYMB proc_decl_init();
|
|
PTR_CMNT make_comment();
|
|
PTR_HASH correct_symtab();
|
|
char *copyn();
|
|
char *convic();
|
|
char *StringConcatenation();
|
|
int atoi();
|
|
PTR_BFND make_logif();
|
|
PTR_BFND make_if();
|
|
PTR_BFND make_forall();
|
|
void startproc();
|
|
void match_parameters();
|
|
void make_else();
|
|
void make_elseif();
|
|
void make_endif();
|
|
void make_elsewhere();
|
|
void make_elsewhere_mask();
|
|
void make_endwhere();
|
|
void make_endforall();
|
|
void make_endselect();
|
|
void make_extend();
|
|
void make_endextend();
|
|
void make_section();
|
|
void make_section_extend();
|
|
void doinclude();
|
|
void endproc();
|
|
void err();
|
|
void execerr();
|
|
void flline();
|
|
void warn();
|
|
void warn1();
|
|
void newprog();
|
|
void set_type();
|
|
void dclerr();
|
|
void enddcl();
|
|
void install_const();
|
|
void setimpl();
|
|
void copy_module_scope();
|
|
void delete_symbol();
|
|
void replace_symbol_in_expr();
|
|
long convci();
|
|
void set_expr_type();
|
|
void errstr();
|
|
void yyerror();
|
|
void set_blobs();
|
|
void make_loop();
|
|
void startioctl();
|
|
void endioctl();
|
|
void redefine_func_arg_type();
|
|
int isResultVar();
|
|
int yylex();
|
|
|
|
/* used by FORTRAN M */
|
|
PTR_BFND make_processdo();
|
|
PTR_BFND make_processes();
|
|
PTR_BFND make_endprocesses();
|
|
|
|
PTR_BFND make_endparallel();/*OMP*/
|
|
PTR_BFND make_parallel();/*OMP*/
|
|
PTR_BFND make_endsingle();/*OMP*/
|
|
PTR_BFND make_single();/*OMP*/
|
|
PTR_BFND make_endmaster();/*OMP*/
|
|
PTR_BFND make_master();/*OMP*/
|
|
PTR_BFND make_endordered();/*OMP*/
|
|
PTR_BFND make_ordered();/*OMP*/
|
|
PTR_BFND make_endcritical();/*OMP*/
|
|
PTR_BFND make_critical();/*OMP*/
|
|
PTR_BFND make_endsections();/*OMP*/
|
|
PTR_BFND make_sections();/*OMP*/
|
|
PTR_BFND make_ompsection();/*OMP*/
|
|
PTR_BFND make_endparallelsections();/*OMP*/
|
|
PTR_BFND make_parallelsections();/*OMP*/
|
|
PTR_BFND make_endworkshare();/*OMP*/
|
|
PTR_BFND make_workshare();/*OMP*/
|
|
PTR_BFND make_endparallelworkshare();/*OMP*/
|
|
PTR_BFND make_parallelworkshare();/*OMP*/
|
|
|
|
|
|
#line 722 "gram1.tab.c" /* yacc.c:358 */
|
|
|
|
#ifdef short
|
|
# undef short
|
|
#endif
|
|
|
|
#ifdef YYTYPE_UINT8
|
|
typedef YYTYPE_UINT8 yytype_uint8;
|
|
#else
|
|
typedef unsigned char yytype_uint8;
|
|
#endif
|
|
|
|
#ifdef YYTYPE_INT8
|
|
typedef YYTYPE_INT8 yytype_int8;
|
|
#else
|
|
typedef signed char yytype_int8;
|
|
#endif
|
|
|
|
#ifdef YYTYPE_UINT16
|
|
typedef YYTYPE_UINT16 yytype_uint16;
|
|
#else
|
|
typedef unsigned short int yytype_uint16;
|
|
#endif
|
|
|
|
#ifdef YYTYPE_INT16
|
|
typedef YYTYPE_INT16 yytype_int16;
|
|
#else
|
|
typedef short int yytype_int16;
|
|
#endif
|
|
|
|
#ifndef YYSIZE_T
|
|
# ifdef __SIZE_TYPE__
|
|
# define YYSIZE_T __SIZE_TYPE__
|
|
# elif defined size_t
|
|
# define YYSIZE_T size_t
|
|
# elif ! defined YYSIZE_T
|
|
# include <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 5948
|
|
|
|
/* YYNTOKENS -- Number of terminals. */
|
|
#define YYNTOKENS 361
|
|
/* YYNNTS -- Number of nonterminals. */
|
|
#define YYNNTS 547
|
|
/* YYNRULES -- Number of rules. */
|
|
#define YYNRULES 1312
|
|
/* YYNSTATES -- Number of states. */
|
|
#define YYNSTATES 2613
|
|
|
|
/* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
|
|
by yylex, with out-of-bounds checking. */
|
|
#define YYUNDEFTOK 2
|
|
#define YYMAXUTOK 360
|
|
|
|
#define YYTRANSLATE(YYX) \
|
|
((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
|
|
|
|
/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
|
|
as returned by yylex, without out-of-bounds checking. */
|
|
static const yytype_uint16 yytranslate[] =
|
|
{
|
|
0, 3, 4, 5, 6, 7, 8, 9, 10, 11,
|
|
12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
|
|
22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
|
|
32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
|
|
42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
|
|
52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
|
|
62, 63, 64, 65, 66, 67, 68, 69, 70, 71,
|
|
72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
|
|
82, 83, 84, 85, 86, 87, 88, 89, 90, 91,
|
|
92, 93, 94, 95, 96, 97, 98, 99, 100, 101,
|
|
102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
|
|
112, 113, 114, 115, 116, 117, 118, 119, 120, 121,
|
|
122, 123, 124, 125, 126, 127, 128, 129, 130, 131,
|
|
132, 133, 134, 135, 136, 137, 138, 139, 140, 141,
|
|
142, 143, 144, 145, 146, 147, 148, 149, 150, 151,
|
|
152, 153, 154, 155, 156, 157, 158, 159, 160, 161,
|
|
162, 163, 164, 165, 166, 167, 168, 169, 170, 171,
|
|
172, 173, 174, 175, 176, 177, 178, 179, 180, 181,
|
|
182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
|
|
192, 193, 194, 195, 196, 197, 198, 199, 200, 201,
|
|
202, 203, 204, 205, 206, 207, 208, 209, 210, 211,
|
|
212, 213, 214, 215, 216, 217, 218, 219, 220, 221,
|
|
222, 223, 224, 225, 226, 227, 228, 229, 230, 231,
|
|
232, 233, 234, 235, 236, 237, 238, 239, 240, 241,
|
|
242, 243, 244, 245, 246, 247, 248, 249, 250, 251,
|
|
252, 253, 254, 255, 256, 257, 258, 259, 260, 261,
|
|
262, 263, 264, 265, 266, 267, 268, 269, 270, 271,
|
|
272, 273, 274, 275, 276, 277, 278, 279, 280, 281,
|
|
282, 283, 284, 285, 286, 287, 288, 289, 290, 291,
|
|
292, 293, 294, 295, 296, 297, 298, 299, 300, 301,
|
|
302, 303, 304, 305, 306, 307, 308, 309, 310, 311,
|
|
312, 313, 314, 315, 316, 317, 318, 319, 320, 321,
|
|
322, 323, 324, 325, 326, 327, 328, 329, 330, 331,
|
|
332, 333, 334, 335, 336, 337, 338, 339, 340, 341,
|
|
342, 343, 344, 345, 346, 347, 348, 349, 350, 351,
|
|
352, 353, 354, 355, 356, 357, 358, 1, 2, 359,
|
|
360
|
|
};
|
|
|
|
#if YYDEBUG
|
|
/* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
|
|
static const yytype_uint16 yyrline[] =
|
|
{
|
|
0, 796, 796, 797, 801, 803, 817, 848, 857, 863,
|
|
883, 892, 908, 920, 930, 937, 943, 948, 953, 977,
|
|
1004, 1018, 1020, 1022, 1026, 1043, 1057, 1081, 1097, 1111,
|
|
1129, 1131, 1138, 1142, 1143, 1150, 1151, 1159, 1160, 1162,
|
|
1166, 1167, 1171, 1175, 1181, 1191, 1195, 1200, 1207, 1208,
|
|
1209, 1210, 1211, 1212, 1213, 1214, 1215, 1216, 1217, 1218,
|
|
1219, 1220, 1221, 1226, 1231, 1238, 1240, 1241, 1242, 1243,
|
|
1244, 1245, 1246, 1247, 1248, 1249, 1250, 1251, 1254, 1258,
|
|
1266, 1274, 1283, 1291, 1295, 1297, 1301, 1303, 1305, 1307,
|
|
1309, 1311, 1313, 1315, 1317, 1319, 1321, 1323, 1325, 1327,
|
|
1329, 1331, 1333, 1335, 1340, 1349, 1359, 1367, 1377, 1398,
|
|
1418, 1419, 1421, 1425, 1427, 1431, 1435, 1437, 1441, 1447,
|
|
1451, 1453, 1457, 1461, 1465, 1469, 1473, 1479, 1483, 1487,
|
|
1493, 1498, 1505, 1516, 1529, 1540, 1553, 1563, 1576, 1581,
|
|
1588, 1591, 1596, 1601, 1608, 1611, 1621, 1635, 1638, 1657,
|
|
1684, 1686, 1698, 1706, 1707, 1708, 1709, 1710, 1711, 1712,
|
|
1717, 1718, 1722, 1724, 1731, 1736, 1737, 1739, 1741, 1754,
|
|
1760, 1766, 1775, 1784, 1797, 1798, 1801, 1805, 1820, 1835,
|
|
1853, 1874, 1894, 1916, 1933, 1951, 1958, 1965, 1972, 1985,
|
|
1992, 1999, 2010, 2014, 2016, 2021, 2039, 2050, 2062, 2074,
|
|
2088, 2094, 2101, 2107, 2113, 2121, 2128, 2144, 2147, 2156,
|
|
2158, 2162, 2166, 2186, 2190, 2192, 2196, 2197, 2200, 2202,
|
|
2204, 2206, 2208, 2211, 2214, 2218, 2224, 2228, 2232, 2234,
|
|
2239, 2240, 2244, 2248, 2250, 2254, 2256, 2258, 2263, 2267,
|
|
2269, 2271, 2274, 2276, 2277, 2278, 2279, 2280, 2281, 2282,
|
|
2283, 2286, 2287, 2293, 2296, 2297, 2299, 2303, 2304, 2307,
|
|
2308, 2310, 2314, 2315, 2316, 2317, 2319, 2322, 2323, 2332,
|
|
2334, 2341, 2348, 2355, 2364, 2366, 2368, 2372, 2374, 2378,
|
|
2387, 2394, 2401, 2403, 2407, 2411, 2417, 2419, 2424, 2428,
|
|
2432, 2439, 2446, 2456, 2458, 2462, 2474, 2477, 2486, 2499,
|
|
2505, 2511, 2517, 2525, 2535, 2537, 2541, 2543, 2576, 2578,
|
|
2582, 2621, 2622, 2626, 2626, 2631, 2635, 2643, 2652, 2661,
|
|
2671, 2677, 2680, 2682, 2686, 2694, 2709, 2716, 2718, 2722,
|
|
2738, 2738, 2742, 2744, 2756, 2758, 2762, 2768, 2780, 2792,
|
|
2809, 2838, 2839, 2847, 2848, 2852, 2854, 2856, 2867, 2871,
|
|
2877, 2879, 2883, 2885, 2887, 2891, 2893, 2897, 2899, 2901,
|
|
2903, 2905, 2907, 2909, 2911, 2913, 2915, 2917, 2919, 2921,
|
|
2923, 2925, 2927, 2929, 2931, 2933, 2935, 2937, 2939, 2941,
|
|
2945, 2946, 2957, 3031, 3043, 3045, 3049, 3180, 3230, 3274,
|
|
3316, 3374, 3376, 3378, 3417, 3460, 3471, 3472, 3476, 3481,
|
|
3482, 3486, 3488, 3494, 3496, 3502, 3515, 3521, 3528, 3534,
|
|
3542, 3550, 3566, 3576, 3589, 3596, 3598, 3621, 3623, 3625,
|
|
3627, 3629, 3631, 3633, 3635, 3639, 3639, 3639, 3653, 3655,
|
|
3678, 3680, 3682, 3698, 3700, 3702, 3716, 3719, 3721, 3729,
|
|
3731, 3733, 3735, 3789, 3809, 3824, 3833, 3836, 3886, 3892,
|
|
3897, 3915, 3917, 3919, 3921, 3923, 3926, 3932, 3934, 3936,
|
|
3939, 3941, 3943, 3970, 3979, 3988, 3989, 3991, 3996, 4003,
|
|
4011, 4013, 4017, 4020, 4022, 4026, 4032, 4034, 4036, 4038,
|
|
4042, 4044, 4053, 4054, 4061, 4062, 4066, 4070, 4091, 4094,
|
|
4098, 4100, 4107, 4112, 4113, 4124, 4136, 4159, 4184, 4185,
|
|
4192, 4194, 4196, 4198, 4200, 4204, 4281, 4293, 4300, 4302,
|
|
4303, 4305, 4314, 4321, 4328, 4336, 4341, 4346, 4349, 4352,
|
|
4355, 4358, 4361, 4365, 4383, 4388, 4407, 4426, 4430, 4431,
|
|
4434, 4438, 4443, 4450, 4452, 4454, 4458, 4459, 4470, 4485,
|
|
4489, 4496, 4499, 4509, 4522, 4535, 4538, 4540, 4543, 4546,
|
|
4550, 4559, 4562, 4566, 4568, 4574, 4578, 4580, 4582, 4589,
|
|
4593, 4595, 4599, 4601, 4605, 4624, 4640, 4649, 4658, 4660,
|
|
4664, 4690, 4705, 4720, 4737, 4745, 4754, 4762, 4767, 4772,
|
|
4794, 4810, 4812, 4816, 4818, 4825, 4827, 4829, 4833, 4835,
|
|
4837, 4839, 4841, 4843, 4847, 4850, 4853, 4859, 4865, 4874,
|
|
4878, 4885, 4887, 4891, 4893, 4895, 4900, 4905, 4910, 4915,
|
|
4924, 4929, 4935, 4936, 4951, 4952, 4953, 4954, 4955, 4956,
|
|
4957, 4958, 4959, 4960, 4961, 4962, 4963, 4964, 4965, 4966,
|
|
4967, 4968, 4969, 4972, 4973, 4974, 4975, 4976, 4977, 4978,
|
|
4979, 4980, 4981, 4982, 4983, 4984, 4985, 4986, 4987, 4988,
|
|
4989, 4990, 4991, 4992, 4993, 4994, 4995, 4996, 4997, 4998,
|
|
4999, 5000, 5001, 5002, 5003, 5004, 5005, 5006, 5007, 5008,
|
|
5009, 5010, 5011, 5012, 5013, 5014, 5015, 5019, 5021, 5032,
|
|
5053, 5057, 5059, 5063, 5076, 5080, 5082, 5086, 5097, 5108,
|
|
5112, 5114, 5118, 5120, 5122, 5137, 5149, 5169, 5189, 5211,
|
|
5217, 5226, 5234, 5240, 5248, 5255, 5261, 5270, 5274, 5280,
|
|
5288, 5302, 5316, 5321, 5337, 5352, 5380, 5382, 5386, 5388,
|
|
5392, 5421, 5444, 5465, 5466, 5470, 5491, 5493, 5497, 5505,
|
|
5509, 5514, 5516, 5518, 5520, 5526, 5528, 5532, 5542, 5546,
|
|
5548, 5553, 5555, 5559, 5563, 5569, 5579, 5581, 5585, 5587,
|
|
5589, 5596, 5614, 5615, 5619, 5621, 5625, 5632, 5642, 5671,
|
|
5686, 5693, 5711, 5713, 5717, 5731, 5757, 5770, 5786, 5788,
|
|
5791, 5793, 5799, 5803, 5831, 5833, 5837, 5845, 5851, 5854,
|
|
5912, 5976, 5978, 5981, 5985, 5989, 5993, 6010, 6022, 6026,
|
|
6030, 6040, 6045, 6050, 6057, 6066, 6066, 6077, 6088, 6090,
|
|
6094, 6105, 6109, 6111, 6115, 6126, 6130, 6132, 6136, 6148,
|
|
6150, 6157, 6159, 6163, 6179, 6187, 6198, 6200, 6204, 6207,
|
|
6212, 6222, 6224, 6228, 6230, 6239, 6240, 6244, 6246, 6251,
|
|
6252, 6253, 6254, 6255, 6256, 6257, 6258, 6259, 6260, 6261,
|
|
6264, 6269, 6273, 6277, 6281, 6294, 6298, 6302, 6306, 6309,
|
|
6311, 6313, 6317, 6319, 6323, 6327, 6329, 6333, 6338, 6342,
|
|
6346, 6348, 6352, 6361, 6364, 6370, 6377, 6380, 6382, 6386,
|
|
6388, 6392, 6404, 6406, 6410, 6414, 6416, 6420, 6422, 6424,
|
|
6426, 6428, 6430, 6432, 6436, 6440, 6444, 6448, 6452, 6459,
|
|
6465, 6470, 6473, 6476, 6489, 6491, 6495, 6497, 6502, 6508,
|
|
6514, 6520, 6526, 6532, 6538, 6544, 6550, 6559, 6565, 6582,
|
|
6584, 6592, 6600, 6602, 6606, 6610, 6612, 6616, 6618, 6626,
|
|
6630, 6642, 6645, 6663, 6665, 6669, 6671, 6675, 6677, 6681,
|
|
6685, 6689, 6698, 6702, 6706, 6711, 6715, 6727, 6729, 6733,
|
|
6738, 6742, 6744, 6748, 6750, 6754, 6759, 6766, 6789, 6791,
|
|
6793, 6795, 6797, 6801, 6812, 6816, 6831, 6838, 6845, 6846,
|
|
6850, 6854, 6862, 6866, 6870, 6878, 6883, 6897, 6899, 6903,
|
|
6905, 6914, 6916, 6918, 6920, 6956, 6960, 6964, 6968, 6972,
|
|
6984, 6986, 6990, 6993, 6995, 6999, 7004, 7011, 7014, 7022,
|
|
7026, 7031, 7033, 7040, 7045, 7049, 7053, 7057, 7061, 7065,
|
|
7068, 7070, 7074, 7076, 7078, 7082, 7086, 7098, 7100, 7104,
|
|
7106, 7110, 7113, 7116, 7120, 7126, 7138, 7140, 7144, 7146,
|
|
7150, 7158, 7170, 7171, 7173, 7177, 7181, 7183, 7191, 7195,
|
|
7198, 7200, 7204, 7208, 7210, 7211, 7212, 7213, 7214, 7215,
|
|
7216, 7217, 7218, 7219, 7220, 7221, 7222, 7223, 7224, 7225,
|
|
7226, 7227, 7228, 7229, 7230, 7231, 7232, 7233, 7234, 7235,
|
|
7238, 7244, 7250, 7256, 7262, 7266, 7272, 7273, 7274, 7275,
|
|
7276, 7277, 7278, 7279, 7280, 7283, 7288, 7293, 7299, 7305,
|
|
7311, 7316, 7322, 7328, 7334, 7341, 7347, 7353, 7360, 7364,
|
|
7366, 7372, 7379, 7385, 7391, 7397, 7403, 7409, 7415, 7421,
|
|
7427, 7433, 7439, 7445, 7455, 7460, 7466, 7470, 7476, 7477,
|
|
7478, 7479, 7482, 7490, 7496, 7502, 7507, 7513, 7520, 7526,
|
|
7530, 7536, 7537, 7538, 7539, 7540, 7541, 7544, 7553, 7557,
|
|
7563, 7570, 7577, 7584, 7593, 7599, 7605, 7609, 7615, 7616,
|
|
7619, 7625, 7631, 7635, 7642, 7643, 7646, 7652, 7658, 7663,
|
|
7671, 7677, 7682, 7689, 7693, 7699, 7700, 7701, 7702, 7703,
|
|
7704, 7705, 7706, 7707, 7708, 7709, 7713, 7718, 7723, 7730,
|
|
7735, 7741, 7747, 7752, 7757, 7762, 7766, 7771, 7776, 7780,
|
|
7785, 7789, 7795, 7800, 7806, 7811, 7817, 7827, 7831, 7835,
|
|
7839, 7845, 7848, 7852, 7853, 7855, 7856, 7857, 7858, 7859,
|
|
7860, 7863, 7867, 7871, 7873, 7875, 7879, 7881, 7883, 7887,
|
|
7889, 7893, 7895, 7899, 7902, 7905, 7910, 7912, 7914, 7916,
|
|
7918, 7922, 7926, 7931, 7935, 7937, 7941, 7943, 7947, 7951,
|
|
7955, 7960, 7962, 7966, 7976, 7981, 7982, 7986, 7988, 7992,
|
|
7994, 7997, 7998, 7999, 8000, 8001, 8002, 8005, 8009, 8013,
|
|
8017, 8019, 8021, 8025, 8027, 8031, 8036, 8037, 8042, 8043,
|
|
8047, 8051, 8053, 8057, 8058, 8059, 8060, 8061, 8064, 8068,
|
|
8072, 8076, 8080, 8083, 8085, 8089, 8093, 8095, 8099, 8100,
|
|
8101, 8104, 8108, 8112, 8116, 8118, 8122, 8124, 8126, 8128,
|
|
8131, 8133, 8135, 8137, 8141, 8148, 8152, 8154, 8158, 8162,
|
|
8164, 8168, 8170, 8172, 8174, 8176, 8180, 8182, 8186, 8188,
|
|
8192, 8194, 8199
|
|
};
|
|
#endif
|
|
|
|
#if YYDEBUG || YYERROR_VERBOSE || 0
|
|
/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
|
|
First, the terminals, then, starting at YYNTOKENS, nonterminals. */
|
|
static const char *const yytname[] =
|
|
{
|
|
"$end", "error", "$undefined", "PERCENT", "AMPERSAND", "ASTER",
|
|
"CLUSTER", "COLON", "COMMA", "DASTER", "DEFINED_OPERATOR", "DOT",
|
|
"DQUOTE", "GLOBAL_A", "LEFTAB", "LEFTPAR", "MINUS", "PLUS", "POINT_TO",
|
|
"QUOTE", "RIGHTAB", "RIGHTPAR", "AND", "DSLASH", "EQV", "EQ", "EQUAL",
|
|
"FFALSE", "GE", "GT", "LE", "LT", "NE", "NEQV", "NOT", "OR", "TTRUE",
|
|
"SLASH", "XOR", "REFERENCE", "AT", "ACROSS", "ALIGN_WITH", "ALIGN",
|
|
"ALLOCATABLE", "ALLOCATE", "ARITHIF", "ASSIGNMENT", "ASSIGN",
|
|
"ASSIGNGOTO", "ASYNCHRONOUS", "ASYNCID", "ASYNCWAIT", "BACKSPACE",
|
|
"BAD_CCONST", "BAD_SYMBOL", "BARRIER", "BLOCKDATA", "BLOCK",
|
|
"BOZ_CONSTANT", "BYTE", "CALL", "CASE", "CHARACTER", "CHAR_CONSTANT",
|
|
"CHECK", "CLOSE", "COMMON", "COMPLEX", "COMPGOTO", "CONSISTENT_GROUP",
|
|
"CONSISTENT_SPEC", "CONSISTENT_START", "CONSISTENT_WAIT", "CONSISTENT",
|
|
"CONSTRUCT_ID", "CONTAINS", "CONTINUE", "CORNER", "CYCLE", "DATA",
|
|
"DEALLOCATE", "HPF_TEMPLATE", "DEBUG", "DEFAULT_CASE", "DEFINE",
|
|
"DERIVED", "DIMENSION", "DISTRIBUTE", "DOWHILE", "DOUBLEPRECISION",
|
|
"DOUBLECOMPLEX", "DP_CONSTANT", "DVM_POINTER", "DYNAMIC", "ELEMENTAL",
|
|
"ELSE", "ELSEIF", "ELSEWHERE", "ENDASYNCHRONOUS", "ENDDEBUG",
|
|
"ENDINTERVAL", "ENDUNIT", "ENDDO", "ENDFILE", "ENDFORALL", "ENDIF",
|
|
"ENDINTERFACE", "ENDMODULE", "ENDON", "ENDSELECT", "ENDTASK_REGION",
|
|
"ENDTYPE", "ENDWHERE", "ENTRY", "EXIT", "EOLN", "EQUIVALENCE", "ERROR",
|
|
"EXTERNAL", "F90", "FIND", "FORALL", "FORMAT", "FUNCTION", "GATE",
|
|
"GEN_BLOCK", "HEAP", "HIGH", "IDENTIFIER", "IMPLICIT", "IMPLICITNONE",
|
|
"INCLUDE_TO", "INCLUDE", "INDEPENDENT", "INDIRECT_ACCESS",
|
|
"INDIRECT_GROUP", "INDIRECT", "INHERIT", "INQUIRE",
|
|
"INTERFACEASSIGNMENT", "INTERFACEOPERATOR", "INTERFACE", "INTRINSIC",
|
|
"INTEGER", "INTENT", "INTERVAL", "INOUT", "IN", "INT_CONSTANT", "LABEL",
|
|
"LABEL_DECLARE", "LET", "LOCALIZE", "LOGICAL", "LOGICALIF", "LOOP",
|
|
"LOW", "MAXLOC", "MAX", "MAP", "MINLOC", "MIN", "MODULE_PROCEDURE",
|
|
"MODULE", "MULT_BLOCK", "NAMEEQ", "NAMELIST", "NEW_VALUE", "NEW",
|
|
"NULLIFY", "OCTAL_CONSTANT", "ONLY", "ON", "ON_DIR", "ONTO", "OPEN",
|
|
"OPERATOR", "OPTIONAL", "OTHERWISE", "OUT", "OWN", "PARALLEL",
|
|
"PARAMETER", "PAUSE", "PLAINDO", "PLAINGOTO", "POINTER", "POINTERLET",
|
|
"PREFETCH", "PRINT", "PRIVATE", "PRODUCT", "PROGRAM", "PUBLIC", "PURE",
|
|
"RANGE", "READ", "REALIGN_WITH", "REALIGN", "REAL", "REAL_CONSTANT",
|
|
"RECURSIVE", "REDISTRIBUTE_NEW", "REDISTRIBUTE", "REDUCTION_GROUP",
|
|
"REDUCTION_START", "REDUCTION_WAIT", "REDUCTION", "REMOTE_ACCESS_SPEC",
|
|
"REMOTE_ACCESS", "REMOTE_GROUP", "RESET", "RESULT", "RETURN", "REWIND",
|
|
"SAVE", "SECTION", "SELECT", "SEQUENCE", "SHADOW_ADD", "SHADOW_COMPUTE",
|
|
"SHADOW_GROUP", "SHADOW_RENEW", "SHADOW_START_SPEC", "SHADOW_START",
|
|
"SHADOW_WAIT_SPEC", "SHADOW_WAIT", "SHADOW", "STAGE", "STATIC", "STAT",
|
|
"STOP", "SUBROUTINE", "SUM", "SYNC", "TARGET", "TASK", "TASK_REGION",
|
|
"THEN", "TO", "TRACEON", "TRACEOFF", "TRUNC", "TYPE", "TYPE_DECL",
|
|
"UNDER", "UNKNOWN", "USE", "VIRTUAL", "VARIABLE", "WAIT", "WHERE",
|
|
"WHERE_ASSIGN", "WHILE", "WITH", "WRITE", "COMMENT", "WGT_BLOCK",
|
|
"HPF_PROCESSORS", "IOSTAT", "ERR", "END", "OMPDVM_ATOMIC",
|
|
"OMPDVM_BARRIER", "OMPDVM_COPYIN", "OMPDVM_COPYPRIVATE",
|
|
"OMPDVM_CRITICAL", "OMPDVM_ONETHREAD", "OMPDVM_DO", "OMPDVM_DYNAMIC",
|
|
"OMPDVM_ENDCRITICAL", "OMPDVM_ENDDO", "OMPDVM_ENDMASTER",
|
|
"OMPDVM_ENDORDERED", "OMPDVM_ENDPARALLEL", "OMPDVM_ENDPARALLELDO",
|
|
"OMPDVM_ENDPARALLELSECTIONS", "OMPDVM_ENDPARALLELWORKSHARE",
|
|
"OMPDVM_ENDSECTIONS", "OMPDVM_ENDSINGLE", "OMPDVM_ENDWORKSHARE",
|
|
"OMPDVM_FIRSTPRIVATE", "OMPDVM_FLUSH", "OMPDVM_GUIDED",
|
|
"OMPDVM_LASTPRIVATE", "OMPDVM_MASTER", "OMPDVM_NOWAIT", "OMPDVM_NONE",
|
|
"OMPDVM_NUM_THREADS", "OMPDVM_ORDERED", "OMPDVM_PARALLEL",
|
|
"OMPDVM_PARALLELDO", "OMPDVM_PARALLELSECTIONS",
|
|
"OMPDVM_PARALLELWORKSHARE", "OMPDVM_RUNTIME", "OMPDVM_SECTION",
|
|
"OMPDVM_SECTIONS", "OMPDVM_SCHEDULE", "OMPDVM_SHARED", "OMPDVM_SINGLE",
|
|
"OMPDVM_THREADPRIVATE", "OMPDVM_WORKSHARE", "OMPDVM_NODES", "OMPDVM_IF",
|
|
"IAND", "IEOR", "IOR", "ACC_REGION", "ACC_END_REGION",
|
|
"ACC_CHECKSECTION", "ACC_END_CHECKSECTION", "ACC_GET_ACTUAL",
|
|
"ACC_ACTUAL", "ACC_TARGETS", "ACC_ASYNC", "ACC_HOST", "ACC_CUDA",
|
|
"ACC_LOCAL", "ACC_INLOCAL", "ACC_CUDA_BLOCK", "ACC_ROUTINE", "ACC_TIE",
|
|
"ACC_DECLARE", "BY", "IO_MODE", "CP_CREATE", "CP_LOAD", "CP_SAVE",
|
|
"CP_WAIT", "FILES", "VARLIST", "STATUS", "EXITINTERVAL",
|
|
"TEMPLATE_CREATE", "TEMPLATE_DELETE", "SPF_ANALYSIS", "SPF_PARALLEL",
|
|
"SPF_TRANSFORM", "SPF_NOINLINE", "SPF_PARALLEL_REG",
|
|
"SPF_END_PARALLEL_REG", "SPF_EXPAND", "SPF_FISSION", "SPF_SHRINK",
|
|
"SPF_CHECKPOINT", "SPF_EXCEPT", "SPF_FILES_COUNT", "SPF_INTERVAL",
|
|
"SPF_TIME", "SPF_ITER", "SPF_FLEXIBLE", "SPF_APPLY_REGION",
|
|
"SPF_APPLY_FRAGMENT", "SPF_CODE_COVERAGE", "SPF_UNROLL", "SPF_MERGE",
|
|
"SPF_COVER", "SPF_PROCESS_PRIVATE", "BINARY_OP", "UNARY_OP", "$accept",
|
|
"program", "stat", "thislabel", "entry", "new_prog", "proc_attr",
|
|
"procname", "funcname", "typedfunc", "opt_result_clause", "name",
|
|
"progname", "blokname", "arglist", "args", "arg", "filename",
|
|
"needkeyword", "keywordoff", "keyword_if_colon_follow", "spec",
|
|
"interface", "defined_op", "operator", "intrinsic_op", "type_dcl",
|
|
"end_type", "dcl", "options", "attr_spec_list", "attr_spec",
|
|
"intent_spec", "access_spec", "intent", "optional", "static", "private",
|
|
"private_attr", "sequence", "public", "public_attr", "type",
|
|
"opt_key_hedr", "attrib", "att_type", "typespec", "typename", "lengspec",
|
|
"proper_lengspec", "selector", "clause", "end_ioctl", "initial_value",
|
|
"dimension", "allocatable", "pointer", "target", "common", "namelist",
|
|
"namelist_group", "comblock", "var", "external", "intrinsic",
|
|
"equivalence", "equivset", "equivlist", "equi_object", "data", "data1",
|
|
"data_in", "in_data", "datapair", "datalvals", "datarvals", "datalval",
|
|
"data_null", "d_name", "dataname", "datasubs", "datarange",
|
|
"iconexprlist", "opticonexpr", "dataimplieddo", "dlist", "dataelt",
|
|
"datarval", "datavalue", "BOZ_const", "int_const", "unsignedint",
|
|
"real_const", "unsignedreal", "complex_const_data", "complex_part",
|
|
"iconexpr", "iconterm", "iconfactor", "iconprimary", "savelist",
|
|
"saveitem", "use_name_list", "use_key_word", "no_use_key_word",
|
|
"use_name", "paramlist", "paramitem", "module_proc_stmt",
|
|
"proc_name_list", "use_stat", "module_name", "only_list", "only_name",
|
|
"rename_list", "rename_name", "dims", "dimlist", "$@1", "dim", "ubound",
|
|
"labellist", "label", "implicit", "implist", "impitem", "imptype", "$@2",
|
|
"type_implicit", "letgroups", "letgroup", "letter", "inside", "in_dcl",
|
|
"opt_double_colon", "funarglist", "funarg", "funargs", "subscript_list",
|
|
"expr", "uexpr", "addop", "ident", "lhs", "array_ele_substring_func_ref",
|
|
"structure_component", "array_element", "asubstring", "opt_substring",
|
|
"substring", "opt_expr", "simple_const", "numeric_bool_const",
|
|
"integer_constant", "string_constant", "complex_const", "kind",
|
|
"triplet", "vec", "$@3", "$@4", "allocate_object", "allocation_list",
|
|
"allocate_object_list", "stat_spec", "pointer_name_list", "exec",
|
|
"do_while", "opt_while", "plain_do", "case", "case_selector",
|
|
"case_value_range", "case_value_range_list", "opt_construct_name",
|
|
"opt_unit_name", "construct_name", "construct_name_colon", "logif",
|
|
"forall", "forall_list", "forall_expr", "opt_forall_cond", "do_var",
|
|
"dospec", "dotarget", "whereable", "iffable", "let", "goto", "opt_comma",
|
|
"call", "callarglist", "callarg", "stop", "end_spec", "intonlyon",
|
|
"intonlyoff", "io", "iofmove", "fmkwd", "iofctl", "ctlkwd", "inquire",
|
|
"infmt", "ioctl", "ctllist", "ioclause", "nameeq", "read", "write",
|
|
"print", "inlist", "inelt", "outlist", "out2", "other", "in_ioctl",
|
|
"start_ioctl", "fexpr", "unpar_fexpr", "cmnt", "dvm_specification",
|
|
"dvm_exec", "dvm_template", "template_obj", "dvm_dynamic",
|
|
"dyn_array_name_list", "dyn_array_name", "dvm_inherit",
|
|
"dummy_array_name_list", "dummy_array_name", "dvm_shadow",
|
|
"shadow_attr_stuff", "sh_width_list", "sh_width", "sh_array_name",
|
|
"dvm_processors", "dvm_indirect_group", "indirect_group_name",
|
|
"dvm_remote_group", "remote_group_name", "dvm_reduction_group",
|
|
"reduction_group_name", "dvm_consistent_group", "consistent_group_name",
|
|
"opt_onto", "dvm_distribute", "dvm_redistribute", "dist_name_list",
|
|
"distributee", "dist_name", "pointer_ar_elem", "processors_name",
|
|
"opt_dist_format_clause", "dist_format_clause", "dist_format_list",
|
|
"opt_key_word", "dist_format", "array_name", "derived_spec",
|
|
"derived_elem_list", "derived_elem", "target_spec", "derived_target",
|
|
"derived_subscript_list", "derived_subscript", "dummy_ident",
|
|
"opt_plus_shadow", "plus_shadow", "shadow_id", "shadow_width",
|
|
"dvm_align", "dvm_realign", "realignee_list", "alignee", "realignee",
|
|
"align_directive_stuff", "align_base", "align_subscript_list",
|
|
"align_subscript", "align_base_name", "dim_ident_list", "dim_ident",
|
|
"dvm_combined_dir", "dvm_attribute_list", "dvm_attribute", "dvm_pointer",
|
|
"dimension_list", "$@5", "pointer_var_list", "pointer_var", "dvm_heap",
|
|
"heap_array_name_list", "heap_array_name", "dvm_consistent",
|
|
"consistent_array_name_list", "consistent_array_name", "dvm_asyncid",
|
|
"async_id_list", "async_id", "dvm_new_value", "dvm_parallel_on",
|
|
"ident_list", "opt_on", "distribute_cycles", "par_subscript_list",
|
|
"par_subscript", "opt_spec", "spec_list", "par_spec",
|
|
"remote_access_spec", "consistent_spec", "consistent_group", "new_spec",
|
|
"private_spec", "cuda_block_spec", "sizelist", "variable_list",
|
|
"tie_spec", "tied_array_list", "indirect_access_spec", "stage_spec",
|
|
"across_spec", "in_out_across", "opt_keyword_in_out", "opt_in_out",
|
|
"dependent_array_list", "dependent_array", "dependence_list",
|
|
"dependence", "section_spec_list", "section_spec", "ar_section",
|
|
"low_section", "high_section", "section", "reduction_spec",
|
|
"opt_key_word_r", "no_opt_key_word_r", "reduction_group",
|
|
"reduction_list", "reduction", "reduction_op", "loc_op", "shadow_spec",
|
|
"shadow_group_name", "shadow_list", "shadow", "opt_corner",
|
|
"array_ident", "array_ident_list", "dvm_shadow_start", "dvm_shadow_wait",
|
|
"dvm_shadow_group", "dvm_reduction_start", "dvm_reduction_wait",
|
|
"dvm_consistent_start", "dvm_consistent_wait", "dvm_remote_access",
|
|
"group_name", "remote_data_list", "remote_data", "remote_index_list",
|
|
"remote_index", "dvm_task", "task_array", "dvm_task_region", "task_name",
|
|
"dvm_end_task_region", "task", "dvm_on", "opt_private_spec",
|
|
"dvm_end_on", "dvm_map", "dvm_prefetch", "dvm_reset",
|
|
"dvm_indirect_access", "indirect_list", "indirect_reference",
|
|
"hpf_independent", "hpf_reduction_spec", "dvm_asynchronous",
|
|
"dvm_endasynchronous", "dvm_asyncwait", "async_ident", "async",
|
|
"dvm_f90", "dvm_debug_dir", "debparamlist", "debparam",
|
|
"fragment_number", "dvm_enddebug_dir", "dvm_interval_dir",
|
|
"interval_number", "dvm_exit_interval_dir", "dvm_endinterval_dir",
|
|
"dvm_traceon_dir", "dvm_traceoff_dir", "dvm_barrier_dir", "dvm_check",
|
|
"dvm_io_mode_dir", "mode_list", "mode_spec", "dvm_shadow_add",
|
|
"template_ref", "shadow_axis_list", "shadow_axis", "opt_include_to",
|
|
"dvm_localize", "localize_target", "target_subscript_list",
|
|
"target_subscript", "aster_expr", "dvm_cp_create", "opt_mode",
|
|
"dvm_cp_load", "dvm_cp_save", "dvm_cp_wait", "dvm_template_create",
|
|
"template_list", "dvm_template_delete", "omp_specification_directive",
|
|
"omp_execution_directive", "ompdvm_onethread",
|
|
"omp_parallel_end_directive", "omp_parallel_begin_directive",
|
|
"parallel_clause_list", "parallel_clause", "omp_variable_list_in_par",
|
|
"ompprivate_clause", "ompfirstprivate_clause", "omplastprivate_clause",
|
|
"ompcopyin_clause", "ompshared_clause", "ompdefault_clause", "def_expr",
|
|
"ompif_clause", "ompnumthreads_clause", "ompreduction_clause",
|
|
"ompreduction", "ompreduction_vars", "ompreduction_op",
|
|
"omp_sections_begin_directive", "sections_clause_list",
|
|
"sections_clause", "omp_sections_end_directive", "omp_section_directive",
|
|
"omp_do_begin_directive", "omp_do_end_directive", "do_clause_list",
|
|
"do_clause", "ompordered_clause", "ompschedule_clause", "ompschedule_op",
|
|
"omp_single_begin_directive", "single_clause_list", "single_clause",
|
|
"omp_single_end_directive", "end_single_clause_list",
|
|
"end_single_clause", "ompcopyprivate_clause", "ompnowait_clause",
|
|
"omp_workshare_begin_directive", "omp_workshare_end_directive",
|
|
"omp_parallel_do_begin_directive", "paralleldo_clause_list",
|
|
"paralleldo_clause", "omp_parallel_do_end_directive",
|
|
"omp_parallel_sections_begin_directive",
|
|
"omp_parallel_sections_end_directive",
|
|
"omp_parallel_workshare_begin_directive",
|
|
"omp_parallel_workshare_end_directive", "omp_threadprivate_directive",
|
|
"omp_master_begin_directive", "omp_master_end_directive",
|
|
"omp_ordered_begin_directive", "omp_ordered_end_directive",
|
|
"omp_barrier_directive", "omp_atomic_directive", "omp_flush_directive",
|
|
"omp_critical_begin_directive", "omp_critical_end_directive",
|
|
"omp_common_var", "omp_variable_list", "op_slash_1", "op_slash_0",
|
|
"acc_specification", "acc_directive", "acc_region", "acc_checksection",
|
|
"acc_get_actual", "acc_actual", "opt_clause", "acc_clause_list",
|
|
"acc_clause", "data_clause", "targets_clause", "async_clause",
|
|
"acc_var_list", "computer_list", "computer", "acc_end_region",
|
|
"acc_end_checksection", "acc_declare", "acc_declare_list", "declare_var",
|
|
"acc_routine", "opt_routine_clauses", "routine_clause_list",
|
|
"routine_clause", "spf_directive", "spf_analysis", "spf_parallel",
|
|
"spf_transform", "spf_parallel_reg", "characteristic_list",
|
|
"characteristic", "opt_clause_apply_fragment", "opt_clause_apply_region",
|
|
"spf_end_parallel_reg", "analysis_spec_list", "analysis_spec",
|
|
"analysis_reduction_spec", "analysis_private_spec",
|
|
"analysis_process_private_spec", "analysis_cover_spec",
|
|
"analysis_parameter_spec", "spf_parameter_list", "spf_parameter",
|
|
"parallel_spec_list", "parallel_spec", "parallel_shadow_spec",
|
|
"parallel_across_spec", "parallel_remote_access_spec",
|
|
"transform_spec_list", "transform_spec", "unroll_list", "region_name",
|
|
"array_element_list", "spf_checkpoint", "checkpoint_spec_list",
|
|
"checkpoint_spec", "spf_type_list", "spf_type", "interval_spec",
|
|
"in_unit", YY_NULLPTR
|
|
};
|
|
#endif
|
|
|
|
# ifdef YYPRINT
|
|
/* YYTOKNUM[NUM] -- (External) token number corresponding to the
|
|
(internal) symbol number NUM (which must be that of a token). */
|
|
static const yytype_uint16 yytoknum[] =
|
|
{
|
|
0, 357, 358, 1, 2, 3, 4, 5, 6, 7,
|
|
8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
|
|
18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
|
|
28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
|
|
38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
|
|
48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
|
|
58, 59, 60, 61, 62, 63, 64, 65, 66, 67,
|
|
68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
|
|
78, 79, 80, 81, 82, 83, 84, 85, 86, 87,
|
|
88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
|
|
98, 99, 100, 101, 102, 103, 104, 105, 106, 107,
|
|
108, 109, 110, 111, 112, 113, 114, 115, 116, 117,
|
|
118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
|
|
128, 129, 130, 131, 132, 133, 134, 135, 136, 137,
|
|
138, 139, 140, 141, 142, 143, 144, 145, 146, 147,
|
|
148, 149, 150, 151, 152, 153, 154, 155, 156, 157,
|
|
158, 159, 160, 161, 162, 163, 164, 165, 166, 167,
|
|
168, 169, 170, 171, 172, 173, 174, 175, 176, 177,
|
|
178, 179, 180, 181, 182, 183, 184, 185, 186, 187,
|
|
188, 189, 190, 191, 192, 193, 194, 195, 196, 197,
|
|
198, 199, 200, 201, 202, 203, 204, 205, 206, 207,
|
|
208, 209, 210, 211, 212, 213, 214, 215, 216, 217,
|
|
218, 219, 220, 221, 222, 223, 224, 225, 226, 227,
|
|
228, 229, 230, 231, 232, 233, 234, 235, 236, 237,
|
|
238, 239, 240, 241, 242, 243, 244, 245, 246, 247,
|
|
248, 249, 250, 251, 252, 253, 254, 255, 256, 257,
|
|
258, 259, 260, 261, 262, 263, 264, 265, 266, 267,
|
|
268, 269, 270, 271, 272, 273, 274, 275, 276, 277,
|
|
278, 279, 280, 281, 282, 283, 284, 285, 286, 287,
|
|
288, 289, 290, 291, 292, 293, 294, 295, 296, 297,
|
|
298, 299, 300, 301, 302, 303, 304, 305, 306, 307,
|
|
308, 309, 310, 311, 312, 313, 314, 315, 316, 317,
|
|
318, 319, 320, 321, 322, 323, 324, 325, 326, 327,
|
|
328, 329, 330, 331, 332, 333, 334, 335, 336, 337,
|
|
338, 339, 340, 341, 342, 343, 344, 345, 346, 347,
|
|
348, 349, 350, 351, 352, 353, 354, 355, 356, 359,
|
|
360
|
|
};
|
|
# endif
|
|
|
|
#define YYPACT_NINF -2221
|
|
|
|
#define yypact_value_is_default(Yystate) \
|
|
(!!((Yystate) == (-2221)))
|
|
|
|
#define YYTABLE_NINF -1192
|
|
|
|
#define yytable_value_is_error(Yytable_value) \
|
|
(!!((Yytable_value) == (-1192)))
|
|
|
|
/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
|
|
STATE-NUM. */
|
|
static const yytype_int16 yypact[] =
|
|
{
|
|
-2221, 112, -2221, -2221, -2221, -2221, 31, 5201, -2221, -2221,
|
|
-2221, 162, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221,
|
|
-2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, 251, -2221,
|
|
-2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221,
|
|
-2221, 64, -2221, -2221, 635, 200, -2221, -2221, -2221, 64,
|
|
-2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221,
|
|
-2221, -2221, 204, 204, -2221, -2221, -2221, -2221, -2221, 204,
|
|
-2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221,
|
|
168, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221,
|
|
-2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, 204, -2221,
|
|
-2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221,
|
|
-2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221,
|
|
-2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221,
|
|
-2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221,
|
|
-2221, 263, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221,
|
|
372, 424, -2221, -2221, -2221, -2221, -2221, 64, -2221, -2221,
|
|
-2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221,
|
|
-2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221,
|
|
-2221, -2221, -2221, -2221, -2221, -2221, 64, -2221, -2221, -2221,
|
|
-2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221,
|
|
-2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, 236,
|
|
1028, 505, 236, -2221, -2221, -2221, 543, 553, 564, 637,
|
|
-2221, -2221, -2221, 605, 669, 204, -2221, -2221, 683, 686,
|
|
726, 782, 603, 198, 805, 816, 827, -2221, 153, -2221,
|
|
-2221, -2221, 236, -2221, -2221, -2221, 591, 45, 2068, 2354,
|
|
-2221, -2221, 3071, -2221, 828, -2221, -2221, 1774, -2221, 863,
|
|
-2221, -2221, 858, 863, 880, -2221, -2221, 884, -2221, -2221,
|
|
-2221, 902, 910, 917, 920, 927, -2221, -2221, -2221, -2221,
|
|
934, 708, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221,
|
|
-2221, -2221, -2221, -2221, -2221, -2221, -2221, 956, -2221, -2221,
|
|
-2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221,
|
|
-2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221,
|
|
-2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221,
|
|
-2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221,
|
|
-2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221,
|
|
-2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221,
|
|
-2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221,
|
|
-2221, -2221, -2221, -2221, -2221, -2221, 159, 204, 981, 1091,
|
|
1105, 923, 204, 204, 164, 204, -2221, 204, 204, 1113,
|
|
-2221, 567, 1130, 204, 204, 204, 204, -2221, -2221, 204,
|
|
-2221, 1134, 204, 982, 204, 993, -2221, -2221, -2221, 204,
|
|
-2221, 1136, 204, -2221, 204, 1154, 304, -2221, 982, -2221,
|
|
204, 204, 204, 204, -2221, -2221, -2221, -2221, -2221, 204,
|
|
-2221, 204, 204, 505, 204, 1158, 981, 204, 1169, -2221,
|
|
204, 204, -2221, -2221, -2221, 1146, 1194, 204, 204, -2221,
|
|
1206, 1210, 204, 981, 1212, 3071, -2221, 1215, 1217, 204,
|
|
-2221, 1228, 204, 1140, -2221, 1227, 204, 981, 1239, 1241,
|
|
-2221, 923, 981, 204, 204, 1782, 63, 204, 83, -2221,
|
|
-2221, 309, -2221, 466, 204, 204, 204, 1244, 204, 204,
|
|
3071, 110, -2221, -2221, 1248, 204, 204, 204, 204, 204,
|
|
2589, 204, -2221, 981, 204, 981, 204, 204, -2221, -2221,
|
|
204, -2221, 981, 204, 1250, 1253, -2221, 204, -2221, -2221,
|
|
1255, -2221, -2221, 1324, -2221, -2221, -2221, -2221, -2221, -2221,
|
|
-2221, -2221, -2221, -2221, 1328, -2221, -2221, -2221, -2221, -2221,
|
|
-2221, -2221, -2221, -2221, -2221, -2221, 204, -2221, -2221, 1331,
|
|
1361, 1272, 981, 1366, 3071, 3071, 3071, 3071, 3071, 1382,
|
|
1388, 1431, 1448, 1462, 204, -2221, 1466, -2221, -2221, -2221,
|
|
-2221, 1177, 165, -2221, -2221, 204, 204, 204, 204, 1325,
|
|
-2221, -2221, 1355, 204, 204, -2221, 636, 204, 204, 204,
|
|
204, 204, 290, 204, 1140, 204, 204, 1158, -2221, -2221,
|
|
-2221, -2221, -2221, -2221, -2221, -2221, 1095, -2221, -2221, -2221,
|
|
-2221, -2221, -2221, 3071, 3071, 3071, -2221, 3071, -2221, -2221,
|
|
-2221, -2221, -2221, -2221, 3071, 3280, -2221, 103, 1452, -2221,
|
|
1467, -2221, 1237, 1240, 1473, -2221, -2221, 1474, 3071, -2221,
|
|
-2221, 1511, -2221, -2221, 1475, 1550, 1452, -2221, -2221, 903,
|
|
-8, -2221, 1511, -2221, -2221, -2221, 1491, 473, 93, 3087,
|
|
3087, 204, 204, 204, 204, 204, 204, 204, 1493, -2221,
|
|
204, -2221, -2221, -2221, 527, -2221, -2221, 1489, 204, -2221,
|
|
3071, -2221, 1268, 801, -2221, 1490, -2221, -2221, 1492, 1501,
|
|
-2221, -2221, -2221, -2221, -2221, 2679, 204, 1495, -2221, 204,
|
|
1492, 204, -2221, 923, -2221, -2221, -2221, -2221, -2221, -2221,
|
|
1504, -2221, -2221, -2221, -2221, -2221, 1492, -2221, -2221, 1498,
|
|
-2221, -2221, 700, 1224, 204, 737, 166, -2221, 1499, 1340,
|
|
3071, 1368, -2221, 1515, -2221, -2221, 3071, 3071, -2221, -2221,
|
|
-2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, 204,
|
|
-2221, 204, 1510, 658, 204, 505, -2221, -2221, 1521, -2221,
|
|
1522, -2221, 1516, 751, -2221, 1525, -2221, 204, -2221, -2221,
|
|
-2221, 1527, -2221, 863, 1517, 3442, -2221, 204, -2221, 5910,
|
|
-2221, 204, 3071, -2221, 1526, -2221, 204, -2221, 204, 204,
|
|
204, 1452, 958, 204, 204, 204, 1368, -2221, 204, 215,
|
|
-2221, -2221, -2221, 1550, 903, -2221, -2221, -2221, -2221, -2221,
|
|
-2221, 159, -2221, 1489, 1529, 1499, -2221, -2221, -2221, -2221,
|
|
-2221, -2221, 204, -2221, -2221, -2221, 5910, -2221, 567, 1480,
|
|
204, -2221, 1530, -2221, -2221, -2221, -2221, 1531, 3521, 744,
|
|
-2221, -2221, 263, 204, 505, -2221, 204, 1492, -2221, 1536,
|
|
1528, -2221, 204, -2221, 1543, 3071, 3071, -2221, 1492, 204,
|
|
123, 204, 1266, 1266, 149, 1266, -2221, 1539, 179, 180,
|
|
184, 190, 205, 212, -2221, 1492, 515, -2221, 1553, -2221,
|
|
183, 210, -2221, -2221, 1272, -2221, 204, -2221, 3654, 5910,
|
|
3754, 3794, 1554, 5910, 204, 204, -2221, -2221, -2221, -2221,
|
|
1560, -2221, 204, 204, -2221, -2221, -2221, -2221, 790, -2221,
|
|
-2221, 1345, 1492, -2221, -2221, -2221, -2221, 1150, 204, -2221,
|
|
-2221, -2221, -2221, -2221, -2221, -2221, 1492, -2221, -2221, -2221,
|
|
-2221, 1561, -2221, 1561, -2221, -2221, -2221, -2221, 651, -2221,
|
|
480, -2221, 1555, -2221, -2221, 3828, 1564, 1567, 1567, 2164,
|
|
-2221, 3071, 3071, 3071, 3071, 3071, 3071, 3071, 3071, 3071,
|
|
3071, 3071, 3071, 3071, 3071, 3071, 3071, 3071, 3071, 3071,
|
|
-2221, 1509, 1408, 1563, 454, 525, 3071, -2221, -2221, -2221,
|
|
802, 1442, -2221, -2221, -2221, -2221, 831, -2221, 1373, 922,
|
|
3071, 1572, 1550, 1550, 1550, 1550, 1550, -2221, 1116, -2221,
|
|
473, 473, 1452, 1574, -2221, 3087, 5910, 91, 120, -2221,
|
|
1577, 1579, -2221, -2221, 1492, -2221, -2221, -2221, -2221, 1492,
|
|
-2221, 416, -2221, 159, -2221, -2221, -2221, 204, 3869, 204,
|
|
1573, 3071, 1523, -2221, -2221, 204, -2221, 3071, 3908, -2221,
|
|
868, -2221, -2221, 1552, -2221, -2221, 876, -2221, 204, -2221,
|
|
204, -2221, -2221, 1224, -2221, -2221, -2221, -2221, -2221, 3942,
|
|
1492, -2221, -2221, -2221, 1580, 1581, 1583, 1584, 1585, 1586,
|
|
-2221, 1340, -2221, 204, -2221, 4031, -2221, -2221, 204, 4065,
|
|
4099, -2221, 1587, 882, 1596, 1473, -2221, -2221, 204, -2221,
|
|
1602, -2221, 1566, -2221, 204, -2221, 1483, 90, -2221, -2221,
|
|
-13, -2221, -2221, 1606, -2221, 1594, 1612, 885, -2221, 204,
|
|
3087, 1599, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221,
|
|
-2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221,
|
|
-2221, 1600, -2221, -2221, 430, 1603, 1604, 4136, 2695, -16,
|
|
-2221, 1588, -2221, -2221, 890, -2221, -2221, -2221, -2221, -2221,
|
|
909, 1597, 925, -2221, -2221, -2221, 3071, -2221, 1162, -2221,
|
|
-2221, -2221, 939, -2221, 1620, -2221, 1340, 1617, 1626, 954,
|
|
-2221, -2221, -2221, 1630, -2221, 1619, 1629, 1632, 204, 3071,
|
|
3071, 2589, -2221, -2221, -2221, -2221, -2221, -2221, -2221, 1637,
|
|
1638, -2221, 308, -2221, -2221, 4190, 4221, -2221, 1645, -2221,
|
|
214, 1646, -2221, -2221, -2221, -2221, 220, -2221, -2221, -2221,
|
|
221, -2221, 389, 453, 481, -2221, 483, -2221, 506, -2221,
|
|
1644, 1653, 1654, 1655, -2221, 1657, 1658, -2221, -2221, -2221,
|
|
-2221, -2221, -2221, 1452, 1670, 1659, -2221, 1661, -40, -2221,
|
|
-2221, 1676, -2221, -4, 957, -2221, -2221, -2221, -2221, 3071,
|
|
436, 590, -2221, 959, 960, -56, 963, -2221, -2221, -2221,
|
|
-2221, -2221, -2221, 95, 964, -2221, -2221, -2221, -2221, 514,
|
|
988, -2221, -2221, 435, 995, -2221, -2221, 505, 204, 186,
|
|
-2221, 1671, -2221, 1680, -2221, 1492, -2221, -2221, -2221, 1672,
|
|
-2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, 1032, -2221,
|
|
-2221, -2221, 204, 1492, 150, 1601, -2221, -2221, 204, 204,
|
|
-2221, 1267, 480, -2221, 1673, -2221, 1627, 3071, 3087, -2221,
|
|
3071, 1567, 1567, 611, 611, 2164, 985, 2300, 2643, 5910,
|
|
2643, 2643, 2643, 2643, 2643, 2300, 2134, 1567, 2134, 2900,
|
|
1563, -2221, -2221, 1669, 1684, 2548, -2221, -2221, -2221, -2221,
|
|
-2221, 1687, -2221, -2221, 923, 5910, -2221, 3071, -2221, -2221,
|
|
-2221, -2221, 5910, 87, 5910, 1572, 1572, 1125, 1572, 612,
|
|
-2221, 1574, 1688, 473, 4269, 1689, 1690, 1692, 3087, 3087,
|
|
3087, -2221, -2221, 204, 1686, -2221, -2221, 1698, 1499, -2221,
|
|
263, -2221, -2221, -2221, -2221, 1447, -2221, 997, 923, -2221,
|
|
923, 1015, 1696, 1017, -2221, 5910, 3071, 2679, -2221, 1020,
|
|
-2221, 923, 1561, -2221, 738, 846, -2221, 1027, 1538, 1041,
|
|
-2221, 1790, -2221, 166, -2221, 1699, 204, 204, 3071, 204,
|
|
-2221, -2221, 1492, -2221, -2221, -2221, 1456, 204, 3071, 204,
|
|
-2221, 204, -2221, 1452, 3071, 1695, 2695, -2221, -2221, -2221,
|
|
-2221, 1052, -2221, 1702, -2221, 1704, 1705, 1706, 1497, 3071,
|
|
204, 204, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221,
|
|
981, 204, -2221, 2746, 3406, 1703, 204, 204, -2221, 204,
|
|
-2221, 1532, 204, -2221, 3071, 204, -2221, 1561, 5910, -2221,
|
|
1717, 398, 1717, -2221, 204, 1340, 1719, 2778, 204, 204,
|
|
-2221, 567, 3071, 812, 3071, 1056, -2221, 1712, 1067, 5910,
|
|
-2221, 53, -2221, -2221, -2221, -2221, -2221, 981, 55, -2221,
|
|
204, -2221, 546, -2221, -2221, 51, -2221, 137, 597, -2221,
|
|
659, -2221, 598, -2221, -18, -2221, 204, 204, 204, -2221,
|
|
204, 204, 515, -2221, 204, -2221, -2221, 1713, -2221, 204,
|
|
-2221, -2221, -2221, -2221, -2221, 1398, 1417, 1401, 5910, -2221,
|
|
1563, 204, -2221, -2221, 1723, 1727, 1730, 1731, 1733, -2221,
|
|
-2221, 1737, 1738, 1740, -2221, -2221, -2221, 1741, 1747, 1748,
|
|
1749, -2221, -2221, -2221, 839, 1750, 1751, 1754, 1757, 1759,
|
|
-2221, -2221, -2221, -2221, -2221, 204, 761, -2221, -2221, 1760,
|
|
-2221, 1770, -2221, -2221, 1680, -2221, -2221, -2221, -2221, 5910,
|
|
2061, -2221, -2221, -2221, 508, 380, 380, 1488, 1535, -2221,
|
|
-2221, 1540, 1546, 1548, 664, 204, -2221, -2221, -2221, -2221,
|
|
1777, -2221, -2221, -2221, 1673, -2221, 1795, -2221, 696, 1796,
|
|
-2221, 1799, 4304, -2221, 1764, 1794, 1473, -2221, -2221, 4365,
|
|
-2221, 3071, 3071, 1442, -2221, 5910, 1511, 473, -2221, 122,
|
|
3087, 3087, 3087, 125, -2221, 129, -2221, 155, -2221, 1492,
|
|
204, -2221, -2221, 1811, 1081, -2221, 1814, -2221, 5910, -2221,
|
|
-2221, -2221, 3071, -2221, -2221, 3071, -2221, -2221, -2221, -2221,
|
|
5910, -2221, 1538, 3071, 1801, -2221, 1804, 1807, 4622, 1826,
|
|
-2221, 130, 204, -2221, 1090, -2221, -2221, 1809, 5910, -2221,
|
|
-2221, 4365, -2221, 1483, -2221, 1483, 204, 204, 204, 1101,
|
|
1115, -2221, 204, 1822, 1818, 3071, 4668, 3055, -2221, -2221,
|
|
-2221, 1492, 1452, -2221, 1825, -2221, 1668, 1834, 5910, -2221,
|
|
204, -2221, 1828, 1829, -2221, -2221, 1592, 1841, -2221, -2221,
|
|
1843, -2221, 5910, 1119, -2221, 1127, -2221, -2221, 4699, -2221,
|
|
-2221, 1139, -2221, -2221, 5910, 1830, 204, -2221, -2221, -2221,
|
|
1837, 1838, 1648, 1784, 204, 204, 1839, 1850, -2221, 699,
|
|
-2221, 1844, -2221, -2221, -2221, 1845, -2221, -2221, -2221, -2221,
|
|
-2221, -2221, -2221, 546, -2221, -2221, -2221, -2221, 51, 204,
|
|
-2221, -2221, 1142, 1846, -2221, 1847, -2221, 1848, -2221, -2221,
|
|
-2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, 597, -2221,
|
|
-2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221,
|
|
-2221, 659, -2221, -2221, -2221, -2221, -2221, 598, -2221, -2221,
|
|
-2221, -18, 1849, 1851, 1855, 886, 1149, -2221, 1856, 1857,
|
|
1452, 204, -2221, -2221, 1852, -2221, 1853, 1563, 1863, -2221,
|
|
204, 204, -2221, 1715, 204, -2221, 204, 204, 204, -2221,
|
|
204, 204, 204, 3071, -2221, 1866, 1870, -2221, 204, 204,
|
|
3071, -2221, -2221, 1871, 3071, 3071, -2221, -2221, 1873, -2221,
|
|
1726, 761, 2427, -2221, 1166, -2221, 5910, -2221, -2221, -2221,
|
|
1887, -2221, -2221, -2221, -2221, 454, 454, 454, 454, 454,
|
|
1267, -2221, 1881, 1893, 1884, 1267, 1796, -2221, 480, 696,
|
|
459, 459, -2221, -2221, -2221, 1167, 1858, 608, 235, -2221,
|
|
1892, 696, -2221, 3071, -2221, 1882, -2221, 1473, -2221, 2548,
|
|
5910, 1885, -2221, -2221, 903, 1879, 1886, 1168, 1889, 1891,
|
|
1894, -2221, -2221, -2221, 1899, 82, 923, -2221, 204, 981,
|
|
5910, 82, 5910, 1538, 3071, 1895, 4734, 1172, -2221, -2221,
|
|
-2221, -2221, -2221, 3071, -2221, 1903, -2221, -2221, -2221, -2221,
|
|
-2221, 1187, 1193, 1199, -2221, -2221, -2221, 992, -2221, 5910,
|
|
3071, 3071, 4769, -2221, 204, 204, -2221, -2221, 1834, -2221,
|
|
-2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221,
|
|
-2221, 1902, 398, 1904, 3442, -2221, 204, 204, 204, 2778,
|
|
-2221, -2221, -2221, 812, -2221, -2221, -2221, 1943, 204, -2221,
|
|
-2221, 1839, 1900, -2221, -2221, 204, 204, 3071, -2221, -2221,
|
|
-2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, 137,
|
|
-2221, -2221, -2221, 3071, -2221, 3071, -2221, -2221, -2221, -2221,
|
|
-2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221,
|
|
-2221, -2221, -2221, 1202, 204, 204, 1908, 851, 1906, 1203,
|
|
-2221, 1205, 634, 1225, 1912, 1254, 1258, 1265, 1277, 1279,
|
|
1284, -2221, 1288, 4800, 1913, -2221, -2221, -114, 1289, -2221,
|
|
1298, 1299, 4836, 895, 1917, -2221, 5910, 5910, 1300, 1928,
|
|
-2221, -2221, -2221, 1915, 4877, -2221, -2221, -2221, 508, -2221,
|
|
-2221, -2221, -2221, -2221, -2221, 1267, -2221, 204, -2221, -2221,
|
|
1922, 1914, -2221, 843, 235, 235, 696, -2221, 696, 459,
|
|
459, 459, 459, 459, 1273, 4908, -2221, -2221, -2221, -2221,
|
|
3071, -2221, -2221, -2221, -2221, 1647, -2221, 204, 1930, 1501,
|
|
204, -2221, 204, -2221, 4969, -2221, 3071, 3071, -2221, 5004,
|
|
1693, 3071, -2221, -2221, -2221, -2221, 1303, -2221, -2221, 5910,
|
|
5910, 3071, 1309, 1926, -2221, 935, -2221, 3071, -2221, 1923,
|
|
1931, -2221, -2221, 1936, 1935, -2221, -2221, -2221, -2221, -2221,
|
|
1823, 1933, 1314, 1954, 1956, 1315, 1057, 204, -2221, -2221,
|
|
5910, 899, 1944, 21, -2221, -2221, 1927, -2221, -2221, 330,
|
|
5040, 5071, -2221, -2221, -2221, -2221, -2221, -2221, 1317, 1945,
|
|
1079, 3071, 204, -2221, -2221, -2221, -2221, -2221, -2221, -2221,
|
|
-2221, -2221, -2221, -2221, -2221, -2221, -2221, 1952, 1953, -2221,
|
|
-2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, 204, -2221,
|
|
3071, -2221, 1615, 1319, -2221, 1321, -2221, -2221, -2221, -2221,
|
|
-2221, -2221, -2221, -2221, -2221, 3071, 1964, 1965, -2221, -2221,
|
|
-2221, 1601, 1955, -2221, 1563, -2221, 696, -2221, 1273, 1957,
|
|
235, 235, -2221, -2221, -2221, -2221, 5140, -2221, 4365, -2221,
|
|
1363, -2221, -2221, 923, 1670, -2221, 1538, 5910, -2221, 1718,
|
|
-2221, 1967, 5196, 992, -2221, 5910, -2221, 2462, 1969, 1971,
|
|
1973, 1974, 1978, 204, 204, 1979, 1980, 1981, 5535, -2221,
|
|
-2221, -2221, 3071, 204, 204, -2221, -2221, 1983, 204, -2221,
|
|
-2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221,
|
|
-2221, -2221, -2221, -2221, -2221, -2221, -2221, 1992, -2221, -2221,
|
|
-2221, -2221, -2221, 1364, -2221, -2221, -2221, -2221, 1982, -2221,
|
|
-2221, 1994, -2221, 5910, -2221, 204, 204, 634, -2221, 5566,
|
|
-2221, -2221, 1998, 2000, -2221, 5597, -2221, 1993, -2221, -2221,
|
|
1988, 1383, 1273, -2221, 3071, 1647, -2221, -2221, 3071, 204,
|
|
3071, -2221, -2221, -2221, 5910, 1391, -2221, -2221, 1969, 204,
|
|
204, 204, 204, -2221, -2221, 3071, 3071, 204, 3071, 1393,
|
|
-2221, -2221, 2002, -2221, 1394, 2004, 1397, 204, 3071, -2221,
|
|
-2221, -2221, -2221, 239, 2006, -2221, 3071, -2221, -2221, -2221,
|
|
-2221, -2221, -2221, 204, 1991, -2221, -2221, 5628, -2221, 5910,
|
|
-2221, -2221, 2001, 5659, 2462, -2221, 394, -2221, 2008, 1403,
|
|
2010, 1409, 2003, 1411, 5690, 5721, 1999, -2221, 1412, 5752,
|
|
-2221, 204, 1947, -2221, -2221, -2221, -2221, 1670, -2221, 5783,
|
|
1697, -2221, 3071, 5910, 1675, 1674, -2221, 2014, -2221, -2221,
|
|
3071, 1744, -2221, -2221, 2016, 2022, 204, 204, -2221, 204,
|
|
-2221, 2589, -2221, -2221, 3071, -2221, 204, -2221, 3071, -2221,
|
|
2011, 1413, 1414, -2221, 2018, 5814, 1121, 2023, 2024, 204,
|
|
5910, 204, 5910, 1415, -2221, -2221, -2221, -2221, 1418, -2221,
|
|
2026, 1419, 1420, 1421, 5845, -2221, 5910, -2221, -2221, -2221,
|
|
3071, -2221, -2221, -2221, -2221, -2221, 2020, 1744, -2221, 204,
|
|
-2221, 3071, -2221, -2221, 2042, 3071, 1423, 1440, 1445, 3071,
|
|
2047, -2221, -2221, -2221, 5879, 1459, -2221, -2221, 5910, 2035,
|
|
-2221, -2221, -2221, 3071, 3071, 3071, 2050, -2221, -2221, -2221,
|
|
5910, -2221, -2221, -38, 486, 1463, -2221, 2060, 2063, -2221,
|
|
-2221, -2221, 2053, 2053, 2053, -2221, -2221, -2221, -2221, -2221,
|
|
-2221, -2221, -2221, -2221, 550, 2066, -2221, 1951, -2221, 1464,
|
|
-2221, -2221, -2221
|
|
};
|
|
|
|
/* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
|
|
Performed when YYTABLE does not specify something else to do. Zero
|
|
means the default is an error. */
|
|
static const yytype_uint16 yydefact[] =
|
|
{
|
|
2, 0, 1, 10, 11, 9, 0, 0, 3, 151,
|
|
150, 790, 340, 538, 538, 538, 538, 538, 340, 538,
|
|
556, 538, 20, 538, 538, 159, 538, 561, 340, 155,
|
|
538, 340, 538, 538, 340, 486, 538, 538, 538, 339,
|
|
538, 783, 538, 538, 341, 792, 538, 156, 157, 786,
|
|
45, 538, 538, 538, 538, 538, 538, 538, 538, 558,
|
|
538, 538, 484, 484, 538, 538, 538, 340, 538, 0,
|
|
538, 340, 340, 538, 538, 339, 20, 340, 340, 326,
|
|
0, 538, 538, 340, 340, 538, 340, 340, 340, 340,
|
|
153, 340, 538, 212, 538, 158, 538, 538, 0, 20,
|
|
340, 538, 538, 538, 560, 340, 538, 340, 536, 538,
|
|
538, 340, 538, 538, 538, 340, 20, 340, 45, 538,
|
|
538, 154, 45, 538, 340, 538, 538, 538, 340, 538,
|
|
538, 557, 340, 538, 340, 538, 538, 538, 538, 538,
|
|
538, 340, 340, 537, 20, 340, 340, 538, 538, 538,
|
|
0, 340, 8, 340, 538, 538, 538, 784, 538, 538,
|
|
538, 538, 538, 538, 538, 538, 538, 538, 538, 538,
|
|
538, 538, 538, 538, 538, 538, 538, 538, 538, 538,
|
|
538, 538, 538, 538, 340, 538, 785, 538, 1228, 538,
|
|
1229, 538, 538, 340, 340, 538, 538, 538, 538, 538,
|
|
538, 538, 538, 1312, 1312, 1312, 1312, 1312, 1312, 612,
|
|
0, 37, 612, 74, 48, 49, 50, 66, 67, 77,
|
|
69, 70, 68, 110, 59, 0, 147, 152, 52, 71,
|
|
72, 73, 51, 60, 55, 56, 57, 61, 208, 76,
|
|
75, 58, 612, 446, 441, 454, 0, 0, 0, 457,
|
|
440, 439, 0, 509, 512, 538, 510, 0, 538, 0,
|
|
538, 546, 0, 0, 553, 53, 460, 614, 617, 623,
|
|
619, 618, 624, 625, 626, 627, 616, 633, 615, 634,
|
|
620, 0, 781, 621, 628, 630, 629, 661, 635, 637,
|
|
638, 636, 639, 640, 641, 642, 643, 622, 644, 645,
|
|
647, 648, 646, 650, 651, 649, 675, 662, 663, 664,
|
|
665, 652, 653, 654, 656, 655, 657, 658, 659, 660,
|
|
666, 667, 668, 669, 670, 671, 672, 673, 674, 632,
|
|
676, 631, 1035, 1034, 1036, 1037, 1038, 1039, 1040, 1041,
|
|
1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049, 1050, 1033,
|
|
1051, 1052, 1053, 1054, 1055, 1056, 1057, 1058, 1059, 54,
|
|
461, 1195, 1197, 1199, 1200, 1196, 1198, 1193, 1194, 462,
|
|
1241, 1242, 1243, 1244, 1245, 1246, 0, 0, 341, 0,
|
|
0, 0, 0, 0, 0, 0, 997, 35, 0, 0,
|
|
599, 0, 0, 0, 0, 0, 0, 455, 508, 482,
|
|
211, 0, 0, 0, 482, 0, 313, 340, 728, 0,
|
|
728, 539, 0, 23, 482, 0, 482, 977, 0, 994,
|
|
484, 482, 482, 482, 32, 485, 82, 445, 960, 482,
|
|
954, 106, 482, 37, 482, 0, 341, 0, 0, 64,
|
|
0, 0, 330, 44, 7, 971, 0, 0, 0, 600,
|
|
0, 0, 78, 341, 0, 991, 523, 0, 0, 0,
|
|
297, 296, 0, 0, 814, 0, 0, 341, 0, 0,
|
|
539, 0, 341, 0, 0, 0, 341, 33, 341, 22,
|
|
600, 0, 21, 0, 0, 0, 0, 0, 0, 0,
|
|
399, 341, 45, 141, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 788, 341, 0, 341, 0, 0, 995, 996,
|
|
0, 340, 341, 0, 0, 0, 600, 0, 1179, 1178,
|
|
1183, 1060, 728, 1185, 728, 1175, 1177, 1061, 1166, 1169,
|
|
1172, 728, 728, 728, 1181, 1174, 1176, 728, 728, 728,
|
|
728, 1114, 728, 728, 1191, 1148, 0, 45, 1202, 1205,
|
|
1208, 1235, 341, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 1260, 0, 613, 4, 20,
|
|
20, 0, 0, 45, 5, 0, 0, 0, 0, 0,
|
|
45, 20, 0, 0, 0, 148, 165, 0, 0, 0,
|
|
0, 529, 0, 529, 0, 0, 0, 0, 529, 223,
|
|
6, 487, 538, 538, 447, 442, 0, 458, 449, 448,
|
|
456, 83, 173, 0, 0, 0, 407, 0, 406, 411,
|
|
409, 410, 408, 382, 0, 0, 352, 383, 355, 385,
|
|
384, 356, 401, 403, 396, 354, 357, 599, 399, 543,
|
|
544, 0, 381, 380, 32, 0, 603, 604, 541, 0,
|
|
601, 600, 0, 545, 600, 565, 548, 547, 601, 551,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 45,
|
|
0, 777, 778, 776, 0, 774, 764, 0, 0, 436,
|
|
0, 324, 0, 525, 979, 980, 976, 45, 311, 809,
|
|
811, 978, 36, 13, 599, 0, 482, 0, 193, 0,
|
|
311, 0, 185, 0, 710, 708, 844, 932, 933, 808,
|
|
805, 806, 483, 517, 223, 436, 311, 677, 988, 983,
|
|
471, 342, 0, 0, 0, 0, 0, 720, 723, 712,
|
|
0, 498, 683, 680, 681, 452, 0, 0, 501, 989,
|
|
443, 444, 459, 453, 472, 107, 500, 45, 518, 0,
|
|
200, 0, 383, 0, 0, 37, 25, 804, 801, 802,
|
|
325, 327, 0, 0, 45, 972, 973, 0, 701, 699,
|
|
687, 684, 685, 0, 0, 0, 79, 0, 45, 992,
|
|
990, 0, 0, 953, 0, 45, 0, 19, 0, 0,
|
|
0, 0, 958, 0, 0, 0, 498, 524, 0, 0,
|
|
936, 963, 600, 0, 600, 601, 140, 34, 12, 144,
|
|
577, 0, 765, 0, 0, 0, 728, 707, 705, 893,
|
|
930, 931, 0, 704, 702, 964, 400, 515, 0, 0,
|
|
0, 914, 0, 926, 925, 928, 927, 0, 692, 0,
|
|
690, 695, 0, 0, 37, 24, 0, 311, 945, 948,
|
|
0, 45, 0, 303, 299, 0, 0, 578, 311, 0,
|
|
528, 0, 1118, 1113, 528, 1150, 1180, 0, 528, 528,
|
|
528, 528, 528, 528, 1173, 311, 46, 1201, 1210, 1211,
|
|
0, 0, 45, 1234, 1236, 1237, 0, 45, 0, 1025,
|
|
1026, 0, 993, 350, 0, 0, 45, 45, 45, 1295,
|
|
1250, 45, 0, 0, 20, 43, 38, 42, 0, 40,
|
|
17, 46, 311, 133, 135, 137, 111, 0, 0, 20,
|
|
340, 149, 539, 599, 166, 147, 311, 180, 182, 184,
|
|
188, 528, 191, 528, 197, 199, 201, 210, 0, 214,
|
|
0, 45, 0, 450, 425, 0, 352, 365, 364, 377,
|
|
363, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
599, 0, 0, 599, 0, 0, 399, 405, 397, 513,
|
|
0, 0, 516, 571, 572, 576, 0, 568, 0, 570,
|
|
0, 609, 0, 0, 0, 0, 0, 555, 570, 559,
|
|
0, 0, 583, 549, 581, 0, 0, 352, 354, 552,
|
|
587, 586, 554, 678, 311, 700, 703, 706, 709, 311,
|
|
340, 0, 946, 0, 45, 759, 179, 0, 0, 0,
|
|
0, 0, 0, 313, 813, 0, 530, 0, 476, 480,
|
|
0, 470, 599, 0, 195, 186, 0, 322, 0, 209,
|
|
0, 679, 599, 0, 787, 320, 317, 314, 316, 321,
|
|
311, 728, 725, 734, 729, 0, 0, 0, 0, 0,
|
|
726, 712, 728, 0, 791, 0, 499, 540, 0, 0,
|
|
0, 18, 205, 0, 0, 0, 207, 196, 0, 495,
|
|
493, 490, 0, 45, 0, 330, 0, 0, 333, 331,
|
|
0, 45, 974, 382, 922, 969, 0, 0, 967, 0,
|
|
562, 0, 88, 89, 87, 86, 92, 91, 103, 96,
|
|
99, 98, 101, 100, 97, 102, 95, 93, 90, 94,
|
|
84, 0, 85, 198, 0, 0, 0, 0, 0, 0,
|
|
298, 0, 189, 437, 0, 45, 959, 957, 134, 816,
|
|
0, 0, 0, 293, 540, 181, 0, 580, 0, 579,
|
|
288, 288, 0, 760, 0, 728, 712, 940, 0, 0,
|
|
937, 285, 284, 63, 282, 0, 0, 0, 0, 0,
|
|
0, 0, 689, 688, 136, 14, 183, 947, 45, 950,
|
|
949, 147, 0, 104, 47, 0, 0, 696, 0, 728,
|
|
528, 0, 1147, 1117, 1112, 728, 528, 1149, 1192, 728,
|
|
528, 728, 528, 528, 528, 728, 528, 728, 528, 697,
|
|
0, 0, 0, 0, 1222, 0, 0, 1209, 1213, 1215,
|
|
1214, 45, 1204, 852, 1223, 0, 1207, 0, 0, 1238,
|
|
1233, 1230, 1231, 0, 0, 1000, 45, 45, 45, 0,
|
|
391, 392, 1030, 0, 0, 0, 0, 1261, 1263, 1264,
|
|
1265, 1267, 1266, 0, 0, 1276, 1278, 1279, 1280, 0,
|
|
0, 1284, 45, 0, 0, 1299, 28, 37, 0, 0,
|
|
39, 0, 30, 160, 117, 311, 340, 119, 121, 0,
|
|
122, 115, 123, 131, 130, 124, 125, 126, 0, 113,
|
|
116, 26, 0, 311, 0, 0, 145, 178, 0, 0,
|
|
223, 223, 0, 225, 218, 222, 0, 0, 0, 353,
|
|
0, 360, 362, 359, 358, 376, 378, 372, 366, 505,
|
|
369, 367, 370, 368, 371, 373, 375, 361, 374, 379,
|
|
599, 412, 390, 0, 344, 0, 415, 416, 402, 413,
|
|
404, 0, 599, 514, 0, 533, 531, 0, 599, 567,
|
|
574, 575, 573, 602, 611, 606, 608, 610, 607, 605,
|
|
566, 550, 0, 0, 0, 352, 0, 0, 0, 0,
|
|
0, 698, 780, 0, 790, 793, 783, 0, 792, 786,
|
|
0, 784, 785, 782, 775, 0, 430, 0, 0, 507,
|
|
0, 0, 0, 0, 812, 478, 477, 0, 475, 0,
|
|
194, 0, 528, 807, 428, 429, 433, 0, 0, 0,
|
|
315, 318, 177, 0, 599, 0, 0, 0, 0, 0,
|
|
713, 724, 311, 463, 728, 682, 0, 482, 0, 0,
|
|
202, 0, 395, 982, 0, 0, 0, 16, 803, 328,
|
|
338, 0, 334, 336, 332, 0, 0, 0, 0, 0,
|
|
0, 0, 966, 686, 563, 81, 80, 129, 127, 128,
|
|
341, 0, 488, 424, 0, 0, 0, 0, 192, 0,
|
|
521, 0, 0, 728, 0, 0, 65, 528, 506, 602,
|
|
139, 0, 143, 45, 0, 712, 0, 0, 0, 0,
|
|
935, 0, 0, 0, 0, 0, 915, 917, 0, 693,
|
|
691, 0, 45, 952, 45, 951, 146, 341, 0, 503,
|
|
0, 1182, 0, 728, 1184, 0, 728, 0, 0, 728,
|
|
0, 728, 0, 728, 0, 728, 0, 0, 0, 45,
|
|
0, 0, 0, 1212, 0, 1203, 1206, 0, 1240, 0,
|
|
1004, 1002, 1003, 45, 999, 0, 0, 0, 351, 599,
|
|
599, 0, 1029, 1032, 0, 0, 0, 0, 0, 45,
|
|
1247, 0, 0, 0, 45, 1248, 1286, 1288, 0, 0,
|
|
1291, 1293, 45, 1249, 0, 0, 0, 0, 0, 0,
|
|
45, 1298, 15, 29, 41, 0, 174, 161, 118, 0,
|
|
45, 0, 45, 27, 160, 540, 540, 170, 173, 169,
|
|
0, 187, 190, 215, 0, 0, 0, 248, 246, 253,
|
|
250, 264, 257, 262, 0, 0, 216, 239, 251, 243,
|
|
254, 244, 259, 245, 0, 238, 0, 233, 230, 219,
|
|
220, 0, 0, 426, 352, 0, 388, 599, 348, 345,
|
|
346, 0, 399, 0, 535, 534, 0, 0, 582, 353,
|
|
0, 0, 0, 352, 589, 352, 593, 352, 591, 311,
|
|
0, 599, 519, 0, 0, 981, 0, 312, 479, 481,
|
|
173, 323, 0, 599, 520, 0, 985, 599, 984, 319,
|
|
321, 727, 0, 0, 0, 737, 0, 0, 0, 0,
|
|
711, 465, 482, 502, 0, 204, 203, 382, 494, 491,
|
|
489, 0, 492, 0, 329, 0, 0, 0, 0, 0,
|
|
0, 968, 0, 1014, 0, 0, 423, 418, 955, 956,
|
|
722, 311, 962, 438, 0, 817, 819, 825, 295, 294,
|
|
0, 288, 0, 0, 290, 289, 0, 761, 762, 714,
|
|
0, 944, 943, 0, 941, 0, 938, 283, 0, 1020,
|
|
1009, 0, 1007, 1010, 756, 0, 0, 929, 921, 694,
|
|
0, 0, 0, 0, 0, 301, 0, 300, 308, 0,
|
|
1191, 0, 1191, 1191, 1127, 0, 1121, 1123, 1124, 1122,
|
|
728, 1126, 1125, 0, 1191, 728, 1145, 1144, 0, 0,
|
|
1188, 1187, 0, 0, 1191, 0, 1191, 0, 728, 1066,
|
|
1070, 1071, 1072, 1068, 1069, 1073, 1074, 1067, 0, 1155,
|
|
1159, 1160, 1161, 1157, 1158, 1162, 1163, 1156, 1165, 1164,
|
|
728, 0, 1108, 1110, 1111, 1109, 728, 0, 1138, 1139,
|
|
728, 0, 0, 0, 0, 0, 0, 1224, 0, 0,
|
|
853, 0, 1232, 1001, 0, 1027, 0, 599, 0, 1031,
|
|
0, 0, 45, 0, 0, 1262, 0, 0, 0, 1277,
|
|
0, 0, 0, 0, 1285, 0, 0, 45, 0, 0,
|
|
0, 45, 1300, 0, 0, 0, 109, 795, 0, 112,
|
|
0, 174, 0, 147, 0, 172, 171, 268, 254, 267,
|
|
0, 256, 261, 255, 260, 0, 0, 0, 0, 0,
|
|
223, 213, 224, 242, 0, 223, 235, 236, 0, 0,
|
|
0, 0, 279, 224, 280, 0, 0, 228, 269, 274,
|
|
277, 230, 221, 0, 504, 0, 414, 386, 389, 0,
|
|
347, 0, 532, 569, 570, 0, 0, 352, 0, 0,
|
|
0, 779, 773, 789, 0, 0, 0, 526, 0, 341,
|
|
527, 0, 987, 0, 0, 0, 741, 0, 739, 736,
|
|
731, 735, 733, 0, 45, 0, 464, 451, 206, 335,
|
|
337, 0, 0, 0, 970, 965, 132, 0, 1013, 422,
|
|
0, 0, 417, 961, 0, 0, 45, 815, 826, 827,
|
|
832, 836, 829, 837, 838, 839, 833, 835, 834, 830,
|
|
831, 0, 0, 0, 0, 286, 0, 0, 0, 0,
|
|
939, 934, 473, 0, 1006, 728, 916, 0, 0, 891,
|
|
105, 307, 302, 304, 306, 0, 0, 0, 1076, 728,
|
|
1077, 1078, 45, 1119, 728, 1146, 1142, 728, 1191, 0,
|
|
1075, 45, 1079, 0, 1080, 0, 1064, 728, 1153, 728,
|
|
1106, 728, 1136, 728, 1216, 1217, 1218, 1226, 1227, 45,
|
|
1221, 1219, 1220, 0, 0, 0, 0, 394, 0, 0,
|
|
1273, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 1296, 0, 0, 0, 45, 45, 0, 0, 1306,
|
|
0, 0, 0, 0, 0, 31, 176, 175, 0, 0,
|
|
120, 114, 108, 0, 0, 162, 599, 167, 0, 249,
|
|
247, 265, 258, 263, 217, 223, 599, 0, 241, 237,
|
|
224, 0, 234, 0, 271, 270, 0, 226, 230, 0,
|
|
0, 0, 0, 0, 231, 0, 427, 387, 349, 398,
|
|
0, 584, 596, 598, 597, 0, 431, 0, 0, 810,
|
|
0, 434, 0, 986, 757, 730, 0, 0, 45, 0,
|
|
0, 0, 845, 975, 846, 1019, 0, 1016, 1018, 421,
|
|
420, 0, 0, 0, 818, 0, 828, 0, 289, 0,
|
|
0, 766, 763, 720, 715, 716, 718, 719, 942, 1008,
|
|
1012, 0, 0, 382, 0, 0, 0, 0, 310, 309,
|
|
522, 0, 0, 0, 1120, 1143, 0, 1190, 1189, 0,
|
|
0, 0, 1065, 1154, 1107, 1137, 1225, 1239, 0, 0,
|
|
393, 0, 0, 1272, 1269, 903, 904, 905, 902, 907,
|
|
901, 908, 900, 899, 898, 906, 894, 0, 0, 45,
|
|
1268, 1271, 1270, 1282, 1283, 1281, 1289, 1287, 0, 1290,
|
|
0, 1292, 0, 0, 1253, 0, 1308, 1309, 45, 1301,
|
|
1302, 1303, 1304, 1310, 1311, 0, 0, 0, 796, 163,
|
|
164, 0, 0, 240, 599, 242, 0, 281, 229, 0,
|
|
273, 272, 275, 276, 278, 474, 0, 771, 770, 772,
|
|
0, 768, 432, 0, 998, 435, 0, 742, 740, 0,
|
|
732, 0, 0, 0, 1015, 419, 847, 0, 0, 0,
|
|
0, 912, 0, 0, 0, 0, 0, 0, 0, 287,
|
|
292, 291, 0, 0, 0, 1005, 918, 919, 0, 843,
|
|
892, 892, 305, 1092, 1091, 1090, 1097, 1098, 1099, 1096,
|
|
1093, 1095, 1094, 1103, 1100, 1101, 1102, 0, 1087, 1131,
|
|
1130, 1132, 1133, 0, 1192, 1082, 1084, 1083, 0, 1086,
|
|
1085, 0, 1028, 1275, 1274, 0, 0, 0, 1297, 0,
|
|
1255, 45, 1256, 1258, 1307, 0, 797, 0, 173, 266,
|
|
0, 0, 228, 227, 0, 0, 767, 511, 0, 0,
|
|
0, 467, 1017, 824, 823, 0, 821, 863, 860, 0,
|
|
0, 0, 0, 910, 911, 0, 0, 0, 0, 0,
|
|
717, 923, 1011, 45, 0, 0, 0, 0, 0, 1129,
|
|
1186, 1081, 45, 0, 0, 895, 0, 1254, 45, 1251,
|
|
45, 1252, 1305, 0, 0, 252, 232, 496, 769, 758,
|
|
745, 738, 743, 0, 0, 820, 866, 861, 0, 0,
|
|
0, 0, 0, 0, 0, 849, 0, 855, 0, 468,
|
|
721, 0, 0, 842, 45, 45, 889, 1089, 1088, 0,
|
|
0, 896, 0, 1294, 0, 0, 800, 794, 798, 168,
|
|
0, 0, 466, 822, 0, 0, 0, 0, 858, 0,
|
|
841, 0, 909, 859, 0, 848, 0, 854, 0, 924,
|
|
0, 0, 0, 1128, 0, 0, 355, 0, 0, 0,
|
|
497, 0, 748, 0, 746, 749, 864, 865, 0, 867,
|
|
869, 0, 0, 0, 850, 856, 469, 920, 890, 888,
|
|
0, 897, 45, 45, 799, 751, 752, 0, 744, 0,
|
|
862, 0, 857, 840, 0, 0, 0, 0, 0, 0,
|
|
750, 753, 747, 868, 0, 0, 872, 913, 851, 1022,
|
|
1257, 1259, 754, 0, 0, 0, 870, 45, 1021, 755,
|
|
874, 873, 45, 0, 0, 0, 875, 880, 882, 883,
|
|
1023, 1024, 0, 0, 0, 45, 871, 45, 45, 599,
|
|
886, 885, 884, 876, 0, 878, 879, 0, 881, 0,
|
|
45, 887, 877
|
|
};
|
|
|
|
/* YYPGOTO[NTERM-NUM]. */
|
|
static const yytype_int16 yypgoto[] =
|
|
{
|
|
-2221, -2221, -2221, -2221, -2221, 10, 1808, 1179, -2221, -2221,
|
|
-667, -31, -2221, -2221, -400, -2221, 806, -2221, -50, 1173,
|
|
-2221, -2221, -2221, 2675, 66, -2221, -2221, -2221, -2221, -2221,
|
|
-2221, 196, 487, 897, -2221, -2221, -2221, -2221, -2221, -2221,
|
|
-2221, -2221, -169, -907, -2221, -2221, -2221, 994, 490, 1513,
|
|
-2221, -191, -1580, 209, -2221, -2221, -2221, -2221, -2221, -2221,
|
|
1507, -270, -335, -2221, -2221, -2221, 1505, -2221, -408, -2221,
|
|
-2221, -2221, -2221, 1389, -2221, -2221, 794, -1287, -1543, 1175,
|
|
472, -1546, -167, -15, 1180, -2221, 208, 217, -1818, -2221,
|
|
-1552, -1257, -1550, -261, -2221, 4, -1587, -1798, -1393, -2221,
|
|
-2221, 630, 967, 391, -55, 124, -2221, 650, -2221, -2221,
|
|
-2221, -2221, -2221, -69, -2221, -1469, -220, 1107, -2221, 1088,
|
|
721, 748, -377, -2221, -2221, 1059, -2221, -2221, -2221, -2221,
|
|
439, 440, 2083, 2922, -362, -1314, 222, -439, -1019, 1093,
|
|
-576, -596, 1860, 19, 1701, -881, -879, -2221, -2221, -625,
|
|
-615, -218, -2221, -792, -2221, -594, -953, -1128, -2221, -2221,
|
|
-2221, 207, -2221, -2221, 1455, -2221, -2221, 1937, -2221, 1938,
|
|
-2221, -2221, 767, -2221, -387, 15, -2221, -2221, 1939, 1941,
|
|
-2221, 733, -2221, -711, -187, 1386, -2221, 1112, -2221, -2221,
|
|
-113, -2221, 1155, 538, -2221, 4421, -391, -1099, -2221, -2221,
|
|
-2221, -2221, -2221, -2221, -2221, -186, -2221, 522, -931, -2221,
|
|
-2221, -2221, 369, -1281, -620, 1195, -930, -369, -384, -456,
|
|
645, 5, -2221, -2221, -2221, 1537, -2221, -2221, 1124, -2221,
|
|
-2221, 1094, -2221, 1362, -1975, 1024, -2221, -2221, -2221, 1545,
|
|
-2221, 1542, -2221, 1544, -2221, 1547, -1011, -2221, -2221, -2221,
|
|
-122, -233, -2221, -2221, -2221, -402, -2221, 825, 789, -373,
|
|
791, -2221, 47, -2221, -2221, -2221, -332, -2221, -2221, -2221,
|
|
-1907, -2221, -2221, -2221, -2221, -2221, -1446, -515, 201, -2221,
|
|
-176, -2221, 1410, 1200, -2221, -2221, 1201, -2221, -2221, -2221,
|
|
-2221, -295, -2221, -2221, 1131, -2221, -2221, 1178, -2221, 269,
|
|
1197, -2221, -2221, -826, -2221, -2220, -2221, -226, -2221, -2221,
|
|
231, -2221, -760, -392, 1785, 1441, -2221, -2221, -1659, -2221,
|
|
-2221, -2221, -2221, -2221, -174, -2221, -2221, -2221, -314, -2221,
|
|
-339, -2221, -358, -2221, -357, -1871, -1200, -764, -2221, -102,
|
|
-484, -1024, -2067, -2221, -2221, -2221, -491, -1805, 475, -2221,
|
|
-756, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221,
|
|
-488, -1473, 743, -2221, 224, -2221, 1575, -2221, 1739, -2221,
|
|
-2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -1440, 786,
|
|
-2221, 1485, -2221, -2221, -2221, -2221, 1868, -2221, -2221, -2221,
|
|
285, 1842, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221,
|
|
-2221, -2221, -2221, 704, -2221, -2221, -2221, 238, -2221, -2221,
|
|
-2221, -2221, -49, -1941, -2221, -2221, -2221, -2221, -2221, -2221,
|
|
-2221, -2221, -2221, -2221, -2221, -2221, -2221, 627, 445, -530,
|
|
-1309, -1245, -1318, -1443, -1435, -1432, -2221, -1427, -1426, -1255,
|
|
-2221, -2221, -2221, -2221, -2221, 429, -2221, -2221, -2221, -2221,
|
|
-2221, 474, -1424, -1423, -2221, -2221, -2221, 427, -2221, -2221,
|
|
471, -2221, 303, -2221, -2221, -2221, -2221, 444, -2221, -2221,
|
|
-2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221, -2221,
|
|
-2221, -2221, -2221, 227, -2221, 223, -94, -2221, -2221, -2221,
|
|
-2221, -2221, -2221, -2221, -2221, 1047, -2221, 1042, -2221, -851,
|
|
-2221, 216, -2221, -2221, -2221, 428, 732, -2221, -2221, -2221,
|
|
1400, -2221, -2221, -2221, -2221, -2221, -2025, -95, -2221, -2221,
|
|
-2221, -2221, 718, -2221, -2221, -2221, -2221, -2221, -2221, 56,
|
|
-2221, 715, -2221, -2221, -2221, -2221, 709, -2221, -2221, -2221,
|
|
-2221, -2221, 705, -2221, 22, -2221, 1286
|
|
};
|
|
|
|
/* YYDEFGOTO[NTERM-NUM]. */
|
|
static const yytype_int16 yydefgoto[] =
|
|
{
|
|
-1, 1, 6, 7, 209, 387, 210, 844, 755, 211,
|
|
910, 623, 808, 693, 573, 908, 909, 444, 2262, 1227,
|
|
1518, 212, 213, 624, 1131, 1132, 214, 215, 216, 583,
|
|
1298, 1299, 1135, 1300, 217, 218, 219, 220, 1160, 221,
|
|
222, 1161, 223, 586, 224, 225, 226, 227, 1596, 1597,
|
|
925, 1608, 944, 1886, 228, 229, 230, 231, 232, 233,
|
|
789, 1171, 1172, 234, 235, 236, 750, 1083, 1084, 237,
|
|
238, 714, 456, 937, 938, 1624, 939, 940, 1924, 1634,
|
|
1639, 1640, 1925, 1926, 1635, 1636, 1637, 1626, 1627, 1628,
|
|
1629, 1898, 1631, 1632, 1633, 1900, 2144, 1928, 1929, 1930,
|
|
1173, 1174, 1490, 1491, 2015, 1745, 1152, 1153, 239, 461,
|
|
240, 854, 2032, 2033, 1777, 2034, 1034, 722, 723, 1057,
|
|
1058, 1046, 1047, 241, 760, 761, 762, 763, 1099, 1451,
|
|
1452, 1453, 400, 377, 407, 1343, 1648, 1344, 892, 1006,
|
|
626, 645, 627, 628, 629, 630, 2078, 1086, 977, 1938,
|
|
827, 631, 632, 633, 634, 635, 1348, 1650, 636, 1318,
|
|
1935, 1416, 1397, 1417, 1027, 1144, 242, 243, 1976, 244,
|
|
245, 696, 1039, 1040, 713, 426, 246, 247, 248, 249,
|
|
1090, 1091, 1445, 1945, 1946, 1077, 250, 251, 252, 253,
|
|
1209, 254, 980, 1356, 255, 379, 731, 1434, 256, 257,
|
|
258, 259, 260, 261, 656, 648, 986, 987, 988, 262,
|
|
263, 264, 1003, 1004, 1009, 1010, 1011, 1345, 773, 649,
|
|
805, 568, 265, 266, 267, 717, 268, 733, 734, 269,
|
|
771, 772, 270, 502, 839, 840, 842, 271, 272, 769,
|
|
273, 824, 274, 818, 275, 705, 1074, 276, 277, 2194,
|
|
2195, 2196, 2197, 1731, 1071, 410, 725, 726, 1070, 1696,
|
|
1760, 1967, 1968, 2451, 2452, 2523, 2524, 2546, 2560, 2561,
|
|
1765, 1965, 278, 279, 1747, 677, 813, 814, 1953, 2300,
|
|
2301, 1954, 674, 675, 280, 281, 282, 283, 2108, 2109,
|
|
2487, 2488, 284, 758, 759, 285, 710, 711, 286, 689,
|
|
690, 287, 288, 1150, 1737, 2184, 2405, 2406, 1997, 1998,
|
|
1999, 2000, 2001, 707, 2002, 2003, 2004, 2466, 1234, 2005,
|
|
2468, 2006, 2007, 2008, 2408, 2456, 2496, 2528, 2529, 2565,
|
|
2566, 2585, 2586, 2587, 2588, 2589, 2600, 2009, 2206, 2425,
|
|
820, 2083, 2246, 2247, 2248, 2010, 832, 1505, 1506, 2027,
|
|
1167, 2422, 289, 290, 291, 292, 293, 294, 295, 296,
|
|
801, 1169, 1170, 1753, 1754, 297, 848, 298, 784, 299,
|
|
785, 300, 1147, 301, 302, 303, 304, 305, 1107, 1108,
|
|
306, 766, 307, 308, 309, 685, 686, 310, 311, 1419,
|
|
1686, 719, 312, 313, 780, 314, 315, 316, 317, 318,
|
|
319, 320, 1244, 1245, 321, 1177, 1761, 1762, 2335, 322,
|
|
1724, 2176, 2177, 1763, 323, 2578, 324, 325, 326, 327,
|
|
1253, 328, 329, 330, 331, 332, 333, 1210, 1808, 866,
|
|
1786, 1787, 1788, 1812, 1813, 1814, 2368, 1815, 1816, 1789,
|
|
2212, 2478, 2357, 334, 1216, 1836, 335, 336, 337, 338,
|
|
1200, 1790, 1791, 1792, 2363, 339, 1218, 1840, 340, 1206,
|
|
1795, 1796, 1797, 341, 342, 343, 1212, 1830, 344, 345,
|
|
346, 347, 348, 349, 350, 351, 352, 353, 354, 355,
|
|
356, 357, 358, 1801, 1802, 867, 1527, 359, 360, 361,
|
|
362, 363, 364, 877, 878, 879, 1228, 1229, 1230, 1235,
|
|
1846, 1847, 365, 366, 367, 1241, 1242, 368, 883, 884,
|
|
885, 369, 370, 371, 372, 373, 2263, 2264, 2439, 2441,
|
|
374, 1256, 1257, 1258, 1259, 1260, 1261, 1262, 2079, 2080,
|
|
1264, 1265, 1266, 1267, 1268, 1270, 1271, 2094, 900, 2092,
|
|
375, 1274, 1275, 2098, 2099, 2104, 561
|
|
};
|
|
|
|
/* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
|
|
positive, shift that token. If negative, reduce the rule whose
|
|
number is the opposite. If YYTABLE_NINF, syntax error. */
|
|
static const yytype_int16 yytable[] =
|
|
{
|
|
413, 825, 821, 708, 682, 833, 834, 835, 836, 978,
|
|
1475, 1105, 1401, 1251, 874, 1252, 678, 720, 1306, 804,
|
|
1720, 697, 1350, 982, 1625, 1755, 1645, 735, 1894, 738,
|
|
1237, 425, 425, 747, 741, 742, 743, 946, 433, 647,
|
|
1012, 571, 744, 1092, 647, 746, 2178, 748, 1748, 1778,
|
|
1357, 1927, 2202, 996, 1630, 1487, 702, 1981, 1982, 1983,
|
|
1430, 2086, 1897, 2088, 1899, 1008, 1008, 460, 479, 1254,
|
|
405, 2265, 482, 653, 751, 1377, 657, 659, 427, 796,
|
|
1081, 816, 1913, 1007, 1007, 1190, 440, 1822, 1917, 1189,
|
|
405, 777, 1658, 1932, 797, 1823, 810, 2128, 1824, 1378,
|
|
1959, -564, -566, 1825, 1826, 793, 1828, 1829, -542, 462,
|
|
798, -585, 2, 3, 806, 2359, 809, 405, 970, 592,
|
|
594, 701, 2134, 2135, 1770, 599, 477, 1564, -594, 828,
|
|
-595, 598, 857, -588, 46, 1565, 1571, -592, 1974, 2341,
|
|
-594, 843, -595, 846, 2590, -588, 1251, 8, 1396, -592,
|
|
852, 1547, 1566, 25, 504, 1496, 1455, 598, 29, 1476,
|
|
1508, 598, 1025, -590, 671, 1605, 672, 74, -528, 1415,
|
|
905, 1063, 687, 1780, 1799, -590, 728, 376, 1550, -138,
|
|
47, 48, 1347, 1347, 424, 989, 906, 598, 598, 991,
|
|
886, 905, 598, -340, 585, 1456, 998, 2467, 598, -142,
|
|
96, 2266, 2081, -566, 1232, 2085, 593, -585, 996, -564,
|
|
1811, 424, 1821, 598, 1834, 408, -566, 574, 972, 1809,
|
|
598, 1819, 598, 1832, 1064, 1838, -62, 1775, 598, 598,
|
|
109, 1236, 443, 1156, 90, -528, -594, 2267, -595, -1116,
|
|
2141, -588, 972, 915, 95, -592, 1858, 600, 985, -542,
|
|
815, 2360, 1065, 927, 928, 929, 930, 647, -793, -793,
|
|
2481, 1771, 4, 602, 1782, -1141, 424, 997, 981, 1457,
|
|
999, -590, 2142, 1817, 1223, 1827, 646, 1835, 500, 1106,
|
|
2591, 646, -528, 1810, 1516, 1820, 2535, 1833, 424, 1839,
|
|
121, -340, 1066, 424, 424, -1063, -1152, 603, 1163, 621,
|
|
-1168, 1567, 1568, 1067, 1572, 2361, -1171, 2283, 1477, 1041,
|
|
2435, 1551, 424, 698, 1552, 424, 2362, 1794, 1712, 737,
|
|
-138, -1105, 931, 1573, 811, 1036, 1072, 699, -1135, -340,
|
|
-1115, 1068, 2133, 424, 1168, 2182, -1140, -1062, 1202, 424,
|
|
-142, 2290, 2291, 1026, -566, 673, 676, 1158, -585, 971,
|
|
-564, 683, 684, 688, 684, 1093, 692, 694, 1901, 1903,
|
|
700, 1351, 704, 706, 706, 709, 1045, -62, 712, 5,
|
|
2129, 716, 2178, 712, 1610, 2131, 1658, -594, 727, -595,
|
|
-1116, 732, -588, 712, 1975, 712, -592, 510, 1822, 425,
|
|
712, 712, 712, 996, 2087, 996, 1823, 598, 712, 1824,
|
|
745, 712, 996, 712, 1825, 1826, -1141, 1828, 1829, 756,
|
|
757, 1008, -590, 1165, 1651, 2228, 768, 770, 1157, 1704,
|
|
1159, 776, 1507, 647, 1069, 1513, 1447, 647, 783, 1375,
|
|
1515, 787, 511, 424, 647, 740, -1063, -1152, 424, -383,
|
|
1719, -1168, 829, 800, 1185, 1742, 807, -1171, 1664, 1666,
|
|
1668, 1559, 727, 817, 819, 819, 753, 823, 800, 1384,
|
|
1442, 598, -1105, 1155, 831, 831, 831, 831, 831, -1135,
|
|
841, -1115, 1621, 845, 1919, 847, 783, -1140, -1062, 850,
|
|
1044, 408, 853, 1385, 1749, 791, 858, 1685, 1001, 598,
|
|
1464, 598, 799, 567, 646, 1312, 1051, 876, 1386, 1293,
|
|
1811, 2304, 1294, 1387, 1388, -1151, 1892, 1893, 1184, 1809,
|
|
1389, 1186, 1606, 1821, 598, 875, 1008, 2557, 2558, 1834,
|
|
572, 2365, 1819, 911, 1615, 1616, 2533, 424, 1832, 1622,
|
|
917, 1304, 1838, 899, 1007, 1023, 1365, 1366, 1367, 1368,
|
|
1369, 907, 2494, 2076, 912, 913, 914, 700, 1024, 2288,
|
|
2525, 575, 920, 921, 1305, 2205, 926, 700, 700, 700,
|
|
700, 576, 996, 1817, 934, 935, 1897, 2209, 1899, -1167,
|
|
1030, 2192, 577, 1810, 2495, 1743, 1827, 1467, 1468, 902,
|
|
903, 1623, 1835, 424, 2285, 647, 1820, 1110, 424, 1349,
|
|
698, 918, 1833, -384, 1098, 424, 1839, -1170, 601, -1104,
|
|
1621, 1340, 424, 621, 699, 1560, 2525, 2463, 1922, 424,
|
|
1469, 591, 579, 580, 2592, -231, 951, 992, 2366, 1021,
|
|
952, 993, -1134, 1625, 2139, 2140, -528, 1187, 2127, 2367,
|
|
716, 1014, 768, 823, 817, 704, 1019, 1032, 1197, 847,
|
|
-528, 922, 405, 2593, 1390, 578, -1151, 700, 967, 995,
|
|
406, 923, 2572, 1630, 424, 1219, 2235, 1622, 2236, 1310,
|
|
646, 972, 1220, 1221, 646, 712, 2579, 2237, 1043, 2238,
|
|
700, 646, 1910, 981, 621, 1391, 1002, 584, 2592, 1585,
|
|
1251, 1803, 1859, 1418, 1088, 1842, 1843, 1844, 1311, 1848,
|
|
1849, 587, 1283, 1060, 588, 1222, 424, 911, 1643, 2392,
|
|
50, 1911, 972, 2594, 1105, 1105, 1307, 2593, 1053, 1623,
|
|
-1167, 1919, 1920, 1921, 1100, 668, 669, 2434, 1082, 1392,
|
|
1087, 1054, 1357, 1089, 1008, 2037, 2606, 2608, 1134, 581,
|
|
1664, 1666, 1668, 1092, 589, 1139, 1103, 1780, -1170, 2612,
|
|
-1104, -383, 1007, 1803, 1644, 1061, 1133, 1199, 2292, 2293,
|
|
2294, 1205, 1181, 970, 1781, 1140, 1211, 1141, 1062, 1215,
|
|
1217, 1964, 1148, -1134, 1151, 1182, 1586, 700, 2477, 996,
|
|
996, 996, 996, 996, 647, 647, 647, 647, 647, 1884,
|
|
673, 1587, 1588, 1589, 1008, 1008, 1008, 1885, 1780, 1780,
|
|
590, 1103, 2239, 2240, 1381, 2241, 2242, 700, 1279, 1382,
|
|
118, 1192, 1663, 1665, 1667, 1781, 1781, 122, 2444, 598,
|
|
1352, 1280, 700, 595, 25, 700, -528, 1759, 1308, 29,
|
|
1309, 1193, 646, 1353, 596, 424, 2243, 1693, 1782, 1223,
|
|
1224, 1783, 1238, 1225, 1226, 597, 1784, 1243, 2127, 1358,
|
|
1422, 47, 48, 637, 1785, 1922, 1255, 1263, 1269, -384,
|
|
1780, 1273, 1359, 1576, -388, 1240, 1577, 1578, 1579, 2139,
|
|
2140, 973, 1804, 655, 2287, 2424, 976, 1781, 2244, 1580,
|
|
1581, 1276, 845, 641, 642, 643, 1407, 1592, 652, 1782,
|
|
1782, 2245, 1783, 1783, 1411, 616, 1805, 1301, 660, 1408,
|
|
1439, 1316, 661, 1461, 618, 90, 1806, 1412, 1479, 1233,
|
|
1233, 1807, 650, 1440, 2343, 95, 1462, 658, 992, 1313,
|
|
662, 1480, 993, 791, 1278, 2344, 2345, 1482, 663, 642,
|
|
643, 2346, 619, 2347, 1804, 664, 994, 992, 665, 1302,
|
|
1483, 993, 2348, 1485, 2349, 666, 2350, 2461, 642, 643,
|
|
995, 1782, 667, 1363, 1783, 994, 1486, 1023, 1805, 1784,
|
|
620, 121, 2119, 2120, 2121, 2122, 2123, 1785, 1806, 995,
|
|
1493, -385, 1499, 1807, 670, 1553, 1145, 1561, 1482, 2459,
|
|
2390, 1569, 1574, 1611, 1395, 1500, 2318, 1654, 1554, 1251,
|
|
1562, 1563, 1097, 1653, 1570, 1575, 2115, 644, 405, 1656,
|
|
951, 1251, 673, 2091, 952, 150, 1582, 1759, 1399, 2175,
|
|
721, 953, 954, 1590, 688, 1671, 1770, 621, 1651, 1583,
|
|
1507, 646, 646, 646, 646, 646, 1591, 709, 1672, 1002,
|
|
1002, 1673, 967, 1249, 2157, 1053, 2532, 2299, 1352, 2011,
|
|
2162, 1705, 1685, 1706, 1681, 1683, 1675, 1941, 1677, 1601,
|
|
1602, 1680, 1432, 911, 2089, 2090, 791, 732, 1684, 1687,
|
|
1703, 1458, 2100, 2101, 1697, 1692, 1699, 2531, 2351, 622,
|
|
1713, 2352, 1688, 757, 1766, 1598, 1008, 1008, 1008, 791,
|
|
2319, 2084, 681, 1714, 1251, 1249, 2156, 1767, 770, 2235,
|
|
1415, 2236, -386, 1604, 1947, 1665, 1667, 1523, 1769, 1411,
|
|
2237, 25, 2238, 1526, 976, 1481, 29, 1529, 1249, 1531,
|
|
1529, 1529, 1957, 1533, 1455, 1535, 679, 1443, 1722, 1249,
|
|
1507, 1978, 1507, 1347, 1347, 1347, 1347, 1347, 47, 48,
|
|
680, 992, 1984, 1461, 972, 993, 1734, 2019, 695, -853,
|
|
992, 718, 642, 643, 993, 1499, 1985, 1370, 1511, 994,
|
|
2020, 642, 643, 1771, 2320, 703, 2353, 2023, 2021, 715,
|
|
2049, 730, 569, 995, 764, 1774, 2321, 2069, 2322, 2323,
|
|
2024, 2324, 995, 2050, 2325, 1203, 1204, 992, 1207, 736,
|
|
2070, 993, 90, 749, 2116, 2136, -588, 788, 642, 643,
|
|
2167, 1542, 95, 1489, 754, 994, 424, 2117, 2137, 1936,
|
|
1857, 1875, 1876, 2168, 1284, 1544, 1555, 1556, 1557, 995,
|
|
1944, 1544, 2067, 2068, 2354, 2355, 2356, 1544, 2172, 767,
|
|
1549, 2232, 1700, 1544, 2173, 2239, 2240, 1457, 2241, 2242,
|
|
2174, 774, 1584, 2227, 2233, 775, 2234, 778, 121, 1055,
|
|
781, 1056, 782, 2249, 611, 729, 786, 1285, 612, 613,
|
|
614, 615, 790, 1286, 2273, 2274, 2250, 1593, 907, 2243,
|
|
2038, 616, 2040, 2041, 794, 2326, 795, 2327, 617, 822,
|
|
618, 570, 1544, 830, 2045, 855, 1766, 2299, 856, 1287,
|
|
859, 1603, 150, 1499, 2052, 2252, 2054, 700, 1939, 2253,
|
|
882, 1313, 1614, 1615, 1616, 1766, 2254, 1482, 619, 2139,
|
|
2140, 2244, 1482, 1288, 1617, 1289, 2258, 2268, 2255, 1682,
|
|
2256, 904, 1955, 1618, 2245, 2257, 1482, 1482, 2276, 2259,
|
|
2269, 2313, 2147, 2419, 1961, 1977, 620, 1544, 1963, 2270,
|
|
2271, 2277, 1181, 1499, 2314, 1544, 1619, 2381, 1290, 2381,
|
|
2316, 1620, 916, 1291, 943, 2337, 2339, 1292, 2371, 861,
|
|
2382, 1293, 2383, -1191, 1294, 625, 880, 860, 996, 862,
|
|
1610, 1251, 1669, 424, 1902, 1904, 863, 864, 865, 1621,
|
|
609, 610, 868, 869, 870, 871, 1295, 872, 873, 1371,
|
|
1372, 2395, 2428, 621, 1740, 2398, 881, 1251, 1360, 2378,
|
|
1296, 887, 1361, 611, 2396, 2429, 1297, 612, 613, 614,
|
|
615, 2136, 1002, 2601, 2602, 1695, 1695, 894, 1695, 2454,
|
|
616, 1249, 1499, 895, 2446, 2475, 712, 617, 1082, 618,
|
|
1082, 1461, 2455, 1707, 2470, 2473, 1622, 1499, 2476, 1766,
|
|
2506, 2249, 2249, 2547, 2498, 622, 2549, 1461, 1499, 1181,
|
|
2500, 1249, 2502, 2507, 2538, 2539, 2548, 619, 647, 2550,
|
|
2552, 2553, 2554, 1746, 2569, 1730, 896, 1354, 2381, 1951,
|
|
2511, 2512, 611, 2381, 1151, 972, 612, 613, 614, 615,
|
|
1744, 2570, 1772, 897, 1773, 620, 2571, 2575, 1623, 616,
|
|
700, 2595, 1647, 1948, 1949, 1950, 617, 898, 618, 919,
|
|
2576, 901, 973, 974, 2596, 2611, 975, 1776, 976, 1845,
|
|
562, 563, 564, 565, 566, 979, 1732, 1213, 1214, 1000,
|
|
1020, 990, 424, 1243, 811, 1031, 619, 1033, 1029, 1035,
|
|
1042, 1993, 1048, 1052, 408, 1073, 983, 1076, 1240, 1255,
|
|
984, 2556, 621, 1078, 1263, 970, 803, 642, 643, 1094,
|
|
1095, 1096, 1269, 1101, 620, 1109, 1164, 1342, 616, 1779,
|
|
1273, 1138, 1175, 1111, 1188, 1178, 1179, 618, 779, 1191,
|
|
1134, 1194, 1890, 1202, 1208, 1233, 1233, 1233, 1281, 1233,
|
|
1233, 1231, 1249, 1850, 1883, 803, 642, 643, 1272, 598,
|
|
1317, 424, 1320, 1341, 622, 619, 952, 616, 2421, 2158,
|
|
791, 993, 1373, 826, -343, 1379, 618, 1380, 1400, 1410,
|
|
1402, 621, 1446, 838, 1912, 1424, 1425, 2160, 1426, 1427,
|
|
1428, 1429, 1438, 620, 1441, 2147, 1607, 1923, 985, 1459,
|
|
1444, 611, 1450, -936, 619, 612, 613, 614, 615, 1460,
|
|
1465, 1466, 1471, 1484, 1470, 1478, 1707, 1494, 616, 1707,
|
|
1707, 1707, 1497, 1498, 1502, 617, 2204, 618, 1501, 1952,
|
|
644, 1166, 620, 622, 1503, 1512, 1514, 888, 889, 890,
|
|
891, 893, 2297, 1105, 1473, 2462, 1507, 611, 1504, 1536,
|
|
621, 612, 613, 614, 615, 619, 1521, 1524, 1537, 1538,
|
|
1539, 712, 1540, 1541, 616, 646, 1002, 985, 1544, 644,
|
|
1545, 617, 1546, 618, 1549, 922, 1595, 1600, 1638, 1641,
|
|
1646, 1986, 1647, 620, 1652, 1702, 1657, 1660, 1661, 621,
|
|
1662, 376, 1670, 1676, 985, 1456, 945, 947, 948, 1089,
|
|
949, 619, 622, 406, 1693, 2509, 1710, 950, 1715, 1716,
|
|
1717, 1718, 2340, 1734, 1729, 1741, 1750, 1768, 1851, 1854,
|
|
424, 826, 1855, 1856, 1905, 1233, 1233, 1233, 1860, 620,
|
|
2530, 1105, 1861, 2030, 2031, 1862, 1863, 2281, 1864, 1759,
|
|
621, 622, 1866, 1867, 611, 1868, 1870, 2284, 612, 613,
|
|
614, 615, 1871, 1872, 1873, 1877, 1878, 985, 2048, 1879,
|
|
1284, 616, 1880, 1028, 1881, 1887, 424, 1889, 617, 639,
|
|
618, 1906, 1915, 640, 2521, 1936, 1907, 802, 1038, 641,
|
|
642, 643, 1908, 2530, 1909, 1055, 621, 803, 642, 643,
|
|
611, 616, 622, 1918, 612, 613, 614, 615, 619, 616,
|
|
618, 1931, 2082, 1285, 1933, 1937, 1059, 616, 618, 1956,
|
|
1240, 1958, 1969, 1075, 617, 1970, 618, 2097, 1971, 1079,
|
|
1080, 2103, 2413, 2414, 1973, -495, 620, 1987, 619, 1988,
|
|
1994, 1995, 1996, 2013, 2014, 1287, 619, 2016, 622, 2017,
|
|
2018, 2025, 2028, 2029, 619, 1770, 1771, 2035, 2036, 2039,
|
|
2042, 2051, 2053, 2055, 621, 2138, 620, 2074, 2075, 1288,
|
|
2064, 1289, 2065, 424, 620, 1137, 2066, 2071, 2072, 791,
|
|
1233, 2095, 620, 1233, 2077, 2096, 1423, 2130, 1923, 1923,
|
|
1923, 791, 2105, 621, 2110, 2118, -382, 1431, 2125, 2126,
|
|
1923, 2143, 2146, 644, 1290, 2150, 2149, 2151, 2207, 1291,
|
|
2152, 644, 2153, 1292, 2155, 2154, 2165, 1293, 2171, 424,
|
|
1294, 2458, 2460, 621, 2170, 2275, 2397, 688, 2187, 2230,
|
|
2189, 621, 2231, 2251, 2261, 2278, 2279, -225, 2303, 621,
|
|
2286, 2317, 1295, 2333, 2330, 622, 2185, 2311, 1195, 1196,
|
|
837, 2332, 2331, 611, 2336, 2334, 1296, 612, 613, 614,
|
|
615, -844, 1297, 2338, 2364, 2358, 2372, 2375, 2376, 2380,
|
|
616, 2386, 2387, 2399, 791, 622, 2389, 617, 2393, 618,
|
|
791, 1744, 2400, 622, 2407, 1952, 2409, 2193, 2410, 2411,
|
|
1495, 622, 2213, 2412, 2415, 2416, 2417, 2203, 2423, 2427,
|
|
2443, 2219, 2432, 2431, 2208, 1776, 2438, 619, 2440, 2445,
|
|
2471, 2474, 2489, 1233, 2482, 2497, 2491, 2499, 2501, 1845,
|
|
2505, 2201, 2519, 2526, 1522, 2510, 2518, 2514, 2517, 2527,
|
|
1525, 582, 2537, 2540, 1528, 620, 1530, 2559, 2542, 2543,
|
|
1532, 2551, 1534, 2577, 1321, 1322, 1323, 1324, 1325, 1326,
|
|
1327, 1328, 1329, 1330, 1331, 1332, 1333, 1334, 1335, 1336,
|
|
1337, 1338, 1339, 2567, 2573, 2582, 1895, 2597, 2599, 826,
|
|
2598, 611, 424, 2610, 1355, 612, 613, 614, 615, 2592,
|
|
2190, 1362, 1277, 1364, 1282, 1594, 2111, 1888, 616, 1517,
|
|
2388, 1454, 621, 1233, 1891, 617, 1912, 618, 1374, 924,
|
|
2112, 933, 936, 1049, 1613, 1923, 1916, 1923, 1923, 1923,
|
|
1923, 1923, 1923, 13, 14, 1314, 15, 16, 2309, 2391,
|
|
1315, 20, 2282, 2289, 893, 619, 2132, 2124, 1492, 23,
|
|
1405, 1757, 2012, 2329, 27, 1739, 2188, 30, 2342, 951,
|
|
1403, 1420, 1689, 952, 622, 37, 1059, 38, 1674, 40,
|
|
953, 954, 1979, 620, 1449, 1980, 955, 956, 439, 958,
|
|
2609, 2148, 960, 961, 962, 963, 964, 792, 2161, 951,
|
|
1050, 967, 59, 952, 1679, 819, 2031, 1709, 1943, 1233,
|
|
953, 954, 1154, 70, 604, 605, 606, 956, 607, 958,
|
|
424, 1942, 960, 961, 962, 963, 964, 1409, 1013, 2377,
|
|
1376, 967, 1435, 1463, 1183, 1510, 1016, 85, 1015, 1017,
|
|
621, 2420, 1691, 1018, 2308, 2562, 1694, 2191, 2097, 2448,
|
|
93, 1162, 1393, 1394, 2544, 1448, 1413, 2159, 2493, 2186,
|
|
765, 1474, 1404, 1146, 2457, 2563, 2581, 2603, 102, 2426,
|
|
2605, 2026, 1756, 2198, 104, 1022, 849, 1721, 2163, 1488,
|
|
1102, 791, 108, 691, 110, 1923, 112, 1853, 114, 1701,
|
|
739, 2199, 622, 2057, 2402, 119, 2061, 2044, 2063, 2047,
|
|
2430, 2216, 893, 1509, 838, 2059, 2218, 791, 1543, 2073,
|
|
1548, 1852, 130, 131, 1239, 2226, 2437, 1865, 2374, 1869,
|
|
2384, 1874, 831, 831, 0, 1882, 0, 752, 0, 0,
|
|
143, 0, 2193, 0, 0, 951, 0, 608, 1736, 952,
|
|
0, 0, 0, 0, 0, 0, 953, 954, 0, 0,
|
|
0, 155, 955, 956, 156, 958, 752, 0, 960, 961,
|
|
962, 963, 964, 752, 0, 966, 0, 967, 968, 0,
|
|
0, 812, 1558, 0, 0, 0, 0, 0, 1793, 0,
|
|
0, 1798, 0, 0, 1818, 0, 1831, 0, 1837, 0,
|
|
1841, 0, 0, 0, 0, 0, 0, 0, 2450, 0,
|
|
0, 0, 0, 2472, 0, 0, 0, 0, 1103, 1103,
|
|
0, 0, 2480, 0, 0, 0, 0, 0, 2484, 0,
|
|
2485, 0, 0, 0, 2433, 1233, 0, 0, 1609, 13,
|
|
14, 0, 15, 16, 0, 0, 0, 20, 0, 0,
|
|
1642, 0, 2486, 0, 0, 23, 0, 0, 0, 0,
|
|
27, 0, 0, 30, 2082, 2082, 0, 0, 0, 0,
|
|
0, 37, 2113, 38, 0, 40, 0, 611, 1649, 0,
|
|
0, 612, 613, 614, 615, 0, 1233, 0, 0, 0,
|
|
1655, 0, 0, 932, 616, 0, 0, 0, 59, 0,
|
|
0, 617, 0, 618, 0, 0, 0, 2403, 0, 70,
|
|
0, 0, 611, 0, 0, 0, 612, 613, 614, 615,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 2486, 616,
|
|
2545, 619, 0, 85, 0, 0, 617, 0, 618, 1678,
|
|
1038, 2516, 0, 0, 0, 0, 93, 0, 0, 0,
|
|
0, 0, 0, 0, 1690, 0, 0, 752, 0, 620,
|
|
0, 1698, 0, 0, 102, 0, 619, 2583, 0, 0,
|
|
104, 893, 2584, 0, 0, 0, 0, 1708, 108, 1711,
|
|
110, 0, 112, 0, 114, 2584, 0, 2604, 2607, 0,
|
|
0, 119, 893, 0, 620, 1473, 424, 0, 611, 0,
|
|
2607, 0, 612, 613, 614, 615, 1726, 0, 130, 131,
|
|
0, 0, 0, 0, 0, 616, 621, 1738, 0, 0,
|
|
0, 0, 617, 0, 618, 0, 143, 0, 0, 0,
|
|
1752, 424, 0, 0, 0, 1758, 837, 1764, 0, 611,
|
|
0, 0, 0, 612, 613, 614, 615, 155, 0, 1085,
|
|
156, 621, 619, 0, 0, 2043, 616, 0, 0, 0,
|
|
2046, 0, 0, 617, 0, 618, 0, 1104, 622, 0,
|
|
0, 0, 0, 2056, 0, 0, 0, 0, 0, 0,
|
|
620, 1136, 0, 0, 0, 0, 0, 0, 951, 1142,
|
|
1143, 0, 952, 619, 1149, 2058, 0, 0, 0, 953,
|
|
954, 2060, 0, 622, 0, 2062, 956, 0, -1192, 0,
|
|
0, -1192, -1192, -1192, -1192, -1192, 0, 424, 0, 0,
|
|
967, 620, 1104, 0, 0, 0, 1037, 0, 0, 611,
|
|
1176, 0, 0, 612, 613, 614, 615, 621, 0, 0,
|
|
0, 0, 1473, 1896, 0, 611, 616, 0, 0, 612,
|
|
613, 614, 615, 617, 985, 618, 0, 0, 424, 1198,
|
|
0, 1201, 616, 0, 0, 0, 0, 0, 0, 617,
|
|
0, 618, 0, 0, 0, 0, 0, 0, 621, 0,
|
|
752, 752, 0, 619, 1940, 826, 1355, 0, 0, 622,
|
|
0, 0, 0, 1725, 1250, 1149, 611, 0, 0, 619,
|
|
612, 613, 614, 615, 0, 0, 0, 0, 0, 0,
|
|
0, 620, 0, 616, 0, 1960, 0, 0, 1962, 0,
|
|
617, 0, 618, 0, 0, 1751, 1966, 620, 611, 0,
|
|
622, 0, 612, 613, 614, 615, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 616, 0, 0, 424, 0,
|
|
619, 0, 617, 0, 618, 0, 0, 0, 1989, 0,
|
|
1992, 0, 0, 0, 424, 0, 0, 0, 621, 0,
|
|
0, 0, 0, 0, 1346, 1346, 0, 0, 620, 0,
|
|
0, 0, 619, 0, 621, 0, 0, 0, 0, 0,
|
|
2200, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
752, 752, 0, 0, 2211, 0, 0, 0, 0, 2214,
|
|
620, 0, 2215, 0, 0, 424, 0, 0, 0, 0,
|
|
622, 0, 2222, 0, 2223, 0, 2224, 1250, 2225, 0,
|
|
0, 0, 0, 0, 0, 621, 622, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 951, 0, 424, 0, 952,
|
|
1414, 0, 0, 0, 0, 0, 953, 954, 0, 0,
|
|
0, 0, 955, 956, 957, 958, 0, 621, 960, 961,
|
|
962, 963, 964, 965, 378, 966, 0, 967, 968, 0,
|
|
384, 0, 0, 0, 0, 0, 0, 622, 752, 0,
|
|
391, 0, 0, 393, 0, 0, 396, 0, 0, 0,
|
|
0, 0, 0, 402, 0, 0, 2093, 409, 0, 0,
|
|
0, 412, 0, 2102, 0, 0, 0, 2106, 2107, 622,
|
|
0, 0, 0, 0, 0, 2114, 0, 0, 0, 431,
|
|
0, 0, 0, 435, 436, 0, 0, 0, 0, 441,
|
|
442, 0, 0, 0, 0, 447, 448, 0, 450, 451,
|
|
452, 453, 0, 454, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 463, 0, 0, 0, 2145, 467, 0, 469,
|
|
0, 0, 1649, 472, 0, 0, 0, 476, 1104, 478,
|
|
0, 0, 0, 0, 0, 0, 484, 0, 0, 0,
|
|
488, 0, 0, 0, 491, 0, 493, 2164, 0, 0,
|
|
0, 0, 1991, 501, 503, 611, 2169, 505, 506, 612,
|
|
613, 614, 615, 512, 0, 513, 0, 0, 0, 517,
|
|
0, 611, 616, 2179, 2180, 612, 613, 614, 615, 617,
|
|
0, 618, 0, 0, 0, 0, 0, 611, 616, 0,
|
|
0, 612, 1005, 614, 615, 617, 544, 618, 546, 0,
|
|
0, 0, 1752, 0, 616, 551, 552, 0, 0, 619,
|
|
838, 617, 0, 618, 0, 0, 0, 0, 0, 0,
|
|
2210, 0, 0, 0, 0, 619, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 2220, 620, 2221, 0,
|
|
0, 619, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 620, 0, 0, 0, 0, 0, 1612,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 620,
|
|
0, 0, 0, 0, 424, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
424, 0, 0, 0, 621, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 424, 0, 0, 0,
|
|
621, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 752, 0, 0, 621, 0, 0, 0,
|
|
0, 0, 0, 2296, 0, 0, 0, 0, 2298, 0,
|
|
0, 0, 0, 0, 0, 0, 622, 0, 0, 2307,
|
|
1966, 0, 0, 0, 2312, 0, 0, 0, 0, 0,
|
|
0, 0, 622, 0, 2315, 0, 0, 0, 0, 0,
|
|
2328, 0, 0, 0, 0, 951, 0, 0, 622, 952,
|
|
611, 0, 0, 0, 0, 0, 953, 954, 0, 1085,
|
|
969, 1085, 955, 956, 957, 958, 959, 0, 960, 961,
|
|
962, 963, 964, 965, 0, 966, 0, 967, 968, 0,
|
|
1104, 1104, 0, 0, 2373, 0, 0, 0, 0, 724,
|
|
0, 1723, 0, 0, 0, 0, 0, 752, 0, 1733,
|
|
0, 0, 1735, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 2379, 812, 0, 0, 0, 1104, 1104,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 2385, 0,
|
|
0, 0, 0, 0, 1609, 0, 0, 0, 0, 0,
|
|
752, 0, 0, 0, 0, 0, 0, 1800, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 752, 752, 752, 0,
|
|
752, 752, 0, 0, 752, 0, 0, 0, 0, 0,
|
|
2404, 951, 0, 1727, 0, 952, 611, 0, 0, 0,
|
|
0, 1250, 953, 954, 0, 893, 0, 1728, 955, 956,
|
|
957, 958, 0, 851, 960, 961, 962, 963, 964, 965,
|
|
0, 966, 0, 967, 968, 0, 0, 1112, 0, 0,
|
|
1130, 1113, 611, 0, 969, 0, 0, 0, 1114, 1115,
|
|
0, 0, 0, 0, 1116, 1117, 1118, 1119, 0, 0,
|
|
1120, 1121, 1122, 1123, 1124, 1125, 1126, 1127, 0, 1128,
|
|
1129, 0, 0, 0, 0, 1914, 0, 2447, 2298, 0,
|
|
0, 2449, 0, 2453, 0, 0, 0, 0, 0, 0,
|
|
0, 969, 0, 0, 0, 0, 0, 0, 2464, 2465,
|
|
0, 2469, 0, 969, 0, 0, 0, 752, 0, 0,
|
|
0, 2479, 0, 0, 0, 0, 951, 0, 1180, 2483,
|
|
952, 611, 0, 0, 0, 0, 0, 953, 954, 0,
|
|
0, 0, 0, 955, 956, 957, 958, 2404, 0, 960,
|
|
961, 962, 963, 964, 965, 0, 966, 0, 967, 968,
|
|
0, 0, 0, 969, 969, 969, 969, 0, 969, 0,
|
|
0, 0, 0, 0, 0, 2515, 752, 752, 752, 0,
|
|
0, 0, 0, 2520, 2522, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 838, 0, 0, 2534, 0, 0,
|
|
0, 2536, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
969, 0, 969, 969, 969, 969, 1104, 0, 0, 0,
|
|
0, 0, 0, 893, 0, 0, 0, 0, 0, 0,
|
|
2522, 0, 0, 0, 2564, 0, 0, 0, 2568, 0,
|
|
0, 0, 1764, 0, 0, 0, 0, 0, 0, 951,
|
|
0, 0, 1246, 952, 611, 0, 1764, 2580, 2564, 0,
|
|
953, 954, 0, 0, 0, 0, 955, 956, 957, 958,
|
|
0, 969, 960, 961, 962, 963, 964, 965, 0, 966,
|
|
0, 967, 968, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 969, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 969, 0, 0, 0, 0, 0, 0,
|
|
1250, 752, 0, 0, 752, 0, 1104, 1104, 1104, 0,
|
|
1149, 1149, 1250, 0, 969, 0, 0, 0, 1149, 1149,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
969, 0, 0, 0, 969, 969, 0, 0, 0, 951,
|
|
0, 0, 1247, 952, 611, 1346, 1346, 1346, 1346, 1346,
|
|
953, 954, 0, 0, 0, 0, 955, 956, 957, 958,
|
|
0, 0, 960, 961, 962, 963, 964, 965, 0, 966,
|
|
0, 967, 968, 0, 0, 0, 0, 0, 0, 951,
|
|
0, 0, 1248, 952, 611, 0, 0, 0, 0, 0,
|
|
953, 954, 969, 0, 0, 1250, 955, 956, 957, 958,
|
|
0, 1414, 960, 961, 962, 963, 964, 965, 0, 966,
|
|
0, 967, 968, 951, 0, 0, 0, 952, 611, 0,
|
|
0, 0, 1303, 0, 953, 954, 0, 0, 0, 1319,
|
|
955, 956, 957, 958, 752, 2183, 960, 961, 962, 963,
|
|
964, 965, 0, 966, 0, 967, 968, 0, 0, 0,
|
|
969, 969, 0, 0, 951, 0, 0, 812, 952, 611,
|
|
0, 0, 0, 0, 0, 953, 954, 0, 1104, 0,
|
|
1398, 955, 956, 957, 958, 0, 0, 960, 961, 962,
|
|
963, 964, 965, 0, 966, 0, 967, 968, 0, 2217,
|
|
0, 0, 0, 951, 0, 1406, 0, 952, 611, 0,
|
|
0, 0, 0, 0, 953, 954, 0, 0, 0, 0,
|
|
955, 956, 957, 958, 752, 2229, 960, 961, 962, 963,
|
|
964, 965, 1383, 966, 0, 967, 968, 951, 0, 1421,
|
|
0, 952, 611, 0, 0, 0, 0, 0, 953, 954,
|
|
0, 0, 0, 0, 955, 956, 957, 958, 0, 0,
|
|
960, 961, 962, 963, 964, 965, 0, 966, 0, 967,
|
|
968, 0, 0, 0, 0, 0, 0, 1914, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 969, 969, 969, 969,
|
|
969, 969, 969, 969, 969, 969, 969, 969, 969, 969,
|
|
969, 969, 969, 969, 969, 0, 0, 2302, 0, 0,
|
|
752, 0, 2305, 0, 0, 0, 0, 0, 0, 0,
|
|
969, 0, 0, 0, 0, 0, 951, 969, 0, 969,
|
|
952, 611, 0, 0, 0, 0, 0, 953, 954, 969,
|
|
0, 0, 1433, 955, 956, 957, 958, 0, 0, 960,
|
|
961, 962, 963, 964, 965, 0, 966, 0, 967, 968,
|
|
951, 0, 0, 0, 952, 611, 0, 0, 0, 0,
|
|
969, 953, 954, 0, 0, 0, 1436, 955, 956, 957,
|
|
958, 0, 1250, 960, 961, 962, 963, 964, 965, 0,
|
|
966, 0, 967, 968, 951, 0, 0, 0, 952, 611,
|
|
0, 0, 0, 0, 0, 953, 954, 0, 1250, 0,
|
|
1437, 955, 956, 957, 958, 0, 0, 960, 961, 962,
|
|
963, 964, 965, 0, 966, 0, 967, 968, 0, 0,
|
|
0, 951, 0, 0, 0, 952, 611, 0, 0, 969,
|
|
0, 0, 953, 954, 0, 0, 0, 1472, 955, 956,
|
|
957, 958, 0, 969, 960, 961, 962, 963, 964, 965,
|
|
0, 966, 0, 967, 968, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 969, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 1104, 951, 0, 0, 1104, 952,
|
|
611, 0, 0, 0, 0, 0, 953, 954, 1599, 0,
|
|
0, 1519, 955, 956, 957, 958, 0, 0, 960, 961,
|
|
962, 963, 964, 965, 0, 966, 951, 967, 968, 0,
|
|
952, 611, 0, 969, 0, 752, 752, 953, 954, 0,
|
|
0, 0, 1520, 955, 956, 957, 958, 0, 0, 960,
|
|
961, 962, 963, 964, 965, 0, 966, 0, 967, 968,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 1104,
|
|
1104, 1104, 1104, 0, 951, 0, 0, 2183, 952, 611,
|
|
0, 0, 0, 0, 969, 953, 954, 752, 0, 0,
|
|
1659, 955, 956, 957, 958, 0, 0, 960, 961, 962,
|
|
963, 964, 965, 0, 966, 0, 967, 968, 0, 951,
|
|
0, 0, 0, 952, 611, 0, 0, 969, 0, 0,
|
|
953, 954, 0, 0, 969, 1934, 955, 956, 957, 958,
|
|
969, 1104, 960, 961, 962, 963, 964, 965, 0, 966,
|
|
0, 967, 968, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 969, 0, 0, 1104, 1104, 0, 1104,
|
|
0, 0, 0, 0, 0, 969, 2183, 0, 0, 0,
|
|
951, 0, 1727, 969, 952, 611, 0, 0, 0, 0,
|
|
0, 953, 954, 969, 0, 0, 969, 955, 956, 957,
|
|
958, 0, 0, 960, 961, 962, 963, 964, 965, 0,
|
|
966, 969, 967, 968, 0, 0, 0, 0, 0, 1104,
|
|
0, 0, 0, 969, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 969, 0, 0,
|
|
0, 0, 0, 969, 0, 380, 381, 382, 383, 969,
|
|
385, 0, 386, 0, 388, 389, 0, 390, 0, 0,
|
|
0, 392, 0, 394, 395, 0, 0, 397, 398, 399,
|
|
0, 401, 0, 403, 404, 0, 0, 411, 0, 0,
|
|
0, 0, 414, 415, 416, 417, 418, 419, 420, 421,
|
|
0, 422, 423, 0, 0, 428, 429, 430, 0, 432,
|
|
0, 434, 0, 0, 437, 438, 0, 0, 0, 0,
|
|
0, 0, 445, 446, 0, 0, 449, 0, 0, 0,
|
|
0, 0, 0, 455, 0, 457, 0, 458, 459, 0,
|
|
0, 0, 464, 465, 466, 0, 0, 468, 0, 0,
|
|
470, 471, 0, 473, 474, 475, 0, 0, 0, 0,
|
|
480, 481, 0, 0, 483, 0, 485, 486, 487, 0,
|
|
489, 490, 0, 0, 492, 0, 494, 495, 496, 497,
|
|
498, 499, 0, 0, 0, 0, 0, 0, 507, 508,
|
|
509, 969, 0, 0, 0, 514, 515, 516, 0, 518,
|
|
519, 520, 521, 522, 523, 524, 525, 526, 527, 528,
|
|
529, 530, 531, 532, 533, 534, 535, 536, 537, 538,
|
|
539, 540, 541, 542, 543, 0, 545, 0, 547, 0,
|
|
548, 0, 549, 550, 0, 969, 553, 554, 555, 556,
|
|
557, 558, 559, 560, 0, 0, 0, 951, 0, 0,
|
|
0, 952, 611, 0, 0, 969, 0, 969, 953, 954,
|
|
0, 969, 0, 1972, 955, 956, 957, 958, 0, 0,
|
|
960, 961, 962, 963, 964, 965, 0, 966, 0, 967,
|
|
968, 0, 0, 0, 969, 0, 0, 969, 0, 0,
|
|
0, 0, 0, 951, 0, 1990, 638, 952, 611, 651,
|
|
0, 654, 0, 0, 953, 954, 0, 0, 0, 1130,
|
|
955, 956, 957, 958, 0, 0, 960, 961, 962, 963,
|
|
964, 965, 0, 966, 951, 967, 968, 0, 952, 611,
|
|
0, 0, 0, 0, 0, 953, 954, 0, 0, 0,
|
|
2022, 955, 956, 957, 958, 0, 0, 960, 961, 962,
|
|
963, 964, 965, 0, 966, 0, 967, 968, 0, 951,
|
|
0, 2166, 0, 952, 611, 0, 0, 0, 0, 0,
|
|
953, 954, 0, 0, 0, 0, 955, 956, 957, 958,
|
|
0, 0, 960, 961, 962, 963, 964, 965, 969, 966,
|
|
0, 967, 968, 0, 951, 0, 2181, 969, 952, 611,
|
|
0, 969, 969, 0, 0, 953, 954, 0, 0, 969,
|
|
0, 955, 956, 957, 958, 0, 0, 960, 961, 962,
|
|
963, 964, 965, 0, 966, 951, 967, 968, 2260, 952,
|
|
611, 0, 0, 0, 0, 0, 953, 954, 0, 0,
|
|
969, 0, 955, 956, 957, 958, 0, 0, 960, 961,
|
|
962, 963, 964, 965, 0, 966, 0, 967, 968, 969,
|
|
0, 951, 0, 0, 969, 952, 611, 0, 0, 0,
|
|
0, 0, 953, 954, 969, 969, 0, 2272, 955, 956,
|
|
957, 958, 0, 0, 960, 961, 962, 963, 964, 965,
|
|
0, 966, 0, 967, 968, 0, 0, 0, 0, 0,
|
|
0, 0, 951, 0, 0, 969, 952, 611, 0, 0,
|
|
0, 0, 0, 953, 954, 969, 969, 0, 2280, 955,
|
|
956, 957, 958, 0, 0, 960, 961, 962, 963, 964,
|
|
965, 0, 966, 951, 967, 968, 0, 952, 611, 0,
|
|
0, 0, 0, 0, 953, 954, 0, 0, 0, 2295,
|
|
955, 956, 957, 958, 0, 0, 960, 961, 962, 963,
|
|
964, 965, 0, 966, 0, 967, 968, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 969, 0, 969, 951, 0, 0, 2306, 952, 611,
|
|
0, 0, 969, 0, 0, 953, 954, 969, 0, 0,
|
|
969, 955, 956, 957, 958, 0, 0, 960, 961, 962,
|
|
963, 964, 965, 969, 966, 0, 967, 968, 0, 951,
|
|
0, 0, 0, 952, 611, 0, 0, 0, 0, 0,
|
|
953, 954, 0, 941, 942, 2310, 955, 956, 957, 958,
|
|
0, 0, 960, 961, 962, 963, 964, 965, 0, 966,
|
|
0, 967, 968, 0, 0, 951, 0, 0, 969, 952,
|
|
611, 0, 0, 0, 969, 0, 953, 954, 0, 0,
|
|
969, 2369, 955, 956, 957, 958, 0, 0, 960, 961,
|
|
962, 963, 964, 965, 0, 966, 951, 967, 968, 969,
|
|
952, 611, 0, 0, 0, 0, 0, 953, 954, 0,
|
|
0, 0, 2370, 955, 956, 957, 958, 0, 0, 960,
|
|
961, 962, 963, 964, 965, 0, 966, 0, 967, 968,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 969, 0, 969, 0, 0, 0, 969, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 969,
|
|
969, 0, 0, 0, 969, 951, 0, 0, 2394, 952,
|
|
611, 0, 0, 0, 969, 0, 953, 954, 969, 0,
|
|
0, 0, 955, 956, 957, 958, 0, 0, 960, 961,
|
|
962, 963, 964, 965, 0, 966, 0, 967, 968, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
969, 0, 0, 0, 0, 969, 0, 969, 0, 0,
|
|
0, 951, 0, 0, 0, 952, 611, 9, 0, 969,
|
|
0, 969, 953, 954, 10, 0, 0, 2401, 955, 956,
|
|
957, 958, 0, 0, 960, 961, 962, 963, 964, 965,
|
|
0, 966, 0, 967, 968, 0, 0, 0, 0, 969,
|
|
0, 0, 0, 969, 11, 12, 13, 14, 0, 15,
|
|
16, 17, 18, 19, 20, 969, 0, 21, 22, 0,
|
|
0, 0, 23, 24, 25, 0, 26, 27, 28, 29,
|
|
30, 31, 0, 32, 33, 34, 35, 36, 37, 0,
|
|
38, 39, 40, 41, 42, 43, 0, 0, 44, 45,
|
|
46, 47, 48, 0, 0, 49, 50, 51, 52, 53,
|
|
54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
|
|
64, 65, 66, 67, 68, 69, 70, 0, 71, 0,
|
|
72, 73, 0, 74, 75, 76, 0, 0, 77, 0,
|
|
0, 78, 79, 0, 80, 81, 82, 83, 0, 84,
|
|
85, 86, 87, 88, 89, 90, 91, 92, 0, 0,
|
|
0, 0, 0, 93, 94, 95, 96, 0, 0, 0,
|
|
0, 97, 0, 0, 98, 99, 0, 0, 100, 101,
|
|
0, 102, 0, 0, 0, 103, 0, 104, 0, 105,
|
|
0, 0, 0, 106, 107, 108, 109, 110, 111, 112,
|
|
113, 114, 115, 0, 116, 117, 118, 0, 119, 0,
|
|
120, 121, 0, 122, 0, 123, 124, 125, 126, 0,
|
|
0, 127, 128, 129, 0, 130, 131, 132, 0, 133,
|
|
134, 135, 0, 136, 0, 137, 138, 139, 140, 141,
|
|
0, 142, 0, 143, 144, 0, 0, 145, 146, 147,
|
|
0, 0, 148, 149, 0, 150, 151, 0, 152, 153,
|
|
0, 0, 0, 154, 155, 0, 0, 156, 0, 0,
|
|
157, 0, 0, 0, 158, 159, 0, 0, 160, 161,
|
|
162, 0, 163, 164, 165, 166, 167, 168, 169, 170,
|
|
171, 172, 173, 0, 174, 0, 0, 175, 0, 0,
|
|
0, 176, 177, 178, 179, 180, 0, 181, 182, 0,
|
|
0, 183, 184, 185, 186, 0, 0, 0, 0, 187,
|
|
188, 189, 190, 191, 192, 0, 0, 0, 0, 0,
|
|
0, 0, 193, 0, 194, 0, 195, 196, 197, 198,
|
|
199, 0, 0, 0, 200, 201, 202, 203, 204, 205,
|
|
951, 206, 207, 2418, 952, 611, 208, 0, 0, 0,
|
|
0, 953, 954, 0, 0, 0, 0, 955, 956, 957,
|
|
958, 0, 0, 960, 961, 962, 963, 964, 965, 0,
|
|
966, 951, 967, 968, 2436, 952, 611, 0, 0, 0,
|
|
0, 0, 953, 954, 0, 0, 0, 0, 955, 956,
|
|
957, 958, 0, 0, 960, 961, 962, 963, 964, 965,
|
|
0, 966, 951, 967, 968, 0, 952, 611, 0, 0,
|
|
0, 0, 0, 953, 954, 0, 0, 0, 2442, 955,
|
|
956, 957, 958, 0, 0, 960, 961, 962, 963, 964,
|
|
965, 0, 966, 951, 967, 968, 2490, 952, 611, 0,
|
|
0, 0, 0, 0, 953, 954, 0, 0, 0, 0,
|
|
955, 956, 957, 958, 0, 0, 960, 961, 962, 963,
|
|
964, 965, 0, 966, 951, 967, 968, 0, 952, 611,
|
|
0, 0, 0, 0, 0, 953, 954, 0, 0, 0,
|
|
2492, 955, 956, 957, 958, 0, 0, 960, 961, 962,
|
|
963, 964, 965, 0, 966, 951, 967, 968, 0, 952,
|
|
611, 0, 0, 0, 0, 0, 953, 954, 0, 0,
|
|
0, 2503, 955, 956, 957, 958, 0, 0, 960, 961,
|
|
962, 963, 964, 965, 0, 966, 951, 967, 968, 2504,
|
|
952, 611, 0, 0, 0, 0, 0, 953, 954, 0,
|
|
0, 0, 0, 955, 956, 957, 958, 0, 0, 960,
|
|
961, 962, 963, 964, 965, 0, 966, 951, 967, 968,
|
|
2508, 952, 611, 0, 0, 0, 0, 0, 953, 954,
|
|
0, 0, 0, 0, 955, 956, 957, 958, 0, 0,
|
|
960, 961, 962, 963, 964, 965, 0, 966, 951, 967,
|
|
968, 0, 952, 611, 0, 0, 0, 0, 0, 953,
|
|
954, 0, 0, 0, 2513, 955, 956, 957, 958, 0,
|
|
0, 960, 961, 962, 963, 964, 965, 0, 966, 951,
|
|
967, 968, 0, 952, 611, 0, 0, 0, 0, 0,
|
|
953, 954, 0, 0, 0, 2541, 955, 956, 957, 958,
|
|
0, 0, 960, 961, 962, 963, 964, 965, 0, 966,
|
|
951, 967, 968, 2555, 952, 611, 0, 0, 0, 0,
|
|
0, 953, 954, 0, 0, 0, 0, 955, 956, 957,
|
|
958, 0, 0, 960, 961, 962, 963, 964, 965, 0,
|
|
966, 0, 967, 968, 951, 0, 2574, 0, 952, 611,
|
|
0, 0, 0, 0, 0, 953, 954, 0, 0, 0,
|
|
0, 955, 956, 957, 958, 0, 0, 960, 961, 962,
|
|
963, 964, 965, 0, 966, 951, 967, 968, 0, 952,
|
|
611, 0, 0, 0, 0, 0, 953, 954, 0, 0,
|
|
0, 0, 955, 956, 957, 958, 0, 0, 960, 961,
|
|
962, 963, 964, 965, 0, 966, 0, 967, 968
|
|
};
|
|
|
|
static const yytype_int16 yycheck[] =
|
|
{
|
|
50, 489, 486, 395, 381, 496, 497, 498, 499, 634,
|
|
1138, 767, 1031, 894, 544, 894, 378, 404, 925, 475,
|
|
1460, 390, 975, 638, 1311, 1498, 1340, 414, 1608, 416,
|
|
881, 62, 63, 433, 421, 422, 423, 613, 69, 257,
|
|
660, 210, 429, 754, 262, 432, 1987, 434, 1494, 1518,
|
|
981, 1638, 2027, 649, 1311, 1154, 391, 1716, 1717, 1718,
|
|
1071, 1866, 1614, 1868, 1614, 659, 660, 98, 118, 895,
|
|
7, 2096, 122, 259, 436, 1005, 262, 263, 63, 470,
|
|
747, 483, 1625, 659, 660, 849, 76, 1530, 1634, 849,
|
|
7, 453, 1373, 1639, 471, 1530, 480, 1915, 1530, 8,
|
|
1680, 8, 15, 1530, 1530, 467, 1530, 1530, 116, 99,
|
|
472, 20, 0, 1, 476, 94, 478, 7, 15, 232,
|
|
233, 391, 1920, 1921, 71, 238, 116, 183, 8, 491,
|
|
8, 8, 516, 8, 89, 191, 41, 8, 8, 2206,
|
|
20, 503, 20, 505, 182, 20, 1027, 116, 1027, 20,
|
|
512, 191, 208, 63, 144, 1166, 169, 8, 68, 175,
|
|
1179, 8, 677, 8, 5, 15, 7, 122, 15, 1050,
|
|
5, 5, 8, 191, 37, 20, 409, 15, 182, 116,
|
|
90, 91, 974, 975, 129, 641, 21, 8, 8, 645,
|
|
552, 5, 8, 129, 225, 208, 652, 2417, 8, 116,
|
|
155, 315, 1861, 116, 21, 1864, 8, 116, 804, 116,
|
|
1528, 129, 1530, 8, 1532, 15, 129, 212, 3, 1528,
|
|
8, 1530, 8, 1532, 58, 1534, 116, 172, 8, 8,
|
|
185, 21, 64, 18, 144, 37, 116, 351, 116, 116,
|
|
5, 116, 3, 578, 154, 116, 1560, 242, 166, 257,
|
|
483, 230, 86, 588, 589, 590, 591, 475, 7, 8,
|
|
21, 208, 150, 218, 282, 116, 129, 651, 637, 282,
|
|
654, 116, 37, 1528, 314, 1530, 257, 1532, 15, 767,
|
|
318, 262, 129, 1528, 1191, 1530, 2506, 1532, 129, 1534,
|
|
200, 129, 126, 129, 129, 116, 116, 252, 813, 149,
|
|
116, 357, 358, 137, 209, 284, 116, 2125, 324, 696,
|
|
2377, 315, 129, 23, 318, 129, 295, 266, 1446, 15,
|
|
257, 116, 592, 228, 15, 694, 728, 37, 116, 129,
|
|
116, 165, 1919, 129, 822, 1994, 116, 116, 287, 129,
|
|
257, 2139, 2140, 678, 257, 376, 377, 803, 257, 246,
|
|
257, 382, 383, 384, 385, 755, 387, 388, 1615, 1616,
|
|
391, 976, 393, 394, 395, 396, 701, 257, 399, 257,
|
|
1916, 402, 2313, 404, 1305, 1918, 1657, 257, 409, 257,
|
|
257, 412, 257, 414, 254, 416, 257, 15, 1831, 420,
|
|
421, 422, 423, 989, 1867, 991, 1831, 8, 429, 1831,
|
|
431, 432, 998, 434, 1831, 1831, 257, 1831, 1831, 440,
|
|
441, 1005, 257, 815, 1345, 2074, 447, 448, 802, 1438,
|
|
804, 452, 1178, 641, 258, 1189, 1093, 645, 459, 1005,
|
|
1190, 462, 8, 129, 652, 420, 257, 257, 129, 3,
|
|
1459, 257, 492, 474, 844, 47, 477, 257, 1378, 1379,
|
|
1380, 15, 483, 484, 485, 486, 437, 488, 489, 43,
|
|
1085, 8, 257, 798, 495, 496, 497, 498, 499, 257,
|
|
501, 257, 92, 504, 15, 506, 507, 257, 257, 510,
|
|
700, 15, 513, 67, 1495, 466, 517, 1418, 15, 8,
|
|
1110, 8, 473, 257, 475, 15, 716, 547, 82, 191,
|
|
1818, 2160, 194, 87, 88, 116, 1605, 1606, 843, 1818,
|
|
94, 846, 1304, 1831, 8, 546, 1110, 2542, 2543, 1837,
|
|
15, 191, 1831, 573, 16, 17, 2501, 129, 1837, 149,
|
|
580, 922, 1841, 564, 1110, 8, 992, 993, 994, 995,
|
|
996, 572, 148, 1857, 575, 576, 577, 578, 21, 2136,
|
|
2491, 8, 583, 584, 923, 2028, 587, 588, 589, 590,
|
|
591, 8, 1158, 1818, 595, 596, 2118, 2036, 2118, 116,
|
|
683, 2017, 8, 1818, 180, 177, 1831, 147, 148, 569,
|
|
570, 201, 1837, 129, 2127, 803, 1831, 773, 129, 64,
|
|
23, 581, 1837, 3, 763, 129, 1841, 116, 7, 116,
|
|
92, 970, 129, 149, 37, 15, 2547, 2412, 149, 129,
|
|
180, 8, 7, 8, 128, 7, 5, 5, 288, 669,
|
|
9, 9, 116, 1910, 16, 17, 23, 847, 1915, 299,
|
|
661, 662, 663, 664, 665, 666, 667, 687, 858, 670,
|
|
37, 5, 7, 157, 228, 8, 257, 678, 37, 37,
|
|
15, 15, 2559, 1910, 129, 875, 22, 149, 24, 8,
|
|
641, 3, 147, 148, 645, 696, 2573, 33, 699, 35,
|
|
701, 652, 8, 1042, 149, 259, 657, 8, 128, 244,
|
|
1561, 84, 1561, 1052, 26, 1536, 1537, 1538, 37, 1540,
|
|
1541, 8, 912, 724, 8, 180, 129, 747, 1318, 2286,
|
|
95, 37, 3, 217, 1460, 1461, 926, 157, 8, 201,
|
|
257, 15, 16, 17, 764, 7, 8, 2376, 749, 303,
|
|
751, 21, 1653, 754, 1318, 26, 2597, 2598, 778, 124,
|
|
1660, 1661, 1662, 1444, 8, 785, 767, 191, 257, 2610,
|
|
257, 3, 1318, 84, 1320, 8, 777, 860, 2141, 2142,
|
|
2143, 864, 8, 15, 208, 786, 869, 788, 21, 872,
|
|
873, 1692, 793, 257, 795, 21, 331, 798, 2427, 1365,
|
|
1366, 1367, 1368, 1369, 992, 993, 994, 995, 996, 18,
|
|
811, 346, 347, 348, 1378, 1379, 1380, 26, 191, 191,
|
|
8, 822, 158, 159, 1014, 161, 162, 828, 8, 1019,
|
|
195, 851, 1378, 1379, 1380, 208, 208, 202, 2388, 8,
|
|
8, 21, 843, 8, 63, 846, 15, 5, 931, 68,
|
|
933, 852, 803, 21, 8, 129, 192, 15, 282, 314,
|
|
315, 285, 882, 318, 319, 8, 290, 887, 2125, 8,
|
|
1060, 90, 91, 15, 298, 149, 896, 897, 898, 3,
|
|
191, 901, 21, 339, 3, 886, 342, 343, 344, 16,
|
|
17, 15, 265, 5, 21, 2338, 15, 208, 234, 355,
|
|
356, 902, 903, 15, 16, 17, 8, 1277, 15, 282,
|
|
282, 247, 285, 285, 8, 27, 289, 918, 8, 21,
|
|
8, 941, 8, 8, 36, 144, 299, 21, 8, 880,
|
|
881, 304, 257, 21, 5, 154, 21, 262, 5, 940,
|
|
8, 21, 9, 894, 904, 16, 17, 8, 8, 16,
|
|
17, 22, 64, 24, 265, 8, 23, 5, 8, 919,
|
|
21, 9, 33, 8, 35, 8, 37, 2410, 16, 17,
|
|
37, 282, 8, 21, 285, 23, 21, 8, 289, 290,
|
|
92, 200, 1905, 1906, 1907, 1908, 1909, 298, 299, 37,
|
|
21, 3, 8, 304, 8, 8, 8, 8, 8, 2409,
|
|
2284, 8, 8, 1308, 1024, 21, 41, 1354, 21, 1860,
|
|
21, 21, 231, 1352, 21, 21, 1893, 129, 7, 1358,
|
|
5, 1872, 1023, 1872, 9, 244, 8, 5, 1029, 7,
|
|
7, 16, 17, 8, 1035, 8, 71, 149, 1939, 21,
|
|
1766, 992, 993, 994, 995, 996, 21, 1048, 21, 1000,
|
|
1001, 1398, 37, 8, 1955, 8, 2499, 2155, 8, 1740,
|
|
1961, 1439, 1963, 1441, 1411, 8, 21, 1652, 21, 7,
|
|
8, 21, 1073, 1093, 1870, 1871, 1027, 1078, 21, 8,
|
|
1437, 1101, 1878, 1879, 1427, 1424, 1429, 2497, 159, 201,
|
|
8, 162, 21, 1094, 8, 1285, 1660, 1661, 1662, 1050,
|
|
135, 1863, 149, 21, 1955, 8, 1955, 21, 1109, 22,
|
|
1961, 24, 3, 1303, 1660, 1661, 1662, 1200, 21, 8,
|
|
33, 63, 35, 1206, 15, 1145, 68, 1210, 8, 1212,
|
|
1213, 1214, 21, 1216, 169, 1218, 15, 1088, 1470, 8,
|
|
1866, 21, 1868, 1905, 1906, 1907, 1908, 1909, 90, 91,
|
|
15, 5, 21, 8, 3, 9, 191, 8, 15, 8,
|
|
5, 149, 16, 17, 9, 8, 21, 21, 1188, 23,
|
|
21, 16, 17, 208, 209, 15, 247, 8, 21, 15,
|
|
8, 15, 124, 37, 8, 1517, 221, 8, 223, 224,
|
|
21, 226, 37, 21, 229, 862, 863, 5, 865, 15,
|
|
21, 9, 144, 15, 8, 8, 8, 37, 16, 17,
|
|
8, 1231, 154, 21, 15, 23, 129, 21, 21, 21,
|
|
1559, 352, 353, 21, 44, 8, 1246, 1247, 1248, 37,
|
|
1656, 8, 316, 317, 305, 306, 307, 8, 21, 15,
|
|
8, 8, 1432, 8, 21, 158, 159, 282, 161, 162,
|
|
21, 15, 1272, 21, 21, 15, 21, 15, 200, 5,
|
|
15, 7, 15, 8, 10, 410, 8, 87, 14, 15,
|
|
16, 17, 15, 93, 349, 350, 21, 1278, 1279, 192,
|
|
1780, 27, 1782, 1783, 15, 320, 15, 322, 34, 15,
|
|
36, 233, 8, 15, 1794, 15, 8, 2395, 15, 119,
|
|
15, 1302, 244, 8, 1804, 21, 1806, 1308, 1647, 21,
|
|
8, 1312, 15, 16, 17, 8, 21, 8, 64, 16,
|
|
17, 234, 8, 143, 27, 145, 8, 8, 21, 1412,
|
|
21, 124, 1671, 36, 247, 21, 8, 8, 8, 21,
|
|
21, 8, 1937, 2332, 1683, 1702, 92, 8, 1687, 21,
|
|
21, 21, 8, 8, 21, 8, 59, 8, 178, 8,
|
|
21, 64, 7, 183, 239, 21, 21, 187, 21, 15,
|
|
21, 191, 21, 15, 194, 252, 15, 522, 1944, 524,
|
|
2281, 2232, 1383, 129, 1615, 1616, 531, 532, 533, 92,
|
|
248, 249, 537, 538, 539, 540, 216, 542, 543, 1000,
|
|
1001, 8, 8, 149, 1487, 2306, 15, 2258, 5, 2258,
|
|
230, 15, 9, 10, 21, 21, 236, 14, 15, 16,
|
|
17, 8, 1373, 2593, 2594, 1426, 1427, 15, 1429, 8,
|
|
27, 8, 8, 15, 21, 8, 1437, 34, 1439, 36,
|
|
1441, 8, 21, 1444, 21, 21, 149, 8, 21, 8,
|
|
8, 8, 8, 8, 21, 201, 8, 8, 8, 8,
|
|
21, 8, 21, 21, 21, 21, 21, 64, 1656, 21,
|
|
21, 21, 21, 1493, 21, 1476, 15, 5, 8, 1669,
|
|
2474, 2475, 10, 8, 1485, 3, 14, 15, 16, 17,
|
|
1491, 21, 1512, 15, 1514, 92, 21, 8, 201, 27,
|
|
1501, 8, 8, 1660, 1661, 1662, 34, 15, 36, 124,
|
|
21, 15, 15, 246, 21, 21, 246, 1518, 15, 1539,
|
|
204, 205, 206, 207, 208, 21, 1477, 870, 871, 8,
|
|
7, 26, 129, 1553, 15, 15, 64, 15, 240, 8,
|
|
15, 1731, 8, 15, 15, 175, 5, 149, 1549, 1569,
|
|
9, 2540, 149, 8, 1574, 15, 15, 16, 17, 8,
|
|
8, 15, 1582, 8, 92, 8, 7, 129, 27, 1520,
|
|
1590, 15, 62, 26, 8, 15, 15, 36, 455, 21,
|
|
1600, 8, 1602, 287, 15, 1536, 1537, 1538, 213, 1540,
|
|
1541, 8, 8, 1544, 1595, 15, 16, 17, 8, 8,
|
|
15, 129, 8, 64, 201, 64, 9, 27, 2334, 1956,
|
|
1561, 9, 8, 490, 21, 8, 36, 8, 15, 37,
|
|
67, 149, 26, 500, 1625, 15, 15, 1959, 15, 15,
|
|
15, 15, 15, 92, 8, 2230, 5, 1638, 166, 15,
|
|
8, 10, 129, 7, 64, 14, 15, 16, 17, 7,
|
|
21, 21, 18, 26, 21, 37, 1657, 7, 27, 1660,
|
|
1661, 1662, 15, 7, 15, 34, 2028, 36, 8, 1670,
|
|
129, 816, 92, 201, 15, 8, 8, 554, 555, 556,
|
|
557, 558, 5, 2409, 7, 2411, 2412, 10, 26, 15,
|
|
149, 14, 15, 16, 17, 64, 21, 21, 15, 15,
|
|
15, 1702, 15, 15, 27, 1656, 1657, 166, 8, 129,
|
|
21, 34, 21, 36, 8, 5, 15, 15, 15, 62,
|
|
21, 1722, 8, 92, 7, 239, 8, 8, 8, 149,
|
|
8, 15, 255, 7, 166, 208, 613, 614, 615, 1740,
|
|
617, 64, 201, 15, 15, 2471, 21, 624, 16, 15,
|
|
15, 15, 2206, 191, 21, 8, 7, 15, 15, 331,
|
|
129, 638, 315, 332, 246, 1716, 1717, 1718, 15, 92,
|
|
2496, 2497, 15, 1774, 1775, 15, 15, 2116, 15, 5,
|
|
149, 201, 15, 15, 10, 15, 15, 2126, 14, 15,
|
|
16, 17, 15, 15, 15, 15, 15, 166, 1799, 15,
|
|
44, 27, 15, 680, 15, 15, 129, 7, 34, 5,
|
|
36, 246, 5, 9, 40, 21, 246, 5, 695, 15,
|
|
16, 17, 246, 2549, 246, 5, 149, 15, 16, 17,
|
|
10, 27, 201, 8, 14, 15, 16, 17, 64, 27,
|
|
36, 15, 1862, 87, 15, 21, 723, 27, 36, 8,
|
|
1851, 7, 21, 730, 34, 21, 36, 1877, 21, 736,
|
|
737, 1881, 2323, 2324, 8, 26, 92, 15, 64, 21,
|
|
15, 173, 8, 15, 15, 119, 64, 255, 201, 8,
|
|
7, 21, 15, 15, 64, 71, 208, 18, 8, 15,
|
|
15, 15, 15, 15, 149, 7, 92, 15, 15, 143,
|
|
21, 145, 21, 129, 92, 782, 21, 21, 21, 1860,
|
|
1861, 15, 92, 1864, 21, 15, 1061, 1918, 1919, 1920,
|
|
1921, 1872, 21, 149, 21, 8, 15, 1072, 5, 15,
|
|
1931, 9, 20, 129, 178, 26, 21, 21, 8, 183,
|
|
21, 129, 21, 187, 15, 21, 21, 191, 15, 129,
|
|
194, 2409, 2410, 149, 1974, 8, 2303, 1958, 26, 21,
|
|
26, 149, 26, 21, 21, 7, 21, 15, 8, 149,
|
|
26, 15, 216, 8, 21, 201, 1996, 254, 855, 856,
|
|
7, 15, 21, 10, 21, 132, 230, 14, 15, 16,
|
|
17, 7, 236, 7, 37, 21, 21, 15, 15, 354,
|
|
27, 7, 7, 255, 1955, 201, 21, 34, 21, 36,
|
|
1961, 2012, 15, 201, 15, 2016, 15, 2018, 15, 15,
|
|
1165, 201, 2042, 15, 15, 15, 15, 2028, 15, 7,
|
|
7, 2051, 8, 21, 2035, 2036, 8, 64, 8, 21,
|
|
8, 7, 21, 1994, 8, 7, 15, 7, 15, 2069,
|
|
21, 78, 8, 7, 1199, 78, 352, 330, 353, 7,
|
|
1205, 223, 21, 15, 1209, 92, 1211, 17, 15, 15,
|
|
1215, 15, 1217, 8, 951, 952, 953, 954, 955, 956,
|
|
957, 958, 959, 960, 961, 962, 963, 964, 965, 966,
|
|
967, 968, 969, 21, 17, 15, 5, 7, 15, 976,
|
|
7, 10, 129, 7, 981, 14, 15, 16, 17, 128,
|
|
2014, 988, 903, 990, 911, 1279, 1890, 1600, 27, 1192,
|
|
2281, 1097, 149, 2074, 1604, 34, 2127, 36, 1005, 586,
|
|
1891, 594, 597, 714, 1310, 2136, 1634, 2138, 2139, 2140,
|
|
2141, 2142, 2143, 45, 46, 940, 48, 49, 2168, 2286,
|
|
940, 53, 2118, 2138, 1031, 64, 1918, 1910, 1161, 61,
|
|
1037, 1501, 1741, 2188, 66, 1485, 2012, 69, 2207, 5,
|
|
1033, 1053, 1421, 9, 201, 77, 1053, 79, 1400, 81,
|
|
16, 17, 1713, 92, 1095, 1715, 22, 23, 75, 25,
|
|
2599, 1939, 28, 29, 30, 31, 32, 466, 1961, 5,
|
|
715, 37, 104, 9, 1407, 2206, 2207, 1444, 1656, 2160,
|
|
16, 17, 796, 115, 247, 247, 247, 23, 247, 25,
|
|
129, 1653, 28, 29, 30, 31, 32, 1042, 661, 2249,
|
|
1005, 37, 1078, 1109, 842, 1181, 664, 139, 663, 665,
|
|
149, 2333, 1423, 666, 2167, 2547, 1425, 2016, 2268, 2395,
|
|
152, 811, 1021, 1023, 2519, 1094, 1048, 1958, 2454, 1998,
|
|
445, 1138, 1035, 792, 2408, 2549, 2575, 2595, 170, 2341,
|
|
2597, 1766, 1499, 2019, 176, 670, 507, 1461, 1963, 1156,
|
|
765, 2232, 184, 385, 186, 2286, 188, 1553, 190, 1434,
|
|
418, 2023, 201, 1818, 2313, 197, 1837, 1793, 1841, 1798,
|
|
2364, 2048, 1179, 1180, 1181, 1831, 2049, 2258, 1231, 1851,
|
|
1238, 1549, 214, 215, 884, 2069, 2381, 1569, 2232, 1574,
|
|
2268, 1582, 2323, 2324, -1, 1590, -1, 437, -1, -1,
|
|
232, -1, 2333, -1, -1, 5, -1, 239, 1483, 9,
|
|
-1, -1, -1, -1, -1, -1, 16, 17, -1, -1,
|
|
-1, 253, 22, 23, 256, 25, 466, -1, 28, 29,
|
|
30, 31, 32, 473, -1, 35, -1, 37, 38, -1,
|
|
-1, 481, 1249, -1, -1, -1, -1, -1, 1523, -1,
|
|
-1, 1526, -1, -1, 1529, -1, 1531, -1, 1533, -1,
|
|
1535, -1, -1, -1, -1, -1, -1, -1, 2399, -1,
|
|
-1, -1, -1, 2423, -1, -1, -1, -1, 2409, 2410,
|
|
-1, -1, 2432, -1, -1, -1, -1, -1, 2438, -1,
|
|
2440, -1, -1, -1, 2375, 2376, -1, -1, 1305, 45,
|
|
46, -1, 48, 49, -1, -1, -1, 53, -1, -1,
|
|
1317, -1, 2443, -1, -1, 61, -1, -1, -1, -1,
|
|
66, -1, -1, 69, 2474, 2475, -1, -1, -1, -1,
|
|
-1, 77, 5, 79, -1, 81, -1, 10, 1345, -1,
|
|
-1, 14, 15, 16, 17, -1, 2427, -1, -1, -1,
|
|
1357, -1, -1, 593, 27, -1, -1, -1, 104, -1,
|
|
-1, 34, -1, 36, -1, -1, -1, 5, -1, 115,
|
|
-1, -1, 10, -1, -1, -1, 14, 15, 16, 17,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, 2519, 27,
|
|
2521, 64, -1, 139, -1, -1, 34, -1, 36, 1406,
|
|
1407, 2482, -1, -1, -1, -1, 152, -1, -1, -1,
|
|
-1, -1, -1, -1, 1421, -1, -1, 657, -1, 92,
|
|
-1, 1428, -1, -1, 170, -1, 64, 2577, -1, -1,
|
|
176, 1438, 2582, -1, -1, -1, -1, 1444, 184, 1446,
|
|
186, -1, 188, -1, 190, 2595, -1, 2597, 2598, -1,
|
|
-1, 197, 1459, -1, 92, 7, 129, -1, 10, -1,
|
|
2610, -1, 14, 15, 16, 17, 1473, -1, 214, 215,
|
|
-1, -1, -1, -1, -1, 27, 149, 1484, -1, -1,
|
|
-1, -1, 34, -1, 36, -1, 232, -1, -1, -1,
|
|
1497, 129, -1, -1, -1, 1502, 7, 1504, -1, 10,
|
|
-1, -1, -1, 14, 15, 16, 17, 253, -1, 749,
|
|
256, 149, 64, -1, -1, 1790, 27, -1, -1, -1,
|
|
1795, -1, -1, 34, -1, 36, -1, 767, 201, -1,
|
|
-1, -1, -1, 1808, -1, -1, -1, -1, -1, -1,
|
|
92, 781, -1, -1, -1, -1, -1, -1, 5, 789,
|
|
790, -1, 9, 64, 794, 1830, -1, -1, -1, 16,
|
|
17, 1836, -1, 201, -1, 1840, 23, -1, 25, -1,
|
|
-1, 28, 29, 30, 31, 32, -1, 129, -1, -1,
|
|
37, 92, 822, -1, -1, -1, 7, -1, -1, 10,
|
|
830, -1, -1, 14, 15, 16, 17, 149, -1, -1,
|
|
-1, -1, 7, 1610, -1, 10, 27, -1, -1, 14,
|
|
15, 16, 17, 34, 166, 36, -1, -1, 129, 859,
|
|
-1, 861, 27, -1, -1, -1, -1, -1, -1, 34,
|
|
-1, 36, -1, -1, -1, -1, -1, -1, 149, -1,
|
|
880, 881, -1, 64, 1651, 1652, 1653, -1, -1, 201,
|
|
-1, -1, -1, 7, 894, 895, 10, -1, -1, 64,
|
|
14, 15, 16, 17, -1, -1, -1, -1, -1, -1,
|
|
-1, 92, -1, 27, -1, 1682, -1, -1, 1685, -1,
|
|
34, -1, 36, -1, -1, 7, 1693, 92, 10, -1,
|
|
201, -1, 14, 15, 16, 17, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, 27, -1, -1, 129, -1,
|
|
64, -1, 34, -1, 36, -1, -1, -1, 1725, -1,
|
|
1727, -1, -1, -1, 129, -1, -1, -1, 149, -1,
|
|
-1, -1, -1, -1, 974, 975, -1, -1, 92, -1,
|
|
-1, -1, 64, -1, 149, -1, -1, -1, -1, -1,
|
|
2025, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
1000, 1001, -1, -1, 2039, -1, -1, -1, -1, 2044,
|
|
92, -1, 2047, -1, -1, 129, -1, -1, -1, -1,
|
|
201, -1, 2057, -1, 2059, -1, 2061, 1027, 2063, -1,
|
|
-1, -1, -1, -1, -1, 149, 201, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, 5, -1, 129, -1, 9,
|
|
1050, -1, -1, -1, -1, -1, 16, 17, -1, -1,
|
|
-1, -1, 22, 23, 24, 25, -1, 149, 28, 29,
|
|
30, 31, 32, 33, 12, 35, -1, 37, 38, -1,
|
|
18, -1, -1, -1, -1, -1, -1, 201, 1088, -1,
|
|
28, -1, -1, 31, -1, -1, 34, -1, -1, -1,
|
|
-1, -1, -1, 41, -1, -1, 1873, 45, -1, -1,
|
|
-1, 49, -1, 1880, -1, -1, -1, 1884, 1885, 201,
|
|
-1, -1, -1, -1, -1, 1892, -1, -1, -1, 67,
|
|
-1, -1, -1, 71, 72, -1, -1, -1, -1, 77,
|
|
78, -1, -1, -1, -1, 83, 84, -1, 86, 87,
|
|
88, 89, -1, 91, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, 100, -1, -1, -1, 1933, 105, -1, 107,
|
|
-1, -1, 1939, 111, -1, -1, -1, 115, 1178, 117,
|
|
-1, -1, -1, -1, -1, -1, 124, -1, -1, -1,
|
|
128, -1, -1, -1, 132, -1, 134, 1964, -1, -1,
|
|
-1, -1, 7, 141, 142, 10, 1973, 145, 146, 14,
|
|
15, 16, 17, 151, -1, 153, -1, -1, -1, 157,
|
|
-1, 10, 27, 1990, 1991, 14, 15, 16, 17, 34,
|
|
-1, 36, -1, -1, -1, -1, -1, 10, 27, -1,
|
|
-1, 14, 15, 16, 17, 34, 184, 36, 186, -1,
|
|
-1, -1, 2019, -1, 27, 193, 194, -1, -1, 64,
|
|
2027, 34, -1, 36, -1, -1, -1, -1, -1, -1,
|
|
2037, -1, -1, -1, -1, 64, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, 2053, 92, 2055, -1,
|
|
-1, 64, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 92, -1, -1, -1, -1, -1, 1309,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, 92,
|
|
-1, -1, -1, -1, 129, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
129, -1, -1, -1, 149, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, 129, -1, -1, -1,
|
|
149, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 1373, -1, -1, 149, -1, -1, -1,
|
|
-1, -1, -1, 2150, -1, -1, -1, -1, 2155, -1,
|
|
-1, -1, -1, -1, -1, -1, 201, -1, -1, 2166,
|
|
2167, -1, -1, -1, 2171, -1, -1, -1, -1, -1,
|
|
-1, -1, 201, -1, 2181, -1, -1, -1, -1, -1,
|
|
2187, -1, -1, -1, -1, 5, -1, -1, 201, 9,
|
|
10, -1, -1, -1, -1, -1, 16, 17, -1, 1439,
|
|
625, 1441, 22, 23, 24, 25, 26, -1, 28, 29,
|
|
30, 31, 32, 33, -1, 35, -1, 37, 38, -1,
|
|
1460, 1461, -1, -1, 2231, -1, -1, -1, -1, 407,
|
|
-1, 1471, -1, -1, -1, -1, -1, 1477, -1, 1479,
|
|
-1, -1, 1482, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 2260, 1494, -1, -1, -1, 1498, 1499,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, 2275, -1,
|
|
-1, -1, -1, -1, 2281, -1, -1, -1, -1, -1,
|
|
1520, -1, -1, -1, -1, -1, -1, 1527, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, 1536, 1537, 1538, -1,
|
|
1540, 1541, -1, -1, 1544, -1, -1, -1, -1, -1,
|
|
2317, 5, -1, 7, -1, 9, 10, -1, -1, -1,
|
|
-1, 1561, 16, 17, -1, 2332, -1, 21, 22, 23,
|
|
24, 25, -1, 511, 28, 29, 30, 31, 32, 33,
|
|
-1, 35, -1, 37, 38, -1, -1, 5, -1, -1,
|
|
775, 9, 10, -1, 779, -1, -1, -1, 16, 17,
|
|
-1, -1, -1, -1, 22, 23, 24, 25, -1, -1,
|
|
28, 29, 30, 31, 32, 33, 34, 35, -1, 37,
|
|
38, -1, -1, -1, -1, 1625, -1, 2394, 2395, -1,
|
|
-1, 2398, -1, 2400, -1, -1, -1, -1, -1, -1,
|
|
-1, 826, -1, -1, -1, -1, -1, -1, 2415, 2416,
|
|
-1, 2418, -1, 838, -1, -1, -1, 1657, -1, -1,
|
|
-1, 2428, -1, -1, -1, -1, 5, -1, 7, 2436,
|
|
9, 10, -1, -1, -1, -1, -1, 16, 17, -1,
|
|
-1, -1, -1, 22, 23, 24, 25, 2454, -1, 28,
|
|
29, 30, 31, 32, 33, -1, 35, -1, 37, 38,
|
|
-1, -1, -1, 888, 889, 890, 891, -1, 893, -1,
|
|
-1, -1, -1, -1, -1, 2482, 1716, 1717, 1718, -1,
|
|
-1, -1, -1, 2490, 2491, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, 2501, -1, -1, 2504, -1, -1,
|
|
-1, 2508, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
945, -1, 947, 948, 949, 950, 1766, -1, -1, -1,
|
|
-1, -1, -1, 2540, -1, -1, -1, -1, -1, -1,
|
|
2547, -1, -1, -1, 2551, -1, -1, -1, 2555, -1,
|
|
-1, -1, 2559, -1, -1, -1, -1, -1, -1, 5,
|
|
-1, -1, 8, 9, 10, -1, 2573, 2574, 2575, -1,
|
|
16, 17, -1, -1, -1, -1, 22, 23, 24, 25,
|
|
-1, 1006, 28, 29, 30, 31, 32, 33, -1, 35,
|
|
-1, 37, 38, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 1028, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 1038, -1, -1, -1, -1, -1, -1,
|
|
1860, 1861, -1, -1, 1864, -1, 1866, 1867, 1868, -1,
|
|
1870, 1871, 1872, -1, 1059, -1, -1, -1, 1878, 1879,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
1075, -1, -1, -1, 1079, 1080, -1, -1, -1, 5,
|
|
-1, -1, 8, 9, 10, 1905, 1906, 1907, 1908, 1909,
|
|
16, 17, -1, -1, -1, -1, 22, 23, 24, 25,
|
|
-1, -1, 28, 29, 30, 31, 32, 33, -1, 35,
|
|
-1, 37, 38, -1, -1, -1, -1, -1, -1, 5,
|
|
-1, -1, 8, 9, 10, -1, -1, -1, -1, -1,
|
|
16, 17, 1137, -1, -1, 1955, 22, 23, 24, 25,
|
|
-1, 1961, 28, 29, 30, 31, 32, 33, -1, 35,
|
|
-1, 37, 38, 5, -1, -1, -1, 9, 10, -1,
|
|
-1, -1, 920, -1, 16, 17, -1, -1, -1, 21,
|
|
22, 23, 24, 25, 1994, 1995, 28, 29, 30, 31,
|
|
32, 33, -1, 35, -1, 37, 38, -1, -1, -1,
|
|
1195, 1196, -1, -1, 5, -1, -1, 2017, 9, 10,
|
|
-1, -1, -1, -1, -1, 16, 17, -1, 2028, -1,
|
|
21, 22, 23, 24, 25, -1, -1, 28, 29, 30,
|
|
31, 32, 33, -1, 35, -1, 37, 38, -1, 2049,
|
|
-1, -1, -1, 5, -1, 7, -1, 9, 10, -1,
|
|
-1, -1, -1, -1, 16, 17, -1, -1, -1, -1,
|
|
22, 23, 24, 25, 2074, 2075, 28, 29, 30, 31,
|
|
32, 33, 1020, 35, -1, 37, 38, 5, -1, 7,
|
|
-1, 9, 10, -1, -1, -1, -1, -1, 16, 17,
|
|
-1, -1, -1, -1, 22, 23, 24, 25, -1, -1,
|
|
28, 29, 30, 31, 32, 33, -1, 35, -1, 37,
|
|
38, -1, -1, -1, -1, -1, -1, 2127, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, 1321, 1322, 1323, 1324,
|
|
1325, 1326, 1327, 1328, 1329, 1330, 1331, 1332, 1333, 1334,
|
|
1335, 1336, 1337, 1338, 1339, -1, -1, 2157, -1, -1,
|
|
2160, -1, 2162, -1, -1, -1, -1, -1, -1, -1,
|
|
1355, -1, -1, -1, -1, -1, 5, 1362, -1, 1364,
|
|
9, 10, -1, -1, -1, -1, -1, 16, 17, 1374,
|
|
-1, -1, 21, 22, 23, 24, 25, -1, -1, 28,
|
|
29, 30, 31, 32, 33, -1, 35, -1, 37, 38,
|
|
5, -1, -1, -1, 9, 10, -1, -1, -1, -1,
|
|
1405, 16, 17, -1, -1, -1, 21, 22, 23, 24,
|
|
25, -1, 2232, 28, 29, 30, 31, 32, 33, -1,
|
|
35, -1, 37, 38, 5, -1, -1, -1, 9, 10,
|
|
-1, -1, -1, -1, -1, 16, 17, -1, 2258, -1,
|
|
21, 22, 23, 24, 25, -1, -1, 28, 29, 30,
|
|
31, 32, 33, -1, 35, -1, 37, 38, -1, -1,
|
|
-1, 5, -1, -1, -1, 9, 10, -1, -1, 1474,
|
|
-1, -1, 16, 17, -1, -1, -1, 21, 22, 23,
|
|
24, 25, -1, 1488, 28, 29, 30, 31, 32, 33,
|
|
-1, 35, -1, 37, 38, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, 1509, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, 2334, 5, -1, -1, 2338, 9,
|
|
10, -1, -1, -1, -1, -1, 16, 17, 1286, -1,
|
|
-1, 21, 22, 23, 24, 25, -1, -1, 28, 29,
|
|
30, 31, 32, 33, -1, 35, 5, 37, 38, -1,
|
|
9, 10, -1, 1558, -1, 2375, 2376, 16, 17, -1,
|
|
-1, -1, 21, 22, 23, 24, 25, -1, -1, 28,
|
|
29, 30, 31, 32, 33, -1, 35, -1, 37, 38,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, 2409,
|
|
2410, 2411, 2412, -1, 5, -1, -1, 2417, 9, 10,
|
|
-1, -1, -1, -1, 1609, 16, 17, 2427, -1, -1,
|
|
21, 22, 23, 24, 25, -1, -1, 28, 29, 30,
|
|
31, 32, 33, -1, 35, -1, 37, 38, -1, 5,
|
|
-1, -1, -1, 9, 10, -1, -1, 1642, -1, -1,
|
|
16, 17, -1, -1, 1649, 21, 22, 23, 24, 25,
|
|
1655, 2471, 28, 29, 30, 31, 32, 33, -1, 35,
|
|
-1, 37, 38, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, 1678, -1, -1, 2496, 2497, -1, 2499,
|
|
-1, -1, -1, -1, -1, 1690, 2506, -1, -1, -1,
|
|
5, -1, 7, 1698, 9, 10, -1, -1, -1, -1,
|
|
-1, 16, 17, 1708, -1, -1, 1711, 22, 23, 24,
|
|
25, -1, -1, 28, 29, 30, 31, 32, 33, -1,
|
|
35, 1726, 37, 38, -1, -1, -1, -1, -1, 2549,
|
|
-1, -1, -1, 1738, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, 1752, -1, -1,
|
|
-1, -1, -1, 1758, -1, 14, 15, 16, 17, 1764,
|
|
19, -1, 21, -1, 23, 24, -1, 26, -1, -1,
|
|
-1, 30, -1, 32, 33, -1, -1, 36, 37, 38,
|
|
-1, 40, -1, 42, 43, -1, -1, 46, -1, -1,
|
|
-1, -1, 51, 52, 53, 54, 55, 56, 57, 58,
|
|
-1, 60, 61, -1, -1, 64, 65, 66, -1, 68,
|
|
-1, 70, -1, -1, 73, 74, -1, -1, -1, -1,
|
|
-1, -1, 81, 82, -1, -1, 85, -1, -1, -1,
|
|
-1, -1, -1, 92, -1, 94, -1, 96, 97, -1,
|
|
-1, -1, 101, 102, 103, -1, -1, 106, -1, -1,
|
|
109, 110, -1, 112, 113, 114, -1, -1, -1, -1,
|
|
119, 120, -1, -1, 123, -1, 125, 126, 127, -1,
|
|
129, 130, -1, -1, 133, -1, 135, 136, 137, 138,
|
|
139, 140, -1, -1, -1, -1, -1, -1, 147, 148,
|
|
149, 1896, -1, -1, -1, 154, 155, 156, -1, 158,
|
|
159, 160, 161, 162, 163, 164, 165, 166, 167, 168,
|
|
169, 170, 171, 172, 173, 174, 175, 176, 177, 178,
|
|
179, 180, 181, 182, 183, -1, 185, -1, 187, -1,
|
|
189, -1, 191, 192, -1, 1940, 195, 196, 197, 198,
|
|
199, 200, 201, 202, -1, -1, -1, 5, -1, -1,
|
|
-1, 9, 10, -1, -1, 1960, -1, 1962, 16, 17,
|
|
-1, 1966, -1, 21, 22, 23, 24, 25, -1, -1,
|
|
28, 29, 30, 31, 32, 33, -1, 35, -1, 37,
|
|
38, -1, -1, -1, 1989, -1, -1, 1992, -1, -1,
|
|
-1, -1, -1, 5, -1, 7, 255, 9, 10, 258,
|
|
-1, 260, -1, -1, 16, 17, -1, -1, -1, 2014,
|
|
22, 23, 24, 25, -1, -1, 28, 29, 30, 31,
|
|
32, 33, -1, 35, 5, 37, 38, -1, 9, 10,
|
|
-1, -1, -1, -1, -1, 16, 17, -1, -1, -1,
|
|
21, 22, 23, 24, 25, -1, -1, 28, 29, 30,
|
|
31, 32, 33, -1, 35, -1, 37, 38, -1, 5,
|
|
-1, 7, -1, 9, 10, -1, -1, -1, -1, -1,
|
|
16, 17, -1, -1, -1, -1, 22, 23, 24, 25,
|
|
-1, -1, 28, 29, 30, 31, 32, 33, 2093, 35,
|
|
-1, 37, 38, -1, 5, -1, 7, 2102, 9, 10,
|
|
-1, 2106, 2107, -1, -1, 16, 17, -1, -1, 2114,
|
|
-1, 22, 23, 24, 25, -1, -1, 28, 29, 30,
|
|
31, 32, 33, -1, 35, 5, 37, 38, 8, 9,
|
|
10, -1, -1, -1, -1, -1, 16, 17, -1, -1,
|
|
2145, -1, 22, 23, 24, 25, -1, -1, 28, 29,
|
|
30, 31, 32, 33, -1, 35, -1, 37, 38, 2164,
|
|
-1, 5, -1, -1, 2169, 9, 10, -1, -1, -1,
|
|
-1, -1, 16, 17, 2179, 2180, -1, 21, 22, 23,
|
|
24, 25, -1, -1, 28, 29, 30, 31, 32, 33,
|
|
-1, 35, -1, 37, 38, -1, -1, -1, -1, -1,
|
|
-1, -1, 5, -1, -1, 2210, 9, 10, -1, -1,
|
|
-1, -1, -1, 16, 17, 2220, 2221, -1, 21, 22,
|
|
23, 24, 25, -1, -1, 28, 29, 30, 31, 32,
|
|
33, -1, 35, 5, 37, 38, -1, 9, 10, -1,
|
|
-1, -1, -1, -1, 16, 17, -1, -1, -1, 21,
|
|
22, 23, 24, 25, -1, -1, 28, 29, 30, 31,
|
|
32, 33, -1, 35, -1, 37, 38, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, 2296, -1, 2298, 5, -1, -1, 8, 9, 10,
|
|
-1, -1, 2307, -1, -1, 16, 17, 2312, -1, -1,
|
|
2315, 22, 23, 24, 25, -1, -1, 28, 29, 30,
|
|
31, 32, 33, 2328, 35, -1, 37, 38, -1, 5,
|
|
-1, -1, -1, 9, 10, -1, -1, -1, -1, -1,
|
|
16, 17, -1, 602, 603, 21, 22, 23, 24, 25,
|
|
-1, -1, 28, 29, 30, 31, 32, 33, -1, 35,
|
|
-1, 37, 38, -1, -1, 5, -1, -1, 2373, 9,
|
|
10, -1, -1, -1, 2379, -1, 16, 17, -1, -1,
|
|
2385, 21, 22, 23, 24, 25, -1, -1, 28, 29,
|
|
30, 31, 32, 33, -1, 35, 5, 37, 38, 2404,
|
|
9, 10, -1, -1, -1, -1, -1, 16, 17, -1,
|
|
-1, -1, 21, 22, 23, 24, 25, -1, -1, 28,
|
|
29, 30, 31, 32, 33, -1, 35, -1, 37, 38,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, 2447, -1, 2449, -1, -1, -1, 2453, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, 2464,
|
|
2465, -1, -1, -1, 2469, 5, -1, -1, 8, 9,
|
|
10, -1, -1, -1, 2479, -1, 16, 17, 2483, -1,
|
|
-1, -1, 22, 23, 24, 25, -1, -1, 28, 29,
|
|
30, 31, 32, 33, -1, 35, -1, 37, 38, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
2515, -1, -1, -1, -1, 2520, -1, 2522, -1, -1,
|
|
-1, 5, -1, -1, -1, 9, 10, 6, -1, 2534,
|
|
-1, 2536, 16, 17, 13, -1, -1, 21, 22, 23,
|
|
24, 25, -1, -1, 28, 29, 30, 31, 32, 33,
|
|
-1, 35, -1, 37, 38, -1, -1, -1, -1, 2564,
|
|
-1, -1, -1, 2568, 43, 44, 45, 46, -1, 48,
|
|
49, 50, 51, 52, 53, 2580, -1, 56, 57, -1,
|
|
-1, -1, 61, 62, 63, -1, 65, 66, 67, 68,
|
|
69, 70, -1, 72, 73, 74, 75, 76, 77, -1,
|
|
79, 80, 81, 82, 83, 84, -1, -1, 87, 88,
|
|
89, 90, 91, -1, -1, 94, 95, 96, 97, 98,
|
|
99, 100, 101, 102, 103, 104, 105, 106, 107, 108,
|
|
109, 110, 111, 112, 113, 114, 115, -1, 117, -1,
|
|
119, 120, -1, 122, 123, 124, -1, -1, 127, -1,
|
|
-1, 130, 131, -1, 133, 134, 135, 136, -1, 138,
|
|
139, 140, 141, 142, 143, 144, 145, 146, -1, -1,
|
|
-1, -1, -1, 152, 153, 154, 155, -1, -1, -1,
|
|
-1, 160, -1, -1, 163, 164, -1, -1, 167, 168,
|
|
-1, 170, -1, -1, -1, 174, -1, 176, -1, 178,
|
|
-1, -1, -1, 182, 183, 184, 185, 186, 187, 188,
|
|
189, 190, 191, -1, 193, 194, 195, -1, 197, -1,
|
|
199, 200, -1, 202, -1, 204, 205, 206, 207, -1,
|
|
-1, 210, 211, 212, -1, 214, 215, 216, -1, 218,
|
|
219, 220, -1, 222, -1, 224, 225, 226, 227, 228,
|
|
-1, 230, -1, 232, 233, -1, -1, 236, 237, 238,
|
|
-1, -1, 241, 242, -1, 244, 245, -1, 247, 248,
|
|
-1, -1, -1, 252, 253, -1, -1, 256, -1, -1,
|
|
259, -1, -1, -1, 263, 264, -1, -1, 267, 268,
|
|
269, -1, 271, 272, 273, 274, 275, 276, 277, 278,
|
|
279, 280, 281, -1, 283, -1, -1, 286, -1, -1,
|
|
-1, 290, 291, 292, 293, 294, -1, 296, 297, -1,
|
|
-1, 300, 301, 302, 303, -1, -1, -1, -1, 308,
|
|
309, 310, 311, 312, 313, -1, -1, -1, -1, -1,
|
|
-1, -1, 321, -1, 323, -1, 325, 326, 327, 328,
|
|
329, -1, -1, -1, 333, 334, 335, 336, 337, 338,
|
|
5, 340, 341, 8, 9, 10, 345, -1, -1, -1,
|
|
-1, 16, 17, -1, -1, -1, -1, 22, 23, 24,
|
|
25, -1, -1, 28, 29, 30, 31, 32, 33, -1,
|
|
35, 5, 37, 38, 8, 9, 10, -1, -1, -1,
|
|
-1, -1, 16, 17, -1, -1, -1, -1, 22, 23,
|
|
24, 25, -1, -1, 28, 29, 30, 31, 32, 33,
|
|
-1, 35, 5, 37, 38, -1, 9, 10, -1, -1,
|
|
-1, -1, -1, 16, 17, -1, -1, -1, 21, 22,
|
|
23, 24, 25, -1, -1, 28, 29, 30, 31, 32,
|
|
33, -1, 35, 5, 37, 38, 8, 9, 10, -1,
|
|
-1, -1, -1, -1, 16, 17, -1, -1, -1, -1,
|
|
22, 23, 24, 25, -1, -1, 28, 29, 30, 31,
|
|
32, 33, -1, 35, 5, 37, 38, -1, 9, 10,
|
|
-1, -1, -1, -1, -1, 16, 17, -1, -1, -1,
|
|
21, 22, 23, 24, 25, -1, -1, 28, 29, 30,
|
|
31, 32, 33, -1, 35, 5, 37, 38, -1, 9,
|
|
10, -1, -1, -1, -1, -1, 16, 17, -1, -1,
|
|
-1, 21, 22, 23, 24, 25, -1, -1, 28, 29,
|
|
30, 31, 32, 33, -1, 35, 5, 37, 38, 8,
|
|
9, 10, -1, -1, -1, -1, -1, 16, 17, -1,
|
|
-1, -1, -1, 22, 23, 24, 25, -1, -1, 28,
|
|
29, 30, 31, 32, 33, -1, 35, 5, 37, 38,
|
|
8, 9, 10, -1, -1, -1, -1, -1, 16, 17,
|
|
-1, -1, -1, -1, 22, 23, 24, 25, -1, -1,
|
|
28, 29, 30, 31, 32, 33, -1, 35, 5, 37,
|
|
38, -1, 9, 10, -1, -1, -1, -1, -1, 16,
|
|
17, -1, -1, -1, 21, 22, 23, 24, 25, -1,
|
|
-1, 28, 29, 30, 31, 32, 33, -1, 35, 5,
|
|
37, 38, -1, 9, 10, -1, -1, -1, -1, -1,
|
|
16, 17, -1, -1, -1, 21, 22, 23, 24, 25,
|
|
-1, -1, 28, 29, 30, 31, 32, 33, -1, 35,
|
|
5, 37, 38, 8, 9, 10, -1, -1, -1, -1,
|
|
-1, 16, 17, -1, -1, -1, -1, 22, 23, 24,
|
|
25, -1, -1, 28, 29, 30, 31, 32, 33, -1,
|
|
35, -1, 37, 38, 5, -1, 7, -1, 9, 10,
|
|
-1, -1, -1, -1, -1, 16, 17, -1, -1, -1,
|
|
-1, 22, 23, 24, 25, -1, -1, 28, 29, 30,
|
|
31, 32, 33, -1, 35, 5, 37, 38, -1, 9,
|
|
10, -1, -1, -1, -1, -1, 16, 17, -1, -1,
|
|
-1, -1, 22, 23, 24, 25, -1, -1, 28, 29,
|
|
30, 31, 32, 33, -1, 35, -1, 37, 38
|
|
};
|
|
|
|
/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
|
|
symbol of state STATE-NUM. */
|
|
static const yytype_uint16 yystos[] =
|
|
{
|
|
0, 362, 0, 1, 150, 257, 363, 364, 116, 6,
|
|
13, 43, 44, 45, 46, 48, 49, 50, 51, 52,
|
|
53, 56, 57, 61, 62, 63, 65, 66, 67, 68,
|
|
69, 70, 72, 73, 74, 75, 76, 77, 79, 80,
|
|
81, 82, 83, 84, 87, 88, 89, 90, 91, 94,
|
|
95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
|
|
105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
|
|
115, 117, 119, 120, 122, 123, 124, 127, 130, 131,
|
|
133, 134, 135, 136, 138, 139, 140, 141, 142, 143,
|
|
144, 145, 146, 152, 153, 154, 155, 160, 163, 164,
|
|
167, 168, 170, 174, 176, 178, 182, 183, 184, 185,
|
|
186, 187, 188, 189, 190, 191, 193, 194, 195, 197,
|
|
199, 200, 202, 204, 205, 206, 207, 210, 211, 212,
|
|
214, 215, 216, 218, 219, 220, 222, 224, 225, 226,
|
|
227, 228, 230, 232, 233, 236, 237, 238, 241, 242,
|
|
244, 245, 247, 248, 252, 253, 256, 259, 263, 264,
|
|
267, 268, 269, 271, 272, 273, 274, 275, 276, 277,
|
|
278, 279, 280, 281, 283, 286, 290, 291, 292, 293,
|
|
294, 296, 297, 300, 301, 302, 303, 308, 309, 310,
|
|
311, 312, 313, 321, 323, 325, 326, 327, 328, 329,
|
|
333, 334, 335, 336, 337, 338, 340, 341, 345, 365,
|
|
367, 370, 382, 383, 387, 388, 389, 395, 396, 397,
|
|
398, 400, 401, 403, 405, 406, 407, 408, 415, 416,
|
|
417, 418, 419, 420, 424, 425, 426, 430, 431, 469,
|
|
471, 484, 527, 528, 530, 531, 537, 538, 539, 540,
|
|
547, 548, 549, 550, 552, 555, 559, 560, 561, 562,
|
|
563, 564, 570, 571, 572, 583, 584, 585, 587, 590,
|
|
593, 598, 599, 601, 603, 605, 608, 609, 633, 634,
|
|
645, 646, 647, 648, 653, 656, 659, 662, 663, 713,
|
|
714, 715, 716, 717, 718, 719, 720, 726, 728, 730,
|
|
732, 734, 735, 736, 737, 738, 741, 743, 744, 745,
|
|
748, 749, 753, 754, 756, 757, 758, 759, 760, 761,
|
|
762, 765, 770, 775, 777, 778, 779, 780, 782, 783,
|
|
784, 785, 786, 787, 804, 807, 808, 809, 810, 816,
|
|
819, 824, 825, 826, 829, 830, 831, 832, 833, 834,
|
|
835, 836, 837, 838, 839, 840, 841, 842, 843, 848,
|
|
849, 850, 851, 852, 853, 863, 864, 865, 868, 872,
|
|
873, 874, 875, 876, 881, 901, 15, 494, 494, 556,
|
|
556, 556, 556, 556, 494, 556, 556, 366, 556, 556,
|
|
556, 494, 556, 494, 556, 556, 494, 556, 556, 556,
|
|
493, 556, 494, 556, 556, 7, 15, 495, 15, 494,
|
|
616, 556, 494, 379, 556, 556, 556, 556, 556, 556,
|
|
556, 556, 556, 556, 129, 372, 536, 536, 556, 556,
|
|
556, 494, 556, 372, 556, 494, 494, 556, 556, 493,
|
|
366, 494, 494, 64, 378, 556, 556, 494, 494, 556,
|
|
494, 494, 494, 494, 494, 556, 433, 556, 556, 556,
|
|
372, 470, 366, 494, 556, 556, 556, 494, 556, 494,
|
|
556, 556, 494, 556, 556, 556, 494, 366, 494, 379,
|
|
556, 556, 379, 556, 494, 556, 556, 556, 494, 556,
|
|
556, 494, 556, 494, 556, 556, 556, 556, 556, 556,
|
|
15, 494, 594, 494, 366, 494, 494, 556, 556, 556,
|
|
15, 8, 494, 494, 556, 556, 556, 494, 556, 556,
|
|
556, 556, 556, 556, 556, 556, 556, 556, 556, 556,
|
|
556, 556, 556, 556, 556, 556, 556, 556, 556, 556,
|
|
556, 556, 556, 556, 494, 556, 494, 556, 556, 556,
|
|
556, 494, 494, 556, 556, 556, 556, 556, 556, 556,
|
|
556, 907, 907, 907, 907, 907, 907, 257, 582, 124,
|
|
233, 403, 15, 375, 582, 8, 8, 8, 8, 7,
|
|
8, 124, 367, 390, 8, 372, 404, 8, 8, 8,
|
|
8, 8, 551, 8, 551, 8, 8, 8, 8, 551,
|
|
582, 7, 218, 252, 528, 530, 539, 540, 239, 548,
|
|
548, 10, 14, 15, 16, 17, 27, 34, 36, 64,
|
|
92, 149, 201, 372, 384, 500, 501, 503, 504, 505,
|
|
506, 512, 513, 514, 515, 516, 519, 15, 556, 5,
|
|
9, 15, 16, 17, 129, 502, 504, 512, 566, 580,
|
|
581, 556, 15, 566, 556, 5, 565, 566, 581, 566,
|
|
8, 8, 8, 8, 8, 8, 8, 8, 7, 8,
|
|
8, 5, 7, 372, 643, 644, 372, 636, 495, 15,
|
|
15, 149, 483, 372, 372, 746, 747, 8, 372, 660,
|
|
661, 747, 372, 374, 372, 15, 532, 578, 23, 37,
|
|
372, 422, 423, 15, 372, 606, 372, 674, 674, 372,
|
|
657, 658, 372, 535, 432, 15, 372, 586, 149, 752,
|
|
535, 7, 478, 479, 494, 617, 618, 372, 612, 618,
|
|
15, 557, 372, 588, 589, 535, 15, 15, 535, 752,
|
|
536, 535, 535, 535, 535, 372, 535, 375, 535, 15,
|
|
427, 495, 503, 504, 15, 369, 372, 372, 654, 655,
|
|
485, 486, 487, 488, 8, 675, 742, 15, 372, 600,
|
|
372, 591, 592, 579, 15, 15, 372, 495, 15, 500,
|
|
755, 15, 15, 372, 729, 731, 8, 372, 37, 421,
|
|
15, 504, 505, 495, 15, 15, 557, 483, 495, 504,
|
|
372, 721, 5, 15, 580, 581, 495, 372, 373, 495,
|
|
579, 15, 503, 637, 638, 612, 616, 372, 604, 372,
|
|
701, 701, 15, 372, 602, 721, 500, 511, 495, 379,
|
|
15, 372, 707, 707, 707, 707, 707, 7, 500, 595,
|
|
596, 372, 597, 495, 368, 372, 495, 372, 727, 729,
|
|
372, 494, 495, 372, 472, 15, 15, 579, 372, 15,
|
|
618, 15, 618, 618, 618, 618, 790, 846, 618, 618,
|
|
618, 618, 618, 618, 790, 372, 379, 854, 855, 856,
|
|
15, 15, 8, 869, 870, 871, 495, 15, 500, 500,
|
|
500, 500, 499, 500, 15, 15, 15, 15, 15, 372,
|
|
899, 15, 366, 366, 124, 5, 21, 372, 376, 377,
|
|
371, 379, 372, 372, 372, 423, 7, 379, 366, 124,
|
|
372, 372, 5, 15, 410, 411, 372, 423, 423, 423,
|
|
423, 422, 503, 421, 372, 372, 427, 434, 435, 437,
|
|
438, 556, 556, 239, 413, 500, 501, 500, 500, 500,
|
|
500, 5, 9, 16, 17, 22, 23, 24, 25, 26,
|
|
28, 29, 30, 31, 32, 33, 35, 37, 38, 384,
|
|
15, 246, 3, 15, 246, 246, 15, 509, 510, 21,
|
|
553, 578, 511, 5, 9, 166, 567, 568, 569, 580,
|
|
26, 580, 5, 9, 23, 37, 502, 579, 580, 579,
|
|
8, 15, 504, 573, 574, 15, 500, 501, 516, 575,
|
|
576, 577, 575, 586, 372, 600, 602, 604, 606, 372,
|
|
7, 379, 727, 8, 21, 638, 423, 525, 500, 240,
|
|
551, 15, 379, 15, 477, 8, 578, 7, 500, 533,
|
|
534, 535, 15, 372, 477, 423, 482, 483, 8, 434,
|
|
525, 477, 15, 8, 21, 5, 7, 480, 481, 500,
|
|
372, 8, 21, 5, 58, 86, 126, 137, 165, 258,
|
|
619, 615, 616, 175, 607, 500, 149, 546, 8, 500,
|
|
500, 371, 372, 428, 429, 503, 508, 372, 26, 372,
|
|
541, 542, 544, 375, 8, 8, 15, 231, 403, 489,
|
|
379, 8, 742, 372, 503, 711, 721, 739, 740, 8,
|
|
566, 26, 5, 9, 16, 17, 22, 23, 24, 25,
|
|
28, 29, 30, 31, 32, 33, 34, 35, 37, 38,
|
|
384, 385, 386, 372, 379, 393, 503, 500, 15, 379,
|
|
372, 372, 503, 503, 526, 8, 676, 733, 372, 503,
|
|
664, 372, 467, 468, 546, 423, 18, 579, 580, 579,
|
|
399, 402, 643, 638, 7, 616, 618, 711, 721, 722,
|
|
723, 422, 423, 461, 462, 62, 503, 766, 15, 15,
|
|
7, 8, 21, 594, 423, 375, 423, 477, 8, 673,
|
|
698, 21, 379, 372, 8, 500, 500, 477, 503, 551,
|
|
811, 503, 287, 823, 823, 551, 820, 823, 15, 551,
|
|
788, 551, 827, 788, 788, 551, 805, 551, 817, 477,
|
|
147, 148, 180, 314, 315, 318, 319, 380, 857, 858,
|
|
859, 8, 21, 504, 679, 860, 21, 860, 379, 871,
|
|
372, 866, 867, 379, 763, 764, 8, 8, 8, 8,
|
|
503, 506, 507, 781, 664, 379, 882, 883, 884, 885,
|
|
886, 887, 888, 379, 891, 892, 893, 894, 895, 379,
|
|
896, 897, 8, 379, 902, 903, 372, 368, 366, 8,
|
|
21, 213, 380, 477, 44, 87, 93, 119, 143, 145,
|
|
178, 183, 187, 191, 194, 216, 230, 236, 391, 392,
|
|
394, 372, 366, 494, 557, 578, 404, 477, 551, 551,
|
|
8, 37, 15, 372, 440, 445, 379, 15, 520, 21,
|
|
8, 500, 500, 500, 500, 500, 500, 500, 500, 500,
|
|
500, 500, 500, 500, 500, 500, 500, 500, 500, 500,
|
|
578, 64, 129, 496, 498, 578, 503, 514, 517, 64,
|
|
517, 511, 8, 21, 5, 500, 554, 569, 8, 21,
|
|
5, 9, 500, 21, 500, 580, 580, 580, 580, 580,
|
|
21, 573, 573, 8, 500, 501, 576, 577, 8, 8,
|
|
8, 477, 477, 494, 43, 67, 82, 87, 88, 94,
|
|
228, 259, 303, 647, 644, 379, 507, 523, 21, 372,
|
|
15, 499, 67, 478, 661, 500, 7, 8, 21, 553,
|
|
37, 8, 21, 658, 503, 506, 522, 524, 578, 750,
|
|
480, 7, 477, 618, 15, 15, 15, 15, 15, 15,
|
|
607, 618, 372, 21, 558, 589, 21, 21, 15, 8,
|
|
21, 8, 510, 504, 8, 543, 26, 371, 655, 486,
|
|
129, 490, 491, 492, 408, 169, 208, 282, 379, 15,
|
|
7, 8, 21, 592, 575, 21, 21, 147, 148, 180,
|
|
21, 18, 21, 7, 500, 518, 175, 324, 37, 8,
|
|
21, 379, 8, 21, 26, 8, 21, 558, 500, 21,
|
|
463, 464, 463, 21, 7, 618, 607, 15, 7, 8,
|
|
21, 8, 15, 15, 26, 708, 709, 711, 499, 500,
|
|
596, 379, 8, 698, 8, 673, 404, 394, 381, 21,
|
|
21, 21, 618, 551, 21, 618, 551, 847, 618, 551,
|
|
618, 551, 618, 551, 618, 551, 15, 15, 15, 15,
|
|
15, 15, 379, 856, 8, 21, 21, 191, 858, 8,
|
|
182, 315, 318, 8, 21, 379, 379, 379, 500, 15,
|
|
15, 8, 21, 21, 183, 191, 208, 357, 358, 8,
|
|
21, 41, 209, 228, 8, 21, 339, 342, 343, 344,
|
|
355, 356, 8, 21, 379, 244, 331, 346, 347, 348,
|
|
8, 21, 375, 372, 377, 15, 409, 410, 477, 494,
|
|
15, 7, 8, 372, 477, 15, 514, 5, 412, 500,
|
|
569, 423, 503, 437, 15, 16, 17, 27, 36, 59,
|
|
64, 92, 149, 201, 436, 438, 448, 449, 450, 451,
|
|
452, 453, 454, 455, 440, 445, 446, 447, 15, 441,
|
|
442, 62, 500, 575, 501, 496, 21, 8, 497, 500,
|
|
518, 569, 7, 578, 483, 500, 578, 8, 574, 21,
|
|
8, 8, 8, 501, 577, 501, 577, 501, 577, 372,
|
|
255, 8, 21, 483, 482, 21, 7, 21, 500, 533,
|
|
21, 483, 551, 8, 21, 569, 751, 8, 21, 481,
|
|
500, 619, 578, 15, 621, 372, 620, 620, 500, 620,
|
|
477, 618, 239, 535, 499, 429, 429, 372, 500, 542,
|
|
21, 500, 518, 8, 21, 16, 15, 15, 15, 499,
|
|
739, 740, 495, 503, 771, 7, 500, 7, 21, 21,
|
|
372, 614, 504, 503, 191, 503, 618, 665, 500, 468,
|
|
551, 8, 47, 177, 372, 466, 379, 635, 637, 607,
|
|
7, 7, 500, 724, 725, 722, 723, 462, 500, 5,
|
|
621, 767, 768, 774, 500, 631, 8, 21, 15, 21,
|
|
71, 208, 379, 379, 495, 172, 372, 475, 476, 504,
|
|
191, 208, 282, 285, 290, 298, 791, 792, 793, 800,
|
|
812, 813, 814, 618, 266, 821, 822, 823, 618, 37,
|
|
503, 844, 845, 84, 265, 289, 299, 304, 789, 791,
|
|
792, 793, 794, 795, 796, 798, 799, 800, 618, 791,
|
|
792, 793, 794, 795, 796, 798, 799, 800, 813, 814,
|
|
828, 618, 791, 792, 793, 800, 806, 618, 791, 792,
|
|
818, 618, 860, 860, 860, 379, 861, 862, 860, 860,
|
|
504, 15, 867, 764, 331, 315, 332, 578, 496, 507,
|
|
15, 15, 15, 15, 15, 883, 15, 15, 15, 892,
|
|
15, 15, 15, 15, 897, 352, 353, 15, 15, 15,
|
|
15, 15, 903, 372, 18, 26, 414, 15, 393, 7,
|
|
379, 409, 558, 558, 413, 5, 500, 451, 452, 453,
|
|
456, 452, 454, 452, 454, 246, 246, 246, 246, 246,
|
|
8, 37, 372, 439, 503, 5, 441, 442, 8, 15,
|
|
16, 17, 149, 372, 439, 443, 444, 457, 458, 459,
|
|
460, 15, 442, 15, 21, 521, 21, 21, 510, 578,
|
|
500, 511, 554, 568, 580, 544, 545, 501, 545, 545,
|
|
545, 477, 372, 639, 642, 578, 8, 21, 7, 413,
|
|
500, 578, 500, 578, 569, 632, 500, 622, 623, 21,
|
|
21, 21, 21, 8, 8, 254, 529, 535, 21, 491,
|
|
492, 679, 679, 679, 21, 21, 372, 15, 21, 500,
|
|
7, 7, 500, 477, 15, 173, 8, 669, 670, 671,
|
|
672, 673, 675, 676, 677, 680, 682, 683, 684, 698,
|
|
706, 544, 464, 15, 15, 465, 255, 8, 7, 8,
|
|
21, 21, 21, 8, 21, 21, 709, 710, 15, 15,
|
|
372, 372, 473, 474, 476, 18, 8, 26, 790, 15,
|
|
790, 790, 15, 618, 812, 790, 618, 821, 372, 8,
|
|
21, 15, 790, 15, 790, 15, 618, 789, 618, 828,
|
|
618, 806, 618, 818, 21, 21, 21, 316, 317, 8,
|
|
21, 21, 21, 866, 15, 15, 496, 21, 507, 889,
|
|
890, 679, 379, 702, 514, 679, 708, 722, 708, 664,
|
|
664, 507, 900, 500, 898, 15, 15, 379, 904, 905,
|
|
664, 664, 500, 379, 906, 21, 500, 500, 649, 650,
|
|
21, 392, 414, 5, 500, 404, 8, 21, 8, 517,
|
|
517, 517, 517, 517, 448, 5, 15, 438, 449, 442,
|
|
372, 439, 447, 457, 458, 458, 8, 21, 7, 16,
|
|
17, 5, 37, 9, 457, 500, 20, 510, 497, 21,
|
|
26, 21, 21, 21, 21, 15, 507, 569, 483, 660,
|
|
495, 522, 569, 751, 500, 21, 7, 8, 21, 500,
|
|
379, 15, 21, 21, 21, 7, 772, 773, 774, 500,
|
|
500, 7, 679, 503, 666, 379, 671, 26, 466, 26,
|
|
385, 639, 637, 372, 610, 611, 612, 613, 725, 768,
|
|
618, 78, 595, 372, 674, 722, 699, 8, 372, 476,
|
|
500, 618, 801, 379, 618, 618, 846, 503, 844, 379,
|
|
500, 500, 618, 618, 618, 618, 862, 21, 679, 503,
|
|
21, 26, 8, 21, 21, 22, 24, 33, 35, 158,
|
|
159, 161, 162, 192, 234, 247, 703, 704, 705, 8,
|
|
21, 21, 21, 21, 21, 21, 21, 21, 8, 21,
|
|
8, 21, 379, 877, 878, 877, 315, 351, 8, 21,
|
|
21, 21, 21, 349, 350, 8, 8, 21, 7, 21,
|
|
21, 578, 456, 449, 578, 439, 26, 21, 457, 444,
|
|
458, 458, 459, 459, 459, 21, 500, 5, 500, 518,
|
|
640, 641, 503, 8, 679, 503, 8, 500, 623, 379,
|
|
21, 254, 500, 8, 21, 500, 21, 15, 41, 135,
|
|
209, 221, 223, 224, 226, 229, 320, 322, 500, 465,
|
|
21, 21, 15, 8, 132, 769, 21, 21, 7, 21,
|
|
701, 703, 474, 5, 16, 17, 22, 24, 33, 35,
|
|
37, 159, 162, 247, 305, 306, 307, 803, 21, 94,
|
|
230, 284, 295, 815, 37, 191, 288, 299, 797, 21,
|
|
21, 21, 21, 500, 890, 15, 15, 379, 507, 500,
|
|
354, 8, 21, 21, 905, 500, 7, 7, 412, 21,
|
|
496, 443, 457, 21, 8, 8, 21, 483, 569, 255,
|
|
15, 21, 773, 5, 500, 667, 668, 15, 685, 15,
|
|
15, 15, 15, 707, 707, 15, 15, 15, 8, 499,
|
|
611, 711, 712, 15, 722, 700, 700, 7, 8, 21,
|
|
847, 21, 8, 504, 679, 703, 8, 878, 8, 879,
|
|
8, 880, 21, 7, 413, 21, 21, 500, 641, 500,
|
|
372, 624, 625, 500, 8, 21, 686, 685, 721, 739,
|
|
721, 722, 711, 708, 500, 500, 678, 666, 681, 500,
|
|
21, 8, 379, 21, 7, 8, 21, 679, 802, 500,
|
|
379, 21, 8, 500, 379, 379, 372, 651, 652, 21,
|
|
8, 15, 21, 668, 148, 180, 687, 7, 21, 7,
|
|
21, 15, 21, 21, 8, 21, 8, 21, 8, 711,
|
|
78, 702, 702, 21, 330, 500, 504, 353, 352, 8,
|
|
500, 40, 500, 626, 627, 774, 7, 7, 688, 689,
|
|
711, 739, 722, 595, 500, 666, 500, 21, 21, 21,
|
|
15, 21, 15, 15, 652, 372, 628, 8, 21, 8,
|
|
21, 15, 21, 21, 21, 8, 499, 877, 877, 17,
|
|
629, 630, 627, 689, 500, 690, 691, 21, 500, 21,
|
|
21, 21, 631, 17, 7, 8, 21, 8, 776, 631,
|
|
500, 691, 15, 379, 379, 692, 693, 694, 695, 696,
|
|
182, 318, 128, 157, 217, 8, 21, 7, 7, 15,
|
|
697, 697, 697, 693, 379, 695, 696, 379, 696, 498,
|
|
7, 21, 696
|
|
};
|
|
|
|
/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
|
|
static const yytype_uint16 yyr1[] =
|
|
{
|
|
0, 361, 362, 362, 363, 363, 363, 363, 363, 363,
|
|
363, 364, 365, 365, 365, 365, 365, 365, 365, 365,
|
|
366, 367, 367, 367, 368, 369, 370, 370, 370, 370,
|
|
371, 371, 372, 373, 373, 374, 374, 375, 375, 375,
|
|
376, 376, 377, 377, 378, 379, 380, 381, 382, 382,
|
|
382, 382, 382, 382, 382, 382, 382, 382, 382, 382,
|
|
382, 382, 382, 382, 382, 382, 382, 382, 382, 382,
|
|
382, 382, 382, 382, 382, 382, 382, 382, 383, 383,
|
|
383, 383, 383, 384, 385, 385, 386, 386, 386, 386,
|
|
386, 386, 386, 386, 386, 386, 386, 386, 386, 386,
|
|
386, 386, 386, 386, 387, 387, 388, 388, 389, 389,
|
|
390, 390, 390, 391, 391, 392, 392, 392, 392, 392,
|
|
392, 392, 392, 392, 392, 392, 392, 393, 393, 393,
|
|
394, 394, 395, 395, 396, 396, 397, 397, 398, 398,
|
|
399, 400, 401, 401, 402, 403, 403, 404, 405, 405,
|
|
406, 406, 407, 408, 408, 408, 408, 408, 408, 408,
|
|
409, 409, 410, 410, 410, 411, 411, 411, 411, 412,
|
|
412, 412, 412, 413, 414, 414, 414, 415, 415, 416,
|
|
416, 417, 417, 418, 418, 419, 419, 419, 419, 420,
|
|
420, 420, 421, 422, 422, 423, 424, 424, 425, 425,
|
|
426, 426, 427, 428, 428, 429, 429, 429, 430, 431,
|
|
431, 432, 433, 434, 435, 435, 436, 436, 437, 437,
|
|
437, 437, 437, 438, 439, 440, 441, 442, 443, 443,
|
|
444, 444, 445, 446, 446, 447, 447, 447, 447, 448,
|
|
448, 448, 449, 449, 449, 449, 449, 449, 449, 449,
|
|
449, 449, 449, 450, 451, 451, 451, 452, 452, 453,
|
|
453, 453, 454, 454, 454, 454, 455, 456, 456, 457,
|
|
457, 457, 457, 457, 458, 458, 458, 459, 459, 460,
|
|
460, 460, 461, 461, 462, 462, 463, 463, 464, 465,
|
|
466, 466, 466, 467, 467, 468, 469, 470, 470, 471,
|
|
471, 471, 471, 472, 473, 473, 474, 474, 475, 475,
|
|
476, 477, 477, 479, 478, 478, 480, 480, 480, 480,
|
|
481, 481, 482, 482, 483, 484, 484, 485, 485, 486,
|
|
488, 487, 489, 489, 490, 490, 491, 491, 492, 493,
|
|
494, 495, 495, 496, 496, 497, 497, 497, 498, 498,
|
|
499, 499, 500, 500, 500, 501, 501, 501, 501, 501,
|
|
501, 501, 501, 501, 501, 501, 501, 501, 501, 501,
|
|
501, 501, 501, 501, 501, 501, 501, 501, 501, 501,
|
|
502, 502, 503, 504, 504, 504, 505, 505, 505, 505,
|
|
506, 507, 507, 507, 507, 508, 509, 509, 510, 511,
|
|
511, 512, 512, 512, 512, 512, 513, 513, 513, 513,
|
|
514, 515, 515, 515, 516, 517, 517, 518, 518, 518,
|
|
518, 518, 518, 518, 518, 520, 521, 519, 522, 522,
|
|
523, 523, 523, 524, 524, 524, 525, 526, 526, 527,
|
|
527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
|
|
527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
|
|
527, 527, 527, 528, 528, 529, 529, 529, 530, 530,
|
|
531, 531, 531, 531, 531, 532, 533, 533, 533, 533,
|
|
534, 534, 535, 535, 536, 536, 537, 538, 539, 540,
|
|
541, 541, 542, 543, 543, 544, 545, 545, 546, 546,
|
|
547, 547, 547, 547, 547, 548, 548, 548, 548, 548,
|
|
548, 548, 548, 548, 548, 548, 548, 548, 548, 548,
|
|
548, 548, 548, 549, 550, 550, 550, 550, 551, 551,
|
|
552, 553, 553, 554, 554, 554, 555, 555, 556, 557,
|
|
558, 559, 559, 559, 559, 559, 559, 559, 559, 559,
|
|
559, 559, 559, 559, 559, 560, 561, 561, 561, 562,
|
|
563, 563, 564, 564, 565, 565, 566, 566, 567, 567,
|
|
568, 568, 568, 568, 568, 568, 569, 570, 571, 572,
|
|
572, 573, 573, 574, 574, 575, 575, 575, 576, 576,
|
|
576, 576, 576, 576, 577, 577, 577, 577, 577, 578,
|
|
579, 580, 580, 581, 581, 581, 581, 581, 581, 581,
|
|
581, 581, 582, 582, 583, 583, 583, 583, 583, 583,
|
|
583, 583, 583, 583, 583, 583, 583, 583, 583, 583,
|
|
583, 583, 583, 584, 584, 584, 584, 584, 584, 584,
|
|
584, 584, 584, 584, 584, 584, 584, 584, 584, 584,
|
|
584, 584, 584, 584, 584, 584, 584, 584, 584, 584,
|
|
584, 584, 584, 584, 584, 584, 584, 584, 584, 584,
|
|
584, 584, 584, 584, 584, 584, 584, 585, 585, 586,
|
|
587, 588, 588, 589, 590, 591, 591, 592, 593, 594,
|
|
595, 595, 596, 596, 596, 597, 598, 598, 598, 599,
|
|
599, 600, 601, 601, 602, 603, 603, 604, 605, 605,
|
|
606, 607, 607, 608, 609, 609, 610, 610, 611, 611,
|
|
612, 613, 614, 615, 615, 616, 617, 617, 618, 619,
|
|
619, 619, 619, 619, 619, 619, 619, 620, 621, 622,
|
|
622, 623, 623, 624, 624, 625, 626, 626, 627, 627,
|
|
627, 628, 629, 629, 630, 630, 631, 632, 632, 633,
|
|
634, 634, 635, 635, 636, 637, 638, 639, 640, 640,
|
|
641, 641, 641, 642, 643, 643, 644, 644, 644, 645,
|
|
645, 646, 646, 647, 647, 647, 647, 647, 647, 647,
|
|
647, 647, 647, 647, 648, 650, 649, 649, 651, 651,
|
|
652, 653, 654, 654, 655, 656, 657, 657, 658, 659,
|
|
659, 660, 660, 661, 662, 663, 664, 664, 665, 665,
|
|
666, 667, 667, 668, 668, 669, 669, 670, 670, 671,
|
|
671, 671, 671, 671, 671, 671, 671, 671, 671, 671,
|
|
672, 672, 673, 673, 674, 675, 675, 676, 677, 678,
|
|
678, 678, 679, 679, 680, 681, 681, 682, 682, 683,
|
|
684, 684, 685, 686, 687, 687, 687, 688, 688, 689,
|
|
689, 689, 690, 690, 691, 692, 692, 693, 693, 693,
|
|
693, 693, 693, 693, 694, 695, 696, 697, 698, 698,
|
|
698, 699, 700, 701, 702, 702, 703, 703, 704, 704,
|
|
704, 704, 704, 704, 704, 704, 704, 705, 705, 706,
|
|
706, 706, 706, 706, 707, 708, 708, 709, 709, 709,
|
|
709, 710, 711, 712, 712, 713, 713, 714, 714, 715,
|
|
716, 717, 718, 719, 720, 720, 721, 722, 722, 723,
|
|
723, 724, 724, 725, 725, 726, 726, 727, 728, 728,
|
|
728, 728, 728, 729, 730, 731, 731, 732, 733, 733,
|
|
734, 735, 735, 736, 737, 738, 738, 739, 739, 740,
|
|
740, 741, 741, 741, 741, 742, 743, 744, 745, 746,
|
|
747, 747, 748, 749, 749, 750, 750, 751, 752, 753,
|
|
754, 755, 755, 756, 757, 758, 759, 760, 761, 762,
|
|
763, 763, 764, 764, 764, 765, 766, 767, 767, 768,
|
|
768, 769, 769, 770, 771, 771, 772, 772, 773, 773,
|
|
774, 775, 776, 776, 776, 777, 778, 778, 779, 780,
|
|
781, 781, 782, 783, 784, 784, 784, 784, 784, 784,
|
|
784, 784, 784, 784, 784, 784, 784, 784, 784, 784,
|
|
784, 784, 784, 784, 784, 784, 784, 784, 784, 784,
|
|
785, 786, 787, 787, 788, 788, 789, 789, 789, 789,
|
|
789, 789, 789, 789, 789, 790, 791, 792, 793, 794,
|
|
795, 796, 797, 797, 797, 798, 799, 800, 801, 802,
|
|
803, 803, 803, 803, 803, 803, 803, 803, 803, 803,
|
|
803, 803, 803, 803, 804, 804, 805, 805, 806, 806,
|
|
806, 806, 807, 807, 808, 809, 809, 810, 810, 811,
|
|
811, 812, 812, 812, 812, 812, 812, 813, 814, 814,
|
|
815, 815, 815, 815, 816, 816, 817, 817, 818, 818,
|
|
819, 819, 820, 820, 821, 821, 822, 823, 824, 825,
|
|
825, 826, 826, 827, 827, 828, 828, 828, 828, 828,
|
|
828, 828, 828, 828, 828, 828, 829, 830, 830, 831,
|
|
832, 832, 833, 834, 835, 836, 837, 838, 839, 840,
|
|
841, 841, 842, 842, 843, 843, 844, 845, 845, 845,
|
|
845, 846, 847, 848, 848, 849, 849, 849, 849, 849,
|
|
849, 850, 851, 852, 852, 852, 853, 853, 853, 854,
|
|
854, 855, 855, 856, 856, 856, 857, 857, 857, 857,
|
|
857, 858, 859, 860, 861, 861, 862, 862, 863, 864,
|
|
865, 866, 866, 867, 868, 869, 869, 870, 870, 871,
|
|
871, 872, 872, 872, 872, 872, 872, 873, 874, 875,
|
|
876, 876, 876, 877, 877, 878, 879, 879, 880, 880,
|
|
881, 882, 882, 883, 883, 883, 883, 883, 884, 885,
|
|
886, 887, 888, 889, 889, 890, 891, 891, 892, 892,
|
|
892, 893, 894, 895, 896, 896, 897, 897, 897, 897,
|
|
897, 897, 897, 897, 898, 899, 900, 900, 901, 902,
|
|
902, 903, 903, 903, 903, 903, 904, 904, 905, 905,
|
|
906, 906, 907
|
|
};
|
|
|
|
/* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
|
|
static const yytype_uint8 yyr2[] =
|
|
{
|
|
0, 2, 0, 3, 3, 3, 3, 3, 2, 1,
|
|
1, 1, 3, 3, 4, 5, 5, 3, 4, 3,
|
|
0, 2, 2, 2, 1, 1, 4, 5, 4, 5,
|
|
2, 5, 1, 0, 1, 0, 1, 0, 2, 3,
|
|
1, 3, 1, 1, 1, 0, 0, 0, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 2, 4, 2, 5, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
|
|
5, 5, 2, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 4, 7, 2, 3, 7, 6,
|
|
0, 2, 5, 1, 4, 1, 1, 1, 2, 1,
|
|
4, 1, 1, 1, 1, 1, 1, 2, 2, 2,
|
|
1, 1, 7, 3, 4, 3, 4, 3, 2, 5,
|
|
0, 2, 2, 5, 0, 4, 5, 0, 2, 3,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
0, 1, 5, 6, 6, 0, 1, 5, 9, 1,
|
|
1, 2, 2, 0, 0, 2, 2, 5, 4, 4,
|
|
3, 4, 3, 4, 3, 3, 4, 5, 3, 4,
|
|
5, 3, 3, 1, 3, 2, 4, 3, 4, 3,
|
|
3, 3, 3, 3, 3, 1, 4, 1, 1, 4,
|
|
3, 0, 0, 4, 1, 3, 1, 3, 2, 3,
|
|
3, 4, 2, 0, 1, 1, 3, 5, 1, 3,
|
|
0, 1, 7, 1, 3, 2, 2, 3, 1, 1,
|
|
4, 3, 2, 1, 1, 1, 1, 3, 1, 3,
|
|
1, 1, 6, 1, 1, 2, 2, 1, 3, 1,
|
|
2, 2, 1, 3, 1, 3, 5, 1, 1, 1,
|
|
2, 2, 3, 3, 1, 3, 3, 1, 3, 1,
|
|
1, 3, 1, 3, 1, 1, 3, 5, 0, 0,
|
|
1, 4, 4, 1, 3, 3, 2, 1, 3, 3,
|
|
6, 6, 7, 1, 1, 3, 1, 1, 1, 3,
|
|
3, 0, 3, 0, 2, 3, 1, 1, 2, 3,
|
|
1, 1, 1, 3, 1, 3, 1, 1, 3, 4,
|
|
0, 2, 2, 1, 1, 3, 1, 3, 1, 0,
|
|
0, 0, 2, 0, 1, 1, 1, 2, 2, 4,
|
|
1, 3, 1, 3, 1, 1, 1, 1, 3, 3,
|
|
3, 3, 3, 2, 2, 2, 3, 3, 3, 3,
|
|
3, 3, 3, 3, 3, 3, 3, 2, 3, 3,
|
|
1, 1, 1, 1, 1, 1, 5, 6, 4, 5,
|
|
3, 1, 1, 5, 4, 2, 0, 1, 5, 0,
|
|
1, 1, 3, 1, 3, 2, 1, 1, 1, 1,
|
|
1, 1, 3, 3, 5, 1, 1, 3, 2, 5,
|
|
4, 4, 3, 2, 1, 0, 0, 6, 1, 1,
|
|
1, 4, 5, 1, 4, 5, 0, 1, 3, 1,
|
|
1, 1, 2, 3, 3, 2, 1, 2, 2, 2,
|
|
3, 7, 3, 3, 1, 2, 2, 1, 2, 3,
|
|
1, 1, 1, 5, 7, 0, 6, 4, 11, 13,
|
|
4, 3, 3, 7, 8, 3, 1, 2, 2, 3,
|
|
1, 3, 0, 1, 0, 1, 1, 2, 5, 6,
|
|
1, 3, 3, 0, 2, 1, 5, 7, 0, 1,
|
|
3, 3, 6, 5, 6, 4, 5, 5, 2, 1,
|
|
1, 10, 1, 3, 4, 3, 3, 3, 3, 6,
|
|
6, 5, 8, 2, 3, 3, 7, 7, 0, 1,
|
|
4, 2, 4, 1, 2, 2, 1, 1, 0, 0,
|
|
0, 2, 2, 2, 2, 2, 1, 2, 2, 3,
|
|
4, 2, 3, 1, 3, 3, 1, 1, 1, 3,
|
|
1, 1, 4, 5, 1, 1, 3, 3, 1, 4,
|
|
1, 1, 1, 2, 2, 2, 1, 3, 3, 4,
|
|
4, 1, 3, 1, 5, 1, 1, 1, 3, 3,
|
|
3, 3, 3, 3, 1, 3, 5, 5, 5, 0,
|
|
0, 1, 3, 1, 1, 3, 3, 3, 3, 2,
|
|
3, 3, 0, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 3, 3, 2,
|
|
3, 1, 3, 1, 3, 1, 3, 1, 4, 3,
|
|
1, 3, 1, 3, 4, 1, 4, 4, 4, 3,
|
|
3, 1, 3, 3, 1, 3, 3, 1, 3, 3,
|
|
1, 3, 0, 5, 6, 8, 1, 3, 1, 1,
|
|
1, 4, 1, 0, 2, 3, 2, 4, 0, 1,
|
|
5, 4, 6, 4, 1, 4, 4, 1, 6, 1,
|
|
3, 1, 3, 1, 4, 1, 1, 3, 1, 1,
|
|
3, 1, 0, 1, 2, 3, 1, 2, 5, 4,
|
|
4, 6, 1, 3, 1, 1, 6, 4, 1, 3,
|
|
1, 1, 1, 1, 1, 3, 1, 1, 1, 6,
|
|
4, 1, 4, 1, 1, 1, 1, 4, 2, 7,
|
|
1, 4, 1, 1, 11, 0, 2, 3, 1, 3,
|
|
1, 3, 1, 3, 1, 3, 1, 3, 1, 3,
|
|
8, 1, 3, 2, 2, 7, 1, 3, 3, 1,
|
|
4, 1, 3, 1, 1, 0, 1, 1, 2, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
8, 6, 8, 6, 1, 6, 6, 6, 6, 1,
|
|
3, 5, 1, 3, 6, 1, 3, 8, 6, 6,
|
|
4, 5, 5, 0, 2, 2, 0, 1, 3, 1,
|
|
4, 7, 1, 3, 3, 1, 3, 5, 3, 3,
|
|
1, 3, 1, 1, 3, 3, 3, 3, 10, 8,
|
|
10, 0, 0, 1, 2, 4, 4, 6, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 6,
|
|
4, 4, 3, 9, 1, 1, 3, 1, 5, 5,
|
|
9, 0, 1, 1, 3, 3, 3, 3, 3, 6,
|
|
3, 3, 3, 3, 7, 5, 1, 1, 3, 4,
|
|
1, 1, 3, 1, 1, 3, 3, 2, 3, 4,
|
|
4, 5, 5, 1, 2, 4, 4, 4, 0, 1,
|
|
2, 7, 6, 3, 3, 7, 5, 1, 3, 1,
|
|
4, 2, 3, 3, 4, 6, 3, 2, 3, 1,
|
|
1, 4, 5, 3, 6, 2, 4, 2, 1, 3,
|
|
3, 0, 1, 3, 2, 2, 2, 2, 9, 5,
|
|
1, 3, 2, 2, 2, 9, 4, 1, 3, 1,
|
|
1, 2, 0, 7, 1, 4, 1, 3, 1, 1,
|
|
1, 16, 0, 3, 3, 3, 3, 6, 9, 5,
|
|
1, 3, 5, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
2, 2, 4, 3, 4, 5, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 5, 2, 2, 2, 2,
|
|
2, 5, 1, 1, 1, 4, 4, 4, 4, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 4, 3, 4, 5, 1, 1,
|
|
1, 1, 4, 3, 2, 4, 3, 4, 3, 4,
|
|
5, 1, 1, 1, 1, 1, 1, 1, 7, 5,
|
|
1, 1, 1, 1, 4, 3, 4, 5, 1, 1,
|
|
4, 3, 4, 5, 1, 1, 2, 1, 2, 4,
|
|
3, 4, 3, 4, 5, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 2, 4, 3, 2,
|
|
4, 3, 2, 3, 2, 2, 2, 2, 2, 2,
|
|
3, 2, 5, 2, 5, 2, 5, 1, 1, 3,
|
|
3, 0, 0, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 3, 2, 5, 4, 2, 5, 4, 2, 2,
|
|
1, 1, 3, 2, 2, 2, 4, 4, 4, 4,
|
|
4, 4, 1, 1, 1, 3, 2, 2, 1, 1,
|
|
4, 1, 3, 1, 3, 0, 1, 1, 2, 6,
|
|
3, 1, 1, 1, 1, 1, 1, 5, 5, 5,
|
|
3, 10, 10, 1, 3, 2, 0, 6, 0, 6,
|
|
2, 1, 3, 1, 1, 1, 1, 1, 5, 5,
|
|
5, 5, 5, 1, 3, 3, 1, 3, 1, 1,
|
|
1, 5, 5, 5, 1, 3, 2, 5, 2, 5,
|
|
5, 2, 5, 2, 5, 1, 1, 3, 5, 1,
|
|
3, 5, 5, 5, 5, 7, 1, 3, 2, 2,
|
|
2, 2, 0
|
|
};
|
|
|
|
|
|
#define yyerrok (yyerrstatus = 0)
|
|
#define yyclearin (yychar = YYEMPTY)
|
|
#define YYEMPTY (-2)
|
|
#define YYEOF 0
|
|
|
|
#define YYACCEPT goto yyacceptlab
|
|
#define YYABORT goto yyabortlab
|
|
#define YYERROR goto yyerrorlab
|
|
|
|
|
|
#define YYRECOVERING() (!!yyerrstatus)
|
|
|
|
#define YYBACKUP(Token, Value) \
|
|
do \
|
|
if (yychar == YYEMPTY) \
|
|
{ \
|
|
yychar = (Token); \
|
|
yylval = (Value); \
|
|
YYPOPSTACK (yylen); \
|
|
yystate = *yyssp; \
|
|
goto yybackup; \
|
|
} \
|
|
else \
|
|
{ \
|
|
yyerror (YY_("syntax error: cannot back up")); \
|
|
YYERROR; \
|
|
} \
|
|
while (0)
|
|
|
|
/* Error token number */
|
|
#define YYTERROR 1
|
|
#define YYERRCODE 256
|
|
|
|
|
|
|
|
/* Enable debugging if requested. */
|
|
#if YYDEBUG
|
|
|
|
# ifndef YYFPRINTF
|
|
# include <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 796 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = BFNULL; }
|
|
#line 4516 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 3:
|
|
#line 798 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = set_stat_list((yyvsp[-2].bf_node),(yyvsp[-1].bf_node)); }
|
|
#line 4522 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 4:
|
|
#line 802 "gram1.y" /* yacc.c:1646 */
|
|
{ lastwasbranch = NO; (yyval.bf_node) = BFNULL; }
|
|
#line 4528 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 5:
|
|
#line 804 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
if ((yyvsp[-1].bf_node) != BFNULL)
|
|
{
|
|
(yyvsp[-1].bf_node)->label = (yyvsp[-2].label);
|
|
(yyval.bf_node) = (yyvsp[-1].bf_node);
|
|
if (is_openmp_stmt) { /*OMP*/
|
|
is_openmp_stmt = 0;
|
|
if((yyvsp[-1].bf_node)) { /*OMP*/
|
|
if ((yyvsp[-1].bf_node)->decl_specs != -BIT_OPENMP) (yyvsp[-1].bf_node)->decl_specs = BIT_OPENMP; /*OMP*/
|
|
} /*OMP*/
|
|
} /*OMP*/
|
|
}
|
|
}
|
|
#line 4546 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 6:
|
|
#line 818 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_BFND p;
|
|
|
|
if(lastwasbranch && ! thislabel)
|
|
/*if (warn_all)
|
|
warn("statement cannot be reached", 36);*/
|
|
lastwasbranch = thiswasbranch;
|
|
thiswasbranch = NO;
|
|
if((yyvsp[-1].bf_node)) (yyvsp[-1].bf_node)->label = (yyvsp[-2].label);
|
|
if((yyvsp[-2].label) && (yyvsp[-1].bf_node)) (yyvsp[-2].label)->statbody = (yyvsp[-1].bf_node); /*8.11.06 podd*/
|
|
if((yyvsp[-2].label)) {
|
|
/*$1->statbody = $2;*/ /*8.11.06 podd*/
|
|
if((yyvsp[-2].label)->labtype == LABFORMAT)
|
|
err("label already that of a format",39);
|
|
else
|
|
(yyvsp[-2].label)->labtype = LABEXEC;
|
|
}
|
|
if (is_openmp_stmt) { /*OMP*/
|
|
is_openmp_stmt = 0;
|
|
if((yyvsp[-1].bf_node)) { /*OMP*/
|
|
if ((yyvsp[-1].bf_node)->decl_specs != -BIT_OPENMP) (yyvsp[-1].bf_node)->decl_specs = BIT_OPENMP; /*OMP*/
|
|
} /*OMP*/
|
|
} /*OMP*/
|
|
for (p = pred_bfnd; (yyvsp[-2].label) &&
|
|
((p->variant == FOR_NODE)||(p->variant == WHILE_NODE)) &&
|
|
(p->entry.for_node.doend) &&
|
|
(p->entry.for_node.doend->stateno == (yyvsp[-2].label)->stateno);
|
|
p = p->control_parent)
|
|
++end_group;
|
|
(yyval.bf_node) = (yyvsp[-1].bf_node);
|
|
}
|
|
#line 4581 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 7:
|
|
#line 849 "gram1.y" /* yacc.c:1646 */
|
|
{ /* PTR_LLND p; */
|
|
doinclude( (yyvsp[0].charp) );
|
|
/* p = make_llnd(fi, STRING_VAL, LLNULL, LLNULL, SMNULL);
|
|
p->entry.string_val = $3;
|
|
p->type = global_string;
|
|
$$ = get_bfnd(fi, INCLUDE_STAT, SMNULL, p, LLNULL); */
|
|
(yyval.bf_node) = BFNULL;
|
|
}
|
|
#line 4594 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 8:
|
|
#line 858 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
err("Unclassifiable statement", 10);
|
|
flline();
|
|
(yyval.bf_node) = BFNULL;
|
|
}
|
|
#line 4604 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 9:
|
|
#line 864 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_CMNT p;
|
|
PTR_BFND bif;
|
|
|
|
if (last_bfnd && last_bfnd->control_parent &&((last_bfnd->control_parent->variant == LOGIF_NODE)
|
|
||(last_bfnd->control_parent->variant == FORALL_STAT)))
|
|
bif = last_bfnd->control_parent;
|
|
else
|
|
bif = last_bfnd;
|
|
p=bif->entry.Template.cmnt_ptr;
|
|
if(p)
|
|
p->string = StringConcatenation(p->string,commentbuf);
|
|
else
|
|
{
|
|
p = make_comment(fi,commentbuf, FULL);
|
|
bif->entry.Template.cmnt_ptr = p;
|
|
}
|
|
(yyval.bf_node) = BFNULL;
|
|
}
|
|
#line 4627 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 10:
|
|
#line 884 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
flline(); needkwd = NO; inioctl = NO;
|
|
/*!!!*/
|
|
opt_kwd_ = NO; intonly = NO; opt_kwd_hedr = NO; opt_kwd_r = NO; as_op_kwd_= NO; optcorner = NO;
|
|
yyerrok; yyclearin; (yyval.bf_node) = BFNULL;
|
|
}
|
|
#line 4638 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 11:
|
|
#line 893 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
if(yystno)
|
|
{
|
|
(yyval.label) = thislabel = make_label_node(fi,yystno);
|
|
thislabel->scope = cur_scope();
|
|
if (thislabel->labdefined && (thislabel->scope == cur_scope()))
|
|
errstr("Label %s already defined",convic(thislabel->stateno),40);
|
|
else
|
|
thislabel->labdefined = YES;
|
|
}
|
|
else
|
|
(yyval.label) = thislabel = LBNULL;
|
|
}
|
|
#line 4656 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 12:
|
|
#line 909 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_BFND p;
|
|
|
|
if (pred_bfnd != global_bfnd)
|
|
err("Misplaced PROGRAM statement", 33);
|
|
p = get_bfnd(fi,PROG_HEDR, (yyvsp[0].symbol), LLNULL, LLNULL, LLNULL);
|
|
(yyvsp[0].symbol)->entry.prog_decl.prog_hedr=p;
|
|
set_blobs(p, global_bfnd, NEW_GROUP1);
|
|
add_scope_level(p, NO);
|
|
position = IN_PROC;
|
|
}
|
|
#line 4671 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 13:
|
|
#line 921 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_BFND q = BFNULL;
|
|
|
|
(yyvsp[0].symbol)->variant = PROCEDURE_NAME;
|
|
(yyvsp[0].symbol)->decl = YES; /* variable declaration has been seen. */
|
|
q = get_bfnd(fi,BLOCK_DATA, (yyvsp[0].symbol), LLNULL, LLNULL, LLNULL);
|
|
set_blobs(q, global_bfnd, NEW_GROUP1);
|
|
add_scope_level(q, NO);
|
|
}
|
|
#line 4684 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 14:
|
|
#line 931 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
install_param_list((yyvsp[-1].symbol), (yyvsp[0].symbol), LLNULL, PROCEDURE_NAME);
|
|
/* if there is only a control end the control parent is not set */
|
|
|
|
}
|
|
#line 4694 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 15:
|
|
#line 938 "gram1.y" /* yacc.c:1646 */
|
|
{ install_param_list((yyvsp[-1].symbol), (yyvsp[0].symbol), LLNULL, PROCEDURE_NAME);
|
|
if((yyvsp[-4].ll_node)->variant == RECURSIVE_OP)
|
|
(yyvsp[-1].symbol)->attr = (yyvsp[-1].symbol)->attr | RECURSIVE_BIT;
|
|
pred_bfnd->entry.Template.ll_ptr3 = (yyvsp[-4].ll_node);
|
|
}
|
|
#line 4704 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 16:
|
|
#line 944 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
install_param_list((yyvsp[-2].symbol), (yyvsp[-1].symbol), (yyvsp[0].ll_node), FUNCTION_NAME);
|
|
pred_bfnd->entry.Template.ll_ptr1 = (yyvsp[0].ll_node);
|
|
}
|
|
#line 4713 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 17:
|
|
#line 949 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
install_param_list((yyvsp[-2].symbol), (yyvsp[-1].symbol), (yyvsp[0].ll_node), FUNCTION_NAME);
|
|
pred_bfnd->entry.Template.ll_ptr1 = (yyvsp[0].ll_node);
|
|
}
|
|
#line 4722 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 18:
|
|
#line 954 "gram1.y" /* yacc.c:1646 */
|
|
{PTR_BFND p, bif;
|
|
PTR_SYMB q = SMNULL;
|
|
PTR_LLND l = LLNULL;
|
|
|
|
if(parstate==OUTSIDE || procclass==CLMAIN || procclass==CLBLOCK)
|
|
err("Misplaced ENTRY statement", 35);
|
|
|
|
bif = cur_scope();
|
|
if (bif->variant == FUNC_HEDR) {
|
|
q = make_function((yyvsp[-2].hash_entry), bif->entry.Template.symbol->type, LOCAL);
|
|
l = construct_entry_list(q, (yyvsp[-1].symbol), FUNCTION_NAME);
|
|
}
|
|
else if ((bif->variant == PROC_HEDR) ||
|
|
(bif->variant == PROS_HEDR) || /* added for FORTRAN M */
|
|
(bif->variant == PROG_HEDR)) {
|
|
q = make_procedure((yyvsp[-2].hash_entry),LOCAL);
|
|
l = construct_entry_list(q, (yyvsp[-1].symbol), PROCEDURE_NAME);
|
|
}
|
|
p = get_bfnd(fi,ENTRY_STAT, q, l, (yyvsp[0].ll_node), LLNULL);
|
|
set_blobs(p, pred_bfnd, SAME_GROUP);
|
|
q->decl = YES; /*4.02.03*/
|
|
q->entry.proc_decl.proc_hedr = p; /*5.02.03*/
|
|
}
|
|
#line 4750 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 19:
|
|
#line 978 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB s;
|
|
PTR_BFND p;
|
|
/*
|
|
s = make_global_entity($3, MODULE_NAME, global_default, NO);
|
|
s->decl = YES;
|
|
p = get_bfnd(fi, MODULE_STMT, s, LLNULL, LLNULL, LLNULL);
|
|
s->entry.Template.func_hedr = p;
|
|
set_blobs(p, pred_bfnd, NEW_GROUP1);
|
|
add_scope_level(p, NO);
|
|
*/
|
|
/*position = IN_MODULE;*/
|
|
|
|
|
|
s = make_module((yyvsp[0].hash_entry));
|
|
s->decl = YES; /* variable declaration has been seen. */
|
|
if (pred_bfnd != global_bfnd)
|
|
err("Misplaced MODULE statement", 33);
|
|
p = get_bfnd(fi, MODULE_STMT, s, LLNULL, LLNULL, LLNULL);
|
|
s->entry.Template.func_hedr = p; /* !!!????*/
|
|
set_blobs(p, global_bfnd, NEW_GROUP1);
|
|
add_scope_level(p, NO);
|
|
position = IN_MODULE; /*IN_PROC*/
|
|
privateall = 0;
|
|
}
|
|
#line 4779 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 20:
|
|
#line 1004 "gram1.y" /* yacc.c:1646 */
|
|
{ newprog();
|
|
if (position == IN_OUTSIDE)
|
|
position = IN_PROC;
|
|
else if (position != IN_INTERNAL_PROC){
|
|
if(!is_interface_stat(pred_bfnd))
|
|
position--;
|
|
}
|
|
else {
|
|
if(!is_interface_stat(pred_bfnd))
|
|
err("Internal procedures can not contain procedures",304);
|
|
}
|
|
}
|
|
#line 4796 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 21:
|
|
#line 1019 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi, RECURSIVE_OP, LLNULL, LLNULL, SMNULL); }
|
|
#line 4802 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 22:
|
|
#line 1021 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi, PURE_OP, LLNULL, LLNULL, SMNULL); }
|
|
#line 4808 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 23:
|
|
#line 1023 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi, ELEMENTAL_OP, LLNULL, LLNULL, SMNULL); }
|
|
#line 4814 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 24:
|
|
#line 1027 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_BFND p;
|
|
|
|
(yyval.symbol) = make_procedure((yyvsp[0].hash_entry), LOCAL);
|
|
(yyval.symbol)->decl = YES; /* variable declaration has been seen. */
|
|
/* if (pred_bfnd != global_bfnd)
|
|
{
|
|
err("Misplaced SUBROUTINE statement", 34);
|
|
}
|
|
*/
|
|
p = get_bfnd(fi,PROC_HEDR, (yyval.symbol), LLNULL, LLNULL, LLNULL);
|
|
(yyval.symbol)->entry.proc_decl.proc_hedr = p;
|
|
set_blobs(p, pred_bfnd, NEW_GROUP1);
|
|
add_scope_level(p, NO);
|
|
}
|
|
#line 4833 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 25:
|
|
#line 1044 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_BFND p;
|
|
|
|
(yyval.symbol) = make_function((yyvsp[0].hash_entry), TYNULL, LOCAL);
|
|
(yyval.symbol)->decl = YES; /* variable declaration has been seen. */
|
|
/* if (pred_bfnd != global_bfnd)
|
|
err("Misplaced FUNCTION statement", 34); */
|
|
p = get_bfnd(fi,FUNC_HEDR, (yyval.symbol), LLNULL, LLNULL, LLNULL);
|
|
(yyval.symbol)->entry.func_decl.func_hedr = p;
|
|
set_blobs(p, pred_bfnd, NEW_GROUP1);
|
|
add_scope_level(p, NO);
|
|
}
|
|
#line 4849 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 26:
|
|
#line 1058 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_BFND p;
|
|
PTR_LLND l;
|
|
|
|
(yyval.symbol) = make_function((yyvsp[0].hash_entry), (yyvsp[-3].data_type), LOCAL);
|
|
(yyval.symbol)->decl = YES; /* variable declaration has been seen. */
|
|
l = make_llnd(fi, TYPE_OP, LLNULL, LLNULL, SMNULL);
|
|
l->type = (yyvsp[-3].data_type);
|
|
p = get_bfnd(fi,FUNC_HEDR, (yyval.symbol), LLNULL, l, LLNULL);
|
|
(yyval.symbol)->entry.func_decl.func_hedr = p;
|
|
/* if (pred_bfnd != global_bfnd)
|
|
err("Misplaced FUNCTION statement", 34);*/
|
|
set_blobs(p, pred_bfnd, NEW_GROUP1);
|
|
add_scope_level(p, NO);
|
|
/*
|
|
$$ = make_function($4, $1, LOCAL);
|
|
$$->decl = YES;
|
|
p = get_bfnd(fi,FUNC_HEDR, $$, LLNULL, LLNULL, LLNULL);
|
|
if (pred_bfnd != global_bfnd)
|
|
errstr("cftn.gram: misplaced SUBROUTINE statement.");
|
|
set_blobs(p, pred_bfnd, NEW_GROUP1);
|
|
add_scope_level(p, NO);
|
|
*/
|
|
}
|
|
#line 4877 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 27:
|
|
#line 1082 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_BFND p;
|
|
PTR_LLND l;
|
|
(yyval.symbol) = make_function((yyvsp[0].hash_entry), (yyvsp[-4].data_type), LOCAL);
|
|
(yyval.symbol)->decl = YES; /* variable declaration has been seen. */
|
|
if((yyvsp[-3].ll_node)->variant == RECURSIVE_OP)
|
|
(yyval.symbol)->attr = (yyval.symbol)->attr | RECURSIVE_BIT;
|
|
l = make_llnd(fi, TYPE_OP, LLNULL, LLNULL, SMNULL);
|
|
l->type = (yyvsp[-4].data_type);
|
|
/* if (pred_bfnd != global_bfnd)
|
|
err("Misplaced FUNCTION statement", 34);*/
|
|
p = get_bfnd(fi,FUNC_HEDR, (yyval.symbol), LLNULL, l, (yyvsp[-3].ll_node));
|
|
(yyval.symbol)->entry.func_decl.func_hedr = p;
|
|
set_blobs(p, pred_bfnd, NEW_GROUP1);
|
|
add_scope_level(p, NO);
|
|
}
|
|
#line 4897 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 28:
|
|
#line 1098 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_BFND p;
|
|
|
|
(yyval.symbol) = make_function((yyvsp[0].hash_entry), TYNULL, LOCAL);
|
|
(yyval.symbol)->decl = YES; /* variable declaration has been seen. */
|
|
if((yyvsp[-3].ll_node)->variant == RECURSIVE_OP)
|
|
(yyval.symbol)->attr = (yyval.symbol)->attr | RECURSIVE_BIT;
|
|
/*if (pred_bfnd != global_bfnd)
|
|
err("Misplaced FUNCTION statement",34);*/
|
|
p = get_bfnd(fi,FUNC_HEDR, (yyval.symbol), LLNULL, LLNULL, (yyvsp[-3].ll_node));
|
|
(yyval.symbol)->entry.func_decl.func_hedr = p;
|
|
set_blobs(p, pred_bfnd, NEW_GROUP1);
|
|
add_scope_level(p, NO);
|
|
}
|
|
#line 4915 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 29:
|
|
#line 1112 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_BFND p;
|
|
PTR_LLND l;
|
|
(yyval.symbol) = make_function((yyvsp[0].hash_entry), (yyvsp[-3].data_type), LOCAL);
|
|
(yyval.symbol)->decl = YES; /* variable declaration has been seen. */
|
|
if((yyvsp[-4].ll_node)->variant == RECURSIVE_OP)
|
|
(yyval.symbol)->attr = (yyval.symbol)->attr | RECURSIVE_BIT;
|
|
l = make_llnd(fi, TYPE_OP, LLNULL, LLNULL, SMNULL);
|
|
l->type = (yyvsp[-3].data_type);
|
|
/* if (pred_bfnd != global_bfnd)
|
|
err("Misplaced FUNCTION statement",34);*/
|
|
p = get_bfnd(fi,FUNC_HEDR, (yyval.symbol), LLNULL, l, (yyvsp[-4].ll_node));
|
|
(yyval.symbol)->entry.func_decl.func_hedr = p;
|
|
set_blobs(p, pred_bfnd, NEW_GROUP1);
|
|
add_scope_level(p, NO);
|
|
}
|
|
#line 4935 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 30:
|
|
#line 1130 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL; }
|
|
#line 4941 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 31:
|
|
#line 1132 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB s;
|
|
s = make_scalar((yyvsp[-1].hash_entry), TYNULL, LOCAL);
|
|
(yyval.ll_node) = make_llnd(fi, VAR_REF, LLNULL, LLNULL, s);
|
|
}
|
|
#line 4950 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 32:
|
|
#line 1139 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = look_up_sym(yytext); }
|
|
#line 4956 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 33:
|
|
#line 1142 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.symbol) = make_program(look_up_sym("_MAIN")); }
|
|
#line 4962 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 34:
|
|
#line 1144 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.symbol) = make_program((yyvsp[0].hash_entry));
|
|
(yyval.symbol)->decl = YES; /* variable declaration has been seen. */
|
|
}
|
|
#line 4971 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 35:
|
|
#line 1150 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.symbol) = make_program(look_up_sym("_BLOCK")); }
|
|
#line 4977 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 36:
|
|
#line 1152 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.symbol) = make_program((yyvsp[0].hash_entry));
|
|
(yyval.symbol)->decl = YES; /* variable declaration has been seen. */
|
|
}
|
|
#line 4986 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 37:
|
|
#line 1159 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.symbol) = SMNULL; }
|
|
#line 4992 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 38:
|
|
#line 1161 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.symbol) = SMNULL; }
|
|
#line 4998 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 39:
|
|
#line 1163 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.symbol) = (yyvsp[-1].symbol); }
|
|
#line 5004 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 41:
|
|
#line 1168 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.symbol) = set_id_list((yyvsp[-2].symbol), (yyvsp[0].symbol)); }
|
|
#line 5010 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 42:
|
|
#line 1172 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.symbol) = make_scalar((yyvsp[0].hash_entry), TYNULL, IO);
|
|
}
|
|
#line 5018 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 43:
|
|
#line 1176 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.symbol) = make_scalar(look_up_sym("*"), TYNULL, IO); }
|
|
#line 5024 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 44:
|
|
#line 1182 "gram1.y" /* yacc.c:1646 */
|
|
{ char *s;
|
|
|
|
s = copyn(yyleng+1, yytext);
|
|
s[yyleng] = '\0';
|
|
(yyval.charp) = s;
|
|
}
|
|
#line 5035 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 45:
|
|
#line 1191 "gram1.y" /* yacc.c:1646 */
|
|
{ needkwd = 1; }
|
|
#line 5041 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 46:
|
|
#line 1195 "gram1.y" /* yacc.c:1646 */
|
|
{ needkwd = NO; }
|
|
#line 5047 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 47:
|
|
#line 1200 "gram1.y" /* yacc.c:1646 */
|
|
{ colon_flag = YES; }
|
|
#line 5053 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 62:
|
|
#line 1222 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
saveall = YES;
|
|
(yyval.bf_node) = get_bfnd(fi,SAVE_DECL, SMNULL, LLNULL, LLNULL, LLNULL);
|
|
}
|
|
#line 5062 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 63:
|
|
#line 1227 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = get_bfnd(fi,SAVE_DECL, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL);
|
|
}
|
|
#line 5070 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 64:
|
|
#line 1232 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND p;
|
|
|
|
p = make_llnd(fi,STMT_STR, LLNULL, LLNULL, SMNULL);
|
|
p->entry.string_val = copys(stmtbuf);
|
|
(yyval.bf_node) = get_bfnd(fi,FORMAT_STAT, SMNULL, p, LLNULL, LLNULL);
|
|
}
|
|
#line 5081 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 65:
|
|
#line 1239 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,PARAM_DECL, SMNULL, (yyvsp[-1].ll_node), LLNULL, LLNULL); }
|
|
#line 5087 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 78:
|
|
#line 1255 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi, INTERFACE_STMT, SMNULL, LLNULL, LLNULL, LLNULL);
|
|
add_scope_level((yyval.bf_node), NO);
|
|
}
|
|
#line 5095 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 79:
|
|
#line 1259 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB s;
|
|
|
|
s = make_procedure((yyvsp[0].hash_entry), LOCAL);
|
|
s->variant = INTERFACE_NAME;
|
|
(yyval.bf_node) = get_bfnd(fi, INTERFACE_STMT, s, LLNULL, LLNULL, LLNULL);
|
|
add_scope_level((yyval.bf_node), NO);
|
|
}
|
|
#line 5107 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 80:
|
|
#line 1267 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB s;
|
|
|
|
s = make_function((yyvsp[-1].hash_entry), global_default, LOCAL);
|
|
s->variant = INTERFACE_NAME;
|
|
(yyval.bf_node) = get_bfnd(fi, INTERFACE_OPERATOR, s, LLNULL, LLNULL, LLNULL);
|
|
add_scope_level((yyval.bf_node), NO);
|
|
}
|
|
#line 5119 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 81:
|
|
#line 1275 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB s;
|
|
|
|
|
|
s = make_procedure(look_up_sym("="), LOCAL);
|
|
s->variant = INTERFACE_NAME;
|
|
(yyval.bf_node) = get_bfnd(fi, INTERFACE_ASSIGNMENT, s, LLNULL, LLNULL, LLNULL);
|
|
add_scope_level((yyval.bf_node), NO);
|
|
}
|
|
#line 5132 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 82:
|
|
#line 1284 "gram1.y" /* yacc.c:1646 */
|
|
{ parstate = INDCL;
|
|
(yyval.bf_node) = get_bfnd(fi, CONTROL_END, SMNULL, LLNULL, LLNULL, LLNULL);
|
|
/*process_interface($$);*/ /*podd 01.02.03*/
|
|
delete_beyond_scope_level(pred_bfnd);
|
|
}
|
|
#line 5142 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 83:
|
|
#line 1292 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = look_up_sym(yytext); }
|
|
#line 5148 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 84:
|
|
#line 1296 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = (yyvsp[0].hash_entry); }
|
|
#line 5154 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 85:
|
|
#line 1298 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = (yyvsp[0].hash_entry); }
|
|
#line 5160 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 86:
|
|
#line 1302 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = look_up_op(PLUS); }
|
|
#line 5166 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 87:
|
|
#line 1304 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = look_up_op(MINUS); }
|
|
#line 5172 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 88:
|
|
#line 1306 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = look_up_op(ASTER); }
|
|
#line 5178 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 89:
|
|
#line 1308 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = look_up_op(DASTER); }
|
|
#line 5184 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 90:
|
|
#line 1310 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = look_up_op(SLASH); }
|
|
#line 5190 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 91:
|
|
#line 1312 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = look_up_op(DSLASH); }
|
|
#line 5196 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 92:
|
|
#line 1314 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = look_up_op(AND); }
|
|
#line 5202 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 93:
|
|
#line 1316 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = look_up_op(OR); }
|
|
#line 5208 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 94:
|
|
#line 1318 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = look_up_op(XOR); }
|
|
#line 5214 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 95:
|
|
#line 1320 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = look_up_op(NOT); }
|
|
#line 5220 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 96:
|
|
#line 1322 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = look_up_op(EQ); }
|
|
#line 5226 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 97:
|
|
#line 1324 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = look_up_op(NE); }
|
|
#line 5232 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 98:
|
|
#line 1326 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = look_up_op(GT); }
|
|
#line 5238 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 99:
|
|
#line 1328 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = look_up_op(GE); }
|
|
#line 5244 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 100:
|
|
#line 1330 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = look_up_op(LT); }
|
|
#line 5250 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 101:
|
|
#line 1332 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = look_up_op(LE); }
|
|
#line 5256 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 102:
|
|
#line 1334 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = look_up_op(NEQV); }
|
|
#line 5262 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 103:
|
|
#line 1336 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = look_up_op(EQV); }
|
|
#line 5268 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 104:
|
|
#line 1341 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
PTR_SYMB s;
|
|
|
|
type_var = s = make_derived_type((yyvsp[0].hash_entry), TYNULL, LOCAL);
|
|
(yyval.bf_node) = get_bfnd(fi, STRUCT_DECL, s, LLNULL, LLNULL, LLNULL);
|
|
add_scope_level((yyval.bf_node), NO);
|
|
}
|
|
#line 5280 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 105:
|
|
#line 1350 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB s;
|
|
|
|
type_var = s = make_derived_type((yyvsp[0].hash_entry), TYNULL, LOCAL);
|
|
s->attr = s->attr | type_opt;
|
|
(yyval.bf_node) = get_bfnd(fi, STRUCT_DECL, s, (yyvsp[-2].ll_node), LLNULL, LLNULL);
|
|
add_scope_level((yyval.bf_node), NO);
|
|
}
|
|
#line 5292 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 106:
|
|
#line 1360 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = get_bfnd(fi, CONTROL_END, SMNULL, LLNULL, LLNULL, LLNULL);
|
|
if (type_var != SMNULL)
|
|
process_type(type_var, (yyval.bf_node));
|
|
type_var = SMNULL;
|
|
delete_beyond_scope_level(pred_bfnd);
|
|
}
|
|
#line 5304 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 107:
|
|
#line 1368 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = get_bfnd(fi, CONTROL_END, SMNULL, LLNULL, LLNULL, LLNULL);
|
|
if (type_var != SMNULL)
|
|
process_type(type_var, (yyval.bf_node));
|
|
type_var = SMNULL;
|
|
delete_beyond_scope_level(pred_bfnd);
|
|
}
|
|
#line 5316 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 108:
|
|
#line 1378 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
PTR_LLND q, r, l;
|
|
/* PTR_SYMB s;*/
|
|
PTR_TYPE t;
|
|
int type_opts;
|
|
|
|
vartype = (yyvsp[-6].data_type);
|
|
if((yyvsp[-1].ll_node) && vartype->variant != T_STRING)
|
|
errstr("Non character entity %s has length specification",(yyvsp[-4].hash_entry)->ident,41);
|
|
t = make_type_node(vartype, (yyvsp[-1].ll_node));
|
|
type_opts = type_options;
|
|
if ((yyvsp[-2].ll_node)) type_opts = type_opts | DIMENSION_BIT;
|
|
if ((yyvsp[-2].ll_node))
|
|
q = deal_with_options((yyvsp[-4].hash_entry), t, type_opts, (yyvsp[-2].ll_node), ndim, (yyvsp[0].ll_node), (yyvsp[-2].ll_node));
|
|
else q = deal_with_options((yyvsp[-4].hash_entry), t, type_opts, attr_dims, attr_ndim, (yyvsp[0].ll_node), (yyvsp[-2].ll_node));
|
|
r = make_llnd(fi, EXPR_LIST, q, LLNULL, SMNULL);
|
|
l = make_llnd(fi, TYPE_OP, LLNULL, LLNULL, SMNULL);
|
|
l->type = vartype;
|
|
(yyval.bf_node) = get_bfnd(fi,VAR_DECL, SMNULL, r, l, (yyvsp[-5].ll_node));
|
|
}
|
|
#line 5341 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 109:
|
|
#line 1399 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
PTR_LLND q, r;
|
|
/* PTR_SYMB s;*/
|
|
PTR_TYPE t;
|
|
int type_opts;
|
|
if((yyvsp[-1].ll_node) && vartype->variant != T_STRING)
|
|
errstr("Non character entity %s has length specification",(yyvsp[-3].hash_entry)->ident,41);
|
|
t = make_type_node(vartype, (yyvsp[-1].ll_node));
|
|
type_opts = type_options;
|
|
if ((yyvsp[-2].ll_node)) type_opts = type_opts | DIMENSION_BIT;
|
|
if ((yyvsp[-2].ll_node))
|
|
q = deal_with_options((yyvsp[-3].hash_entry), t, type_opts, (yyvsp[-2].ll_node), ndim, (yyvsp[0].ll_node), (yyvsp[-2].ll_node));
|
|
else q = deal_with_options((yyvsp[-3].hash_entry), t, type_opts, attr_dims, attr_ndim, (yyvsp[0].ll_node), (yyvsp[-2].ll_node));
|
|
r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
|
|
add_to_lowLevelList(r, (yyvsp[-5].bf_node)->entry.Template.ll_ptr1);
|
|
}
|
|
#line 5362 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 110:
|
|
#line 1418 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL; }
|
|
#line 5368 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 111:
|
|
#line 1420 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL; }
|
|
#line 5374 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 112:
|
|
#line 1422 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[-2].ll_node); }
|
|
#line 5380 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 113:
|
|
#line 1426 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); }
|
|
#line 5386 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 114:
|
|
#line 1428 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-3].ll_node), (yyvsp[0].ll_node), EXPR_LIST); }
|
|
#line 5392 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 115:
|
|
#line 1432 "gram1.y" /* yacc.c:1646 */
|
|
{ type_options = type_options | PARAMETER_BIT;
|
|
(yyval.ll_node) = make_llnd(fi, PARAMETER_OP, LLNULL, LLNULL, SMNULL);
|
|
}
|
|
#line 5400 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 116:
|
|
#line 1436 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 5406 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 117:
|
|
#line 1438 "gram1.y" /* yacc.c:1646 */
|
|
{ type_options = type_options | ALLOCATABLE_BIT;
|
|
(yyval.ll_node) = make_llnd(fi, ALLOCATABLE_OP, LLNULL, LLNULL, SMNULL);
|
|
}
|
|
#line 5414 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 118:
|
|
#line 1442 "gram1.y" /* yacc.c:1646 */
|
|
{ type_options = type_options | DIMENSION_BIT;
|
|
attr_ndim = ndim;
|
|
attr_dims = (yyvsp[0].ll_node);
|
|
(yyval.ll_node) = make_llnd(fi, DIMENSION_OP, (yyvsp[0].ll_node), LLNULL, SMNULL);
|
|
}
|
|
#line 5424 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 119:
|
|
#line 1448 "gram1.y" /* yacc.c:1646 */
|
|
{ type_options = type_options | EXTERNAL_BIT;
|
|
(yyval.ll_node) = make_llnd(fi, EXTERNAL_OP, LLNULL, LLNULL, SMNULL);
|
|
}
|
|
#line 5432 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 120:
|
|
#line 1452 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[-1].ll_node); }
|
|
#line 5438 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 121:
|
|
#line 1454 "gram1.y" /* yacc.c:1646 */
|
|
{ type_options = type_options | INTRINSIC_BIT;
|
|
(yyval.ll_node) = make_llnd(fi, INTRINSIC_OP, LLNULL, LLNULL, SMNULL);
|
|
}
|
|
#line 5446 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 122:
|
|
#line 1458 "gram1.y" /* yacc.c:1646 */
|
|
{ type_options = type_options | OPTIONAL_BIT;
|
|
(yyval.ll_node) = make_llnd(fi, OPTIONAL_OP, LLNULL, LLNULL, SMNULL);
|
|
}
|
|
#line 5454 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 123:
|
|
#line 1462 "gram1.y" /* yacc.c:1646 */
|
|
{ type_options = type_options | POINTER_BIT;
|
|
(yyval.ll_node) = make_llnd(fi, POINTER_OP, LLNULL, LLNULL, SMNULL);
|
|
}
|
|
#line 5462 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 124:
|
|
#line 1466 "gram1.y" /* yacc.c:1646 */
|
|
{ type_options = type_options | SAVE_BIT;
|
|
(yyval.ll_node) = make_llnd(fi, SAVE_OP, LLNULL, LLNULL, SMNULL);
|
|
}
|
|
#line 5470 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 125:
|
|
#line 1470 "gram1.y" /* yacc.c:1646 */
|
|
{ type_options = type_options | SAVE_BIT;
|
|
(yyval.ll_node) = make_llnd(fi, STATIC_OP, LLNULL, LLNULL, SMNULL);
|
|
}
|
|
#line 5478 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 126:
|
|
#line 1474 "gram1.y" /* yacc.c:1646 */
|
|
{ type_options = type_options | TARGET_BIT;
|
|
(yyval.ll_node) = make_llnd(fi, TARGET_OP, LLNULL, LLNULL, SMNULL);
|
|
}
|
|
#line 5486 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 127:
|
|
#line 1480 "gram1.y" /* yacc.c:1646 */
|
|
{ type_options = type_options | IN_BIT; type_opt = IN_BIT;
|
|
(yyval.ll_node) = make_llnd(fi, IN_OP, LLNULL, LLNULL, SMNULL);
|
|
}
|
|
#line 5494 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 128:
|
|
#line 1484 "gram1.y" /* yacc.c:1646 */
|
|
{ type_options = type_options | OUT_BIT; type_opt = OUT_BIT;
|
|
(yyval.ll_node) = make_llnd(fi, OUT_OP, LLNULL, LLNULL, SMNULL);
|
|
}
|
|
#line 5502 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 129:
|
|
#line 1488 "gram1.y" /* yacc.c:1646 */
|
|
{ type_options = type_options | INOUT_BIT; type_opt = INOUT_BIT;
|
|
(yyval.ll_node) = make_llnd(fi, INOUT_OP, LLNULL, LLNULL, SMNULL);
|
|
}
|
|
#line 5510 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 130:
|
|
#line 1494 "gram1.y" /* yacc.c:1646 */
|
|
{ type_options = type_options | PUBLIC_BIT;
|
|
type_opt = PUBLIC_BIT;
|
|
(yyval.ll_node) = make_llnd(fi, PUBLIC_OP, LLNULL, LLNULL, SMNULL);
|
|
}
|
|
#line 5519 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 131:
|
|
#line 1499 "gram1.y" /* yacc.c:1646 */
|
|
{ type_options = type_options | PRIVATE_BIT;
|
|
type_opt = PRIVATE_BIT;
|
|
(yyval.ll_node) = make_llnd(fi, PRIVATE_OP, LLNULL, LLNULL, SMNULL);
|
|
}
|
|
#line 5528 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 132:
|
|
#line 1506 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
PTR_LLND q, r;
|
|
PTR_SYMB s;
|
|
|
|
s = make_scalar((yyvsp[0].hash_entry), TYNULL, LOCAL);
|
|
s->attr = s->attr | type_opt;
|
|
q = make_llnd(fi,VAR_REF, LLNULL, LLNULL, s);
|
|
r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
|
|
(yyval.bf_node) = get_bfnd(fi, INTENT_STMT, SMNULL, r, (yyvsp[-3].ll_node), LLNULL);
|
|
}
|
|
#line 5543 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 133:
|
|
#line 1517 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
PTR_LLND q, r;
|
|
PTR_SYMB s;
|
|
|
|
s = make_scalar((yyvsp[0].hash_entry), TYNULL, LOCAL);
|
|
s->attr = s->attr | type_opt;
|
|
q = make_llnd(fi,VAR_REF, LLNULL, LLNULL, s);
|
|
r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
|
|
add_to_lowLevelList(r, (yyvsp[-2].bf_node)->entry.Template.ll_ptr1);
|
|
}
|
|
#line 5558 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 134:
|
|
#line 1530 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
PTR_LLND q, r;
|
|
PTR_SYMB s;
|
|
|
|
s = make_scalar((yyvsp[0].hash_entry), TYNULL, LOCAL);
|
|
s->attr = s->attr | OPTIONAL_BIT;
|
|
q = make_llnd(fi,VAR_REF, LLNULL, LLNULL, s);
|
|
r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
|
|
(yyval.bf_node) = get_bfnd(fi, OPTIONAL_STMT, SMNULL, r, LLNULL, LLNULL);
|
|
}
|
|
#line 5573 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 135:
|
|
#line 1541 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
PTR_LLND q, r;
|
|
PTR_SYMB s;
|
|
|
|
s = make_scalar((yyvsp[0].hash_entry), TYNULL, LOCAL);
|
|
s->attr = s->attr | OPTIONAL_BIT;
|
|
q = make_llnd(fi,VAR_REF, LLNULL, LLNULL, s);
|
|
r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
|
|
add_to_lowLevelList(r, (yyvsp[-2].bf_node)->entry.Template.ll_ptr1);
|
|
}
|
|
#line 5588 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 136:
|
|
#line 1554 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
PTR_LLND r;
|
|
PTR_SYMB s;
|
|
|
|
s = (yyvsp[0].ll_node)->entry.Template.symbol;
|
|
s->attr = s->attr | SAVE_BIT;
|
|
r = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
|
|
(yyval.bf_node) = get_bfnd(fi, STATIC_STMT, SMNULL, r, LLNULL, LLNULL);
|
|
}
|
|
#line 5602 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 137:
|
|
#line 1564 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
PTR_LLND r;
|
|
PTR_SYMB s;
|
|
|
|
s = (yyvsp[0].ll_node)->entry.Template.symbol;
|
|
s->attr = s->attr | SAVE_BIT;
|
|
r = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
|
|
add_to_lowLevelList(r, (yyvsp[-2].bf_node)->entry.Template.ll_ptr1);
|
|
}
|
|
#line 5616 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 138:
|
|
#line 1577 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
privateall = 1;
|
|
(yyval.bf_node) = get_bfnd(fi, PRIVATE_STMT, SMNULL, LLNULL, LLNULL, LLNULL);
|
|
}
|
|
#line 5625 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 139:
|
|
#line 1582 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
/*type_options = type_options | PRIVATE_BIT;*/
|
|
(yyval.bf_node) = get_bfnd(fi, PRIVATE_STMT, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL);
|
|
}
|
|
#line 5634 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 140:
|
|
#line 1588 "gram1.y" /* yacc.c:1646 */
|
|
{type_opt = PRIVATE_BIT;}
|
|
#line 5640 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 141:
|
|
#line 1592 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = get_bfnd(fi, SEQUENCE_STMT, SMNULL, LLNULL, LLNULL, LLNULL);
|
|
}
|
|
#line 5648 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 142:
|
|
#line 1597 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
/*saveall = YES;*/ /*14.03.03*/
|
|
(yyval.bf_node) = get_bfnd(fi, PUBLIC_STMT, SMNULL, LLNULL, LLNULL, LLNULL);
|
|
}
|
|
#line 5657 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 143:
|
|
#line 1602 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
/*type_options = type_options | PUBLIC_BIT;*/
|
|
(yyval.bf_node) = get_bfnd(fi, PUBLIC_STMT, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL);
|
|
}
|
|
#line 5666 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 144:
|
|
#line 1608 "gram1.y" /* yacc.c:1646 */
|
|
{type_opt = PUBLIC_BIT;}
|
|
#line 5672 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 145:
|
|
#line 1612 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
type_options = 0;
|
|
/* following block added by dbg */
|
|
ndim = 0;
|
|
attr_ndim = 0;
|
|
attr_dims = LLNULL;
|
|
/* end section added by dbg */
|
|
(yyval.data_type) = make_type_node((yyvsp[-3].data_type), (yyvsp[-1].ll_node));
|
|
}
|
|
#line 5686 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 146:
|
|
#line 1622 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_TYPE t;
|
|
|
|
type_options = 0;
|
|
ndim = 0;
|
|
attr_ndim = 0;
|
|
attr_dims = LLNULL;
|
|
t = lookup_type((yyvsp[-2].hash_entry));
|
|
vartype = t;
|
|
(yyval.data_type) = make_type_node(t, LLNULL);
|
|
}
|
|
#line 5701 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 147:
|
|
#line 1635 "gram1.y" /* yacc.c:1646 */
|
|
{opt_kwd_hedr = YES;}
|
|
#line 5707 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 148:
|
|
#line 1640 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_TYPE p;
|
|
PTR_LLND q;
|
|
PTR_SYMB s;
|
|
s = (yyvsp[0].hash_entry)->id_attr;
|
|
if (s)
|
|
s->attr = (yyvsp[-1].token);
|
|
else {
|
|
p = undeftype ? global_unknown : impltype[*(yyvsp[0].hash_entry)->ident - 'a'];
|
|
s = install_entry((yyvsp[0].hash_entry), SOFT);
|
|
s->attr = (yyvsp[-1].token);
|
|
set_type(s, p, LOCAL);
|
|
}
|
|
q = make_llnd(fi,VAR_REF, LLNULL, LLNULL, (yyvsp[0].hash_entry)->id_attr);
|
|
q = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
|
|
(yyval.bf_node) = get_bfnd(fi,ATTR_DECL, SMNULL, q, LLNULL, LLNULL);
|
|
}
|
|
#line 5728 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 149:
|
|
#line 1659 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_TYPE p;
|
|
PTR_LLND q, r;
|
|
PTR_SYMB s;
|
|
int att;
|
|
|
|
att = (yyvsp[-2].bf_node)->entry.Template.ll_ptr1->entry.Template.ll_ptr1->
|
|
entry.Template.symbol->attr;
|
|
s = (yyvsp[0].hash_entry)->id_attr;
|
|
if (s)
|
|
s->attr = att;
|
|
else {
|
|
p = undeftype ? global_unknown : impltype[*(yyvsp[0].hash_entry)->ident - 'a'];
|
|
s = install_entry((yyvsp[0].hash_entry), SOFT);
|
|
s->attr = att;
|
|
set_type(s, p, LOCAL);
|
|
}
|
|
q = make_llnd(fi,VAR_REF, LLNULL, LLNULL, (yyvsp[0].hash_entry)->id_attr);
|
|
for (r = (yyvsp[-2].bf_node)->entry.Template.ll_ptr1;
|
|
r->entry.list.next;
|
|
r = r->entry.list.next) ;
|
|
r->entry.list.next = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
|
|
|
|
}
|
|
#line 5756 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 150:
|
|
#line 1685 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.token) = ATT_GLOBAL; }
|
|
#line 5762 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 151:
|
|
#line 1687 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.token) = ATT_CLUSTER; }
|
|
#line 5768 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 152:
|
|
#line 1699 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
/* varleng = ($1<0 || $1==TYLONG ? 0 : typesize[$1]); */
|
|
vartype = (yyvsp[0].data_type);
|
|
}
|
|
#line 5777 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 153:
|
|
#line 1706 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.data_type) = global_int; }
|
|
#line 5783 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 154:
|
|
#line 1707 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.data_type) = global_float; }
|
|
#line 5789 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 155:
|
|
#line 1708 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.data_type) = global_complex; }
|
|
#line 5795 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 156:
|
|
#line 1709 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.data_type) = global_double; }
|
|
#line 5801 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 157:
|
|
#line 1710 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.data_type) = global_dcomplex; }
|
|
#line 5807 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 158:
|
|
#line 1711 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.data_type) = global_bool; }
|
|
#line 5813 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 159:
|
|
#line 1712 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.data_type) = global_string; }
|
|
#line 5819 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 160:
|
|
#line 1717 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL; }
|
|
#line 5825 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 161:
|
|
#line 1719 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 5831 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 162:
|
|
#line 1723 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi, LEN_OP, (yyvsp[-2].ll_node), LLNULL, SMNULL); }
|
|
#line 5837 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 163:
|
|
#line 1725 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND l;
|
|
|
|
l = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
|
|
l->entry.string_val = (char *)"*";
|
|
(yyval.ll_node) = make_llnd(fi, LEN_OP, l,l, SMNULL);
|
|
}
|
|
#line 5848 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 164:
|
|
#line 1732 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.ll_node) = make_llnd(fi, LEN_OP, (yyvsp[-1].ll_node), (yyvsp[-1].ll_node), SMNULL);}
|
|
#line 5854 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 165:
|
|
#line 1736 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL; }
|
|
#line 5860 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 166:
|
|
#line 1738 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 5866 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 167:
|
|
#line 1740 "gram1.y" /* yacc.c:1646 */
|
|
{ /*$$ = make_llnd(fi, PAREN_OP, $2, LLNULL, SMNULL);*/ (yyval.ll_node) = (yyvsp[-2].ll_node); }
|
|
#line 5872 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 168:
|
|
#line 1748 "gram1.y" /* yacc.c:1646 */
|
|
{ if((yyvsp[-2].ll_node)->variant==LENGTH_OP && (yyvsp[-6].ll_node)->variant==(yyvsp[-2].ll_node)->variant)
|
|
(yyvsp[-2].ll_node)->variant=KIND_OP;
|
|
(yyval.ll_node) = make_llnd(fi, CONS, (yyvsp[-6].ll_node), (yyvsp[-2].ll_node), SMNULL);
|
|
}
|
|
#line 5881 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 169:
|
|
#line 1755 "gram1.y" /* yacc.c:1646 */
|
|
{ if(vartype->variant == T_STRING)
|
|
(yyval.ll_node) = make_llnd(fi,LENGTH_OP,(yyvsp[0].ll_node),LLNULL,SMNULL);
|
|
else
|
|
(yyval.ll_node) = make_llnd(fi,KIND_OP,(yyvsp[0].ll_node),LLNULL,SMNULL);
|
|
}
|
|
#line 5891 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 170:
|
|
#line 1761 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND l;
|
|
l = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
|
|
l->entry.string_val = (char *)"*";
|
|
(yyval.ll_node) = make_llnd(fi,LENGTH_OP,l,LLNULL,SMNULL);
|
|
}
|
|
#line 5901 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 171:
|
|
#line 1767 "gram1.y" /* yacc.c:1646 */
|
|
{ /* $$ = make_llnd(fi, SPEC_PAIR, $2, LLNULL, SMNULL); */
|
|
char *q;
|
|
q = (yyvsp[-1].ll_node)->entry.string_val;
|
|
if (strcmp(q, "len") == 0)
|
|
(yyval.ll_node) = make_llnd(fi,LENGTH_OP,(yyvsp[0].ll_node),LLNULL,SMNULL);
|
|
else
|
|
(yyval.ll_node) = make_llnd(fi,KIND_OP,(yyvsp[0].ll_node),LLNULL,SMNULL);
|
|
}
|
|
#line 5914 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 172:
|
|
#line 1776 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND l;
|
|
l = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
|
|
l->entry.string_val = (char *)"*";
|
|
(yyval.ll_node) = make_llnd(fi,LENGTH_OP,l,LLNULL,SMNULL);
|
|
}
|
|
#line 5924 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 173:
|
|
#line 1784 "gram1.y" /* yacc.c:1646 */
|
|
{endioctl();}
|
|
#line 5930 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 174:
|
|
#line 1797 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL; }
|
|
#line 5936 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 175:
|
|
#line 1799 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 5942 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 176:
|
|
#line 1802 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi, POINTST_OP, LLNULL, (yyvsp[0].ll_node), SMNULL); }
|
|
#line 5948 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 177:
|
|
#line 1806 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB s;
|
|
PTR_LLND q, r;
|
|
if(! (yyvsp[0].ll_node)) {
|
|
err("No dimensions in DIMENSION statement", 42);
|
|
}
|
|
if(statement_kind == 1) /*DVM-directive*/
|
|
err("No shape specification", 65);
|
|
s = make_array((yyvsp[-1].hash_entry), TYNULL, (yyvsp[0].ll_node), ndim, LOCAL);
|
|
s->attr = s->attr | DIMENSION_BIT;
|
|
q = make_llnd(fi,ARRAY_REF, (yyvsp[0].ll_node), LLNULL, s);
|
|
s->type->entry.ar_decl.ranges = (yyvsp[0].ll_node);
|
|
r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
|
|
(yyval.bf_node) = get_bfnd(fi,DIM_STAT, SMNULL, r, LLNULL, LLNULL);
|
|
}
|
|
#line 5967 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 178:
|
|
#line 1821 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB s;
|
|
PTR_LLND q, r;
|
|
if(! (yyvsp[0].ll_node)) {
|
|
err("No dimensions in DIMENSION statement", 42);
|
|
}
|
|
s = make_array((yyvsp[-1].hash_entry), TYNULL, (yyvsp[0].ll_node), ndim, LOCAL);
|
|
s->attr = s->attr | DIMENSION_BIT;
|
|
q = make_llnd(fi,ARRAY_REF, (yyvsp[0].ll_node), LLNULL, s);
|
|
s->type->entry.ar_decl.ranges = (yyvsp[0].ll_node);
|
|
r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
|
|
add_to_lowLevelList(r, (yyvsp[-3].bf_node)->entry.Template.ll_ptr1);
|
|
}
|
|
#line 5984 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 179:
|
|
#line 1837 "gram1.y" /* yacc.c:1646 */
|
|
{/* PTR_SYMB s;*/
|
|
PTR_LLND r;
|
|
|
|
/*if(!$5) {
|
|
err("No dimensions in ALLOCATABLE statement",305);
|
|
}
|
|
s = make_array($4, TYNULL, $5, ndim, LOCAL);
|
|
s->attr = s->attr | ALLOCATABLE_BIT;
|
|
q = make_llnd(fi,ARRAY_REF, $5, LLNULL, s);
|
|
s->type->entry.ar_decl.ranges = $5;
|
|
r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
|
|
*/
|
|
(yyvsp[0].ll_node)->entry.Template.symbol->attr = (yyvsp[0].ll_node)->entry.Template.symbol->attr | ALLOCATABLE_BIT;
|
|
r = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
|
|
(yyval.bf_node) = get_bfnd(fi, ALLOCATABLE_STMT, SMNULL, r, LLNULL, LLNULL);
|
|
}
|
|
#line 6005 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 180:
|
|
#line 1855 "gram1.y" /* yacc.c:1646 */
|
|
{ /*PTR_SYMB s;*/
|
|
PTR_LLND r;
|
|
|
|
/* if(! $4) {
|
|
err("No dimensions in ALLOCATABLE statement",305);
|
|
|
|
}
|
|
s = make_array($3, TYNULL, $4, ndim, LOCAL);
|
|
s->attr = s->attr | ALLOCATABLE_BIT;
|
|
q = make_llnd(fi,ARRAY_REF, $4, LLNULL, s);
|
|
s->type->entry.ar_decl.ranges = $4;
|
|
r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
|
|
*/
|
|
(yyvsp[0].ll_node)->entry.Template.symbol->attr = (yyvsp[0].ll_node)->entry.Template.symbol->attr | ALLOCATABLE_BIT;
|
|
r = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
|
|
add_to_lowLevelList(r, (yyvsp[-2].bf_node)->entry.Template.ll_ptr1);
|
|
}
|
|
#line 6027 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 181:
|
|
#line 1875 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB s;
|
|
PTR_LLND r;
|
|
|
|
/* if(! $5) {
|
|
err("No dimensions in POINTER statement",306);
|
|
}
|
|
s = make_array($4, TYNULL, $5, ndim, LOCAL);
|
|
s->attr = s->attr | POINTER_BIT;
|
|
q = make_llnd(fi,ARRAY_REF, $5, LLNULL, s);
|
|
s->type->entry.ar_decl.ranges = $5;
|
|
*/
|
|
|
|
/*s = make_pointer( $4->entry.Template.symbol->parent, TYNULL, LOCAL);*/ /*17.02.03*/
|
|
/*$4->entry.Template.symbol->attr = $4->entry.Template.symbol->attr | POINTER_BIT;*/
|
|
s = (yyvsp[0].ll_node)->entry.Template.symbol; /*17.02.03*/
|
|
s->attr = s->attr | POINTER_BIT;
|
|
r = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
|
|
(yyval.bf_node) = get_bfnd(fi, POINTER_STMT, SMNULL, r, LLNULL, LLNULL);
|
|
}
|
|
#line 6051 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 182:
|
|
#line 1895 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB s;
|
|
PTR_LLND r;
|
|
|
|
/* if(! $4) {
|
|
err("No dimensions in POINTER statement",306);
|
|
}
|
|
s = make_array($3, TYNULL, $4, ndim, LOCAL);
|
|
s->attr = s->attr | POINTER_BIT;
|
|
q = make_llnd(fi,ARRAY_REF, $4, LLNULL, s);
|
|
s->type->entry.ar_decl.ranges = $4;
|
|
*/
|
|
|
|
/*s = make_pointer( $3->entry.Template.symbol->parent, TYNULL, LOCAL);*/ /*17.02.03*/
|
|
/*$3->entry.Template.symbol->attr = $3->entry.Template.symbol->attr | POINTER_BIT;*/
|
|
s = (yyvsp[0].ll_node)->entry.Template.symbol; /*17.02.03*/
|
|
s->attr = s->attr | POINTER_BIT;
|
|
r = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
|
|
add_to_lowLevelList(r, (yyvsp[-2].bf_node)->entry.Template.ll_ptr1);
|
|
}
|
|
#line 6075 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 183:
|
|
#line 1917 "gram1.y" /* yacc.c:1646 */
|
|
{/* PTR_SYMB s;*/
|
|
PTR_LLND r;
|
|
|
|
|
|
/* if(! $5) {
|
|
err("No dimensions in TARGET statement",307);
|
|
}
|
|
s = make_array($4, TYNULL, $5, ndim, LOCAL);
|
|
s->attr = s->attr | TARGET_BIT;
|
|
q = make_llnd(fi,ARRAY_REF, $5, LLNULL, s);
|
|
s->type->entry.ar_decl.ranges = $5;
|
|
*/
|
|
(yyvsp[0].ll_node)->entry.Template.symbol->attr = (yyvsp[0].ll_node)->entry.Template.symbol->attr | TARGET_BIT;
|
|
r = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
|
|
(yyval.bf_node) = get_bfnd(fi, TARGET_STMT, SMNULL, r, LLNULL, LLNULL);
|
|
}
|
|
#line 6096 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 184:
|
|
#line 1934 "gram1.y" /* yacc.c:1646 */
|
|
{ /*PTR_SYMB s;*/
|
|
PTR_LLND r;
|
|
|
|
/* if(! $4) {
|
|
err("No dimensions in TARGET statement",307);
|
|
}
|
|
s = make_array($3, TYNULL, $4, ndim, LOCAL);
|
|
s->attr = s->attr | TARGET_BIT;
|
|
q = make_llnd(fi,ARRAY_REF, $4, LLNULL, s);
|
|
s->type->entry.ar_decl.ranges = $4;
|
|
*/
|
|
(yyvsp[0].ll_node)->entry.Template.symbol->attr = (yyvsp[0].ll_node)->entry.Template.symbol->attr | TARGET_BIT;
|
|
r = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
|
|
add_to_lowLevelList(r, (yyvsp[-2].bf_node)->entry.Template.ll_ptr1);
|
|
}
|
|
#line 6116 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 185:
|
|
#line 1952 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND p, q;
|
|
|
|
p = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
|
|
q = make_llnd(fi,COMM_LIST, p, LLNULL, SMNULL);
|
|
(yyval.bf_node) = get_bfnd(fi,COMM_STAT, SMNULL, q, LLNULL, LLNULL);
|
|
}
|
|
#line 6127 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 186:
|
|
#line 1959 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND p, q;
|
|
|
|
p = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
|
|
q = make_llnd(fi,COMM_LIST, p, LLNULL, (yyvsp[-1].symbol));
|
|
(yyval.bf_node) = get_bfnd(fi,COMM_STAT, SMNULL, q, LLNULL, LLNULL);
|
|
}
|
|
#line 6138 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 187:
|
|
#line 1966 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND p, q;
|
|
|
|
p = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
|
|
q = make_llnd(fi,COMM_LIST, p, LLNULL, (yyvsp[-2].symbol));
|
|
add_to_lowList(q, (yyvsp[-4].bf_node)->entry.Template.ll_ptr1);
|
|
}
|
|
#line 6149 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 188:
|
|
#line 1973 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND p, r;
|
|
|
|
p = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
|
|
/*q = make_llnd(fi,COMM_LIST, p, LLNULL, SMNULL);*/
|
|
for (r = (yyvsp[-2].bf_node)->entry.Template.ll_ptr1;
|
|
r->entry.list.next;
|
|
r = r->entry.list.next);
|
|
add_to_lowLevelList(p, r->entry.Template.ll_ptr1);
|
|
}
|
|
#line 6163 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 189:
|
|
#line 1986 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND q, r;
|
|
|
|
q = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
|
|
r = make_llnd(fi,NAMELIST_LIST, q, LLNULL, (yyvsp[-1].symbol));
|
|
(yyval.bf_node) = get_bfnd(fi,NAMELIST_STAT, SMNULL, r, LLNULL, LLNULL);
|
|
}
|
|
#line 6174 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 190:
|
|
#line 1993 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND q, r;
|
|
|
|
q = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
|
|
r = make_llnd(fi,NAMELIST_LIST, q, LLNULL, (yyvsp[-2].symbol));
|
|
add_to_lowList(r, (yyvsp[-4].bf_node)->entry.Template.ll_ptr1);
|
|
}
|
|
#line 6185 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 191:
|
|
#line 2000 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND q, r;
|
|
|
|
q = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
|
|
for (r = (yyvsp[-2].bf_node)->entry.Template.ll_ptr1;
|
|
r->entry.list.next;
|
|
r = r->entry.list.next);
|
|
add_to_lowLevelList(q, r->entry.Template.ll_ptr1);
|
|
}
|
|
#line 6198 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 192:
|
|
#line 2011 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.symbol) = make_local_entity((yyvsp[-1].hash_entry), NAMELIST_NAME,global_default,LOCAL); }
|
|
#line 6204 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 193:
|
|
#line 2015 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.symbol) = NULL; /*make_common(look_up_sym("*"));*/ }
|
|
#line 6210 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 194:
|
|
#line 2017 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.symbol) = make_common((yyvsp[-1].hash_entry)); }
|
|
#line 6216 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 195:
|
|
#line 2022 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB s;
|
|
|
|
if((yyvsp[0].ll_node)) {
|
|
s = make_array((yyvsp[-1].hash_entry), TYNULL, (yyvsp[0].ll_node), ndim, LOCAL);
|
|
s->attr = s->attr | DIMENSION_BIT;
|
|
s->type->entry.ar_decl.ranges = (yyvsp[0].ll_node);
|
|
(yyval.ll_node) = make_llnd(fi,ARRAY_REF, (yyvsp[0].ll_node), LLNULL, s);
|
|
}
|
|
else {
|
|
s = make_scalar((yyvsp[-1].hash_entry), TYNULL, LOCAL);
|
|
(yyval.ll_node) = make_llnd(fi,VAR_REF, LLNULL, LLNULL, s);
|
|
}
|
|
|
|
}
|
|
#line 6235 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 196:
|
|
#line 2040 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND p, q;
|
|
PTR_SYMB s;
|
|
|
|
s = make_external((yyvsp[0].hash_entry), TYNULL);
|
|
s->attr = s->attr | EXTERNAL_BIT;
|
|
q = make_llnd(fi, VAR_REF, LLNULL, LLNULL, s);
|
|
p = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
|
|
(yyval.bf_node) = get_bfnd(fi,EXTERN_STAT, SMNULL, p, LLNULL, LLNULL);
|
|
}
|
|
#line 6249 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 197:
|
|
#line 2051 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND p, q;
|
|
PTR_SYMB s;
|
|
|
|
s = make_external((yyvsp[0].hash_entry), TYNULL);
|
|
s->attr = s->attr | EXTERNAL_BIT;
|
|
p = make_llnd(fi, VAR_REF, LLNULL, LLNULL, s);
|
|
q = make_llnd(fi,EXPR_LIST, p, LLNULL, SMNULL);
|
|
add_to_lowLevelList(q, (yyvsp[-2].bf_node)->entry.Template.ll_ptr1);
|
|
}
|
|
#line 6263 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 198:
|
|
#line 2063 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND p, q;
|
|
PTR_SYMB s;
|
|
|
|
s = make_intrinsic((yyvsp[0].hash_entry), TYNULL); /*make_function($3, TYNULL, NO);*/
|
|
s->attr = s->attr | INTRINSIC_BIT;
|
|
q = make_llnd(fi, VAR_REF, LLNULL, LLNULL, s);
|
|
p = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
|
|
(yyval.bf_node) = get_bfnd(fi,INTRIN_STAT, SMNULL, p,
|
|
LLNULL, LLNULL);
|
|
}
|
|
#line 6278 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 199:
|
|
#line 2075 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND p, q;
|
|
PTR_SYMB s;
|
|
|
|
s = make_intrinsic((yyvsp[0].hash_entry), TYNULL); /* make_function($3, TYNULL, NO);*/
|
|
s->attr = s->attr | INTRINSIC_BIT;
|
|
p = make_llnd(fi, VAR_REF, LLNULL, LLNULL, s);
|
|
q = make_llnd(fi,EXPR_LIST, p, LLNULL, SMNULL);
|
|
add_to_lowLevelList(q, (yyvsp[-2].bf_node)->entry.Template.ll_ptr1);
|
|
}
|
|
#line 6292 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 200:
|
|
#line 2089 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = get_bfnd(fi,EQUI_STAT, SMNULL, (yyvsp[0].ll_node),
|
|
LLNULL, LLNULL);
|
|
}
|
|
#line 6301 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 201:
|
|
#line 2095 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
add_to_lowLevelList((yyvsp[0].ll_node), (yyvsp[-2].bf_node)->entry.Template.ll_ptr1);
|
|
}
|
|
#line 6309 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 202:
|
|
#line 2102 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,EQUI_LIST, (yyvsp[-1].ll_node), LLNULL, SMNULL);
|
|
}
|
|
#line 6317 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 203:
|
|
#line 2108 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND p;
|
|
p = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
|
|
(yyval.ll_node) = make_llnd(fi,EXPR_LIST, (yyvsp[-2].ll_node), p, SMNULL);
|
|
}
|
|
#line 6326 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 204:
|
|
#line 2114 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND p;
|
|
|
|
p = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
|
|
add_to_lowLevelList(p, (yyvsp[-2].ll_node));
|
|
}
|
|
#line 6336 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 205:
|
|
#line 2122 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB s;
|
|
s=make_scalar((yyvsp[0].hash_entry),TYNULL,LOCAL);
|
|
(yyval.ll_node) = make_llnd(fi,VAR_REF, LLNULL, LLNULL, s);
|
|
s->attr = s->attr | EQUIVALENCE_BIT;
|
|
/*$$=$1; $$->entry.Template.symbol->attr = $$->entry.Template.symbol->attr | EQUIVALENCE_BIT; */
|
|
}
|
|
#line 6347 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 206:
|
|
#line 2129 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB s;
|
|
s=make_array((yyvsp[-3].hash_entry),TYNULL,LLNULL,0,LOCAL);
|
|
(yyval.ll_node) = make_llnd(fi,ARRAY_REF, (yyvsp[-1].ll_node), LLNULL, s);
|
|
s->attr = s->attr | EQUIVALENCE_BIT;
|
|
/*$$->entry.Template.symbol->attr = $$->entry.Template.symbol->attr | EQUIVALENCE_BIT; */
|
|
}
|
|
#line 6358 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 208:
|
|
#line 2148 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND p;
|
|
data_stat = NO;
|
|
p = make_llnd(fi,STMT_STR, LLNULL, LLNULL,
|
|
SMNULL);
|
|
p->entry.string_val = copys(stmtbuf);
|
|
(yyval.bf_node) = get_bfnd(fi,DATA_DECL, SMNULL, p, LLNULL, LLNULL);
|
|
}
|
|
#line 6370 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 211:
|
|
#line 2162 "gram1.y" /* yacc.c:1646 */
|
|
{data_stat = YES;}
|
|
#line 6376 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 212:
|
|
#line 2166 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
if (parstate == OUTSIDE)
|
|
{ PTR_BFND p;
|
|
|
|
p = get_bfnd(fi,PROG_HEDR,
|
|
make_program(look_up_sym("_MAIN")),
|
|
LLNULL, LLNULL, LLNULL);
|
|
set_blobs(p, global_bfnd, NEW_GROUP1);
|
|
add_scope_level(p, NO);
|
|
position = IN_PROC;
|
|
/*parstate = INDCL;*/
|
|
}
|
|
if(parstate < INDCL)
|
|
{
|
|
/* enddcl();*/
|
|
parstate = INDCL;
|
|
}
|
|
}
|
|
#line 6399 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 223:
|
|
#line 2211 "gram1.y" /* yacc.c:1646 */
|
|
{;}
|
|
#line 6405 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 224:
|
|
#line 2215 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.symbol)= make_scalar((yyvsp[0].hash_entry), TYNULL, LOCAL);}
|
|
#line 6411 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 225:
|
|
#line 2219 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.symbol)= make_scalar((yyvsp[0].hash_entry), TYNULL, LOCAL);
|
|
(yyval.symbol)->attr = (yyval.symbol)->attr | DATA_BIT;
|
|
}
|
|
#line 6419 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 226:
|
|
#line 2225 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi, DATA_SUBS, (yyvsp[-1].ll_node), LLNULL, SMNULL); }
|
|
#line 6425 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 227:
|
|
#line 2229 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi, DATA_RANGE, (yyvsp[-3].ll_node), (yyvsp[-1].ll_node), SMNULL); }
|
|
#line 6431 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 228:
|
|
#line 2233 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 6437 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 229:
|
|
#line 2235 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = add_to_lowLevelList((yyvsp[0].ll_node), (yyvsp[-2].ll_node)); }
|
|
#line 6443 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 230:
|
|
#line 2239 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL; }
|
|
#line 6449 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 231:
|
|
#line 2241 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 6455 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 232:
|
|
#line 2245 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.ll_node)= make_llnd(fi, DATA_IMPL_DO, (yyvsp[-5].ll_node), (yyvsp[-1].ll_node), (yyvsp[-3].symbol)); }
|
|
#line 6461 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 233:
|
|
#line 2249 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 6467 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 234:
|
|
#line 2251 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = add_to_lowLevelList((yyvsp[0].ll_node), (yyvsp[-2].ll_node)); }
|
|
#line 6473 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 235:
|
|
#line 2255 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi, DATA_ELT, (yyvsp[0].ll_node), LLNULL, (yyvsp[-1].symbol)); }
|
|
#line 6479 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 236:
|
|
#line 2257 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi, DATA_ELT, (yyvsp[0].ll_node), LLNULL, (yyvsp[-1].symbol)); }
|
|
#line 6485 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 237:
|
|
#line 2259 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyvsp[-1].ll_node)->entry.Template.ll_ptr2 = (yyvsp[0].ll_node);
|
|
(yyval.ll_node) = make_llnd(fi, DATA_ELT, (yyvsp[-1].ll_node), LLNULL, (yyvsp[-2].symbol));
|
|
}
|
|
#line 6494 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 238:
|
|
#line 2264 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi, DATA_ELT, (yyvsp[0].ll_node), LLNULL, SMNULL); }
|
|
#line 6500 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 252:
|
|
#line 2288 "gram1.y" /* yacc.c:1646 */
|
|
{if((yyvsp[-4].ll_node)->entry.Template.symbol->variant != TYPE_NAME)
|
|
errstr("Undefined type %s",(yyvsp[-4].ll_node)->entry.Template.symbol->ident,319);
|
|
}
|
|
#line 6508 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 269:
|
|
#line 2333 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,ICON_EXPR, (yyvsp[0].ll_node), LLNULL, SMNULL); }
|
|
#line 6514 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 270:
|
|
#line 2335 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
PTR_LLND p;
|
|
|
|
p = intrinsic_op_node("+", UNARY_ADD_OP, (yyvsp[0].ll_node), LLNULL);
|
|
(yyval.ll_node) = make_llnd(fi,ICON_EXPR, p, LLNULL, SMNULL);
|
|
}
|
|
#line 6525 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 271:
|
|
#line 2342 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
PTR_LLND p;
|
|
|
|
p = intrinsic_op_node("-", MINUS_OP, (yyvsp[0].ll_node), LLNULL);
|
|
(yyval.ll_node) = make_llnd(fi,ICON_EXPR, p, LLNULL, SMNULL);
|
|
}
|
|
#line 6536 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 272:
|
|
#line 2349 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
PTR_LLND p;
|
|
|
|
p = intrinsic_op_node("+", ADD_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node));
|
|
(yyval.ll_node) = make_llnd(fi,ICON_EXPR, p, LLNULL, SMNULL);
|
|
}
|
|
#line 6547 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 273:
|
|
#line 2356 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
PTR_LLND p;
|
|
|
|
p = intrinsic_op_node("-", SUBT_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node));
|
|
(yyval.ll_node) = make_llnd(fi,ICON_EXPR, p, LLNULL, SMNULL);
|
|
}
|
|
#line 6558 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 274:
|
|
#line 2365 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 6564 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 275:
|
|
#line 2367 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node("*", MULT_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
|
|
#line 6570 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 276:
|
|
#line 2369 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node("/", DIV_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
|
|
#line 6576 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 277:
|
|
#line 2373 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 6582 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 278:
|
|
#line 2375 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node("**", EXP_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
|
|
#line 6588 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 279:
|
|
#line 2379 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
PTR_LLND p;
|
|
|
|
p = make_llnd(fi,INT_VAL, LLNULL, LLNULL, SMNULL);
|
|
p->entry.ival = atoi(yytext);
|
|
p->type = global_int;
|
|
(yyval.ll_node) = make_llnd(fi,EXPR_LIST, p, LLNULL, SMNULL);
|
|
}
|
|
#line 6601 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 280:
|
|
#line 2388 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
PTR_LLND p;
|
|
|
|
p = make_llnd(fi,VAR_REF, LLNULL, LLNULL, (yyvsp[0].symbol));
|
|
(yyval.ll_node) = make_llnd(fi,EXPR_LIST, p, LLNULL, SMNULL);
|
|
}
|
|
#line 6612 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 281:
|
|
#line 2395 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,EXPR_LIST, (yyvsp[-1].ll_node), LLNULL, SMNULL);
|
|
}
|
|
#line 6620 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 282:
|
|
#line 2402 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL); }
|
|
#line 6626 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 283:
|
|
#line 2404 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); }
|
|
#line 6632 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 284:
|
|
#line 2408 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);
|
|
(yyval.ll_node)->entry.Template.symbol->attr = (yyval.ll_node)->entry.Template.symbol->attr | SAVE_BIT;
|
|
}
|
|
#line 6640 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 285:
|
|
#line 2412 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,COMM_LIST, LLNULL, LLNULL, (yyvsp[0].symbol));
|
|
(yyval.ll_node)->entry.Template.symbol->attr = (yyval.ll_node)->entry.Template.symbol->attr | SAVE_BIT;
|
|
}
|
|
#line 6648 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 286:
|
|
#line 2418 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node), LLNULL, EXPR_LIST); }
|
|
#line 6654 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 287:
|
|
#line 2420 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-4].ll_node), (yyvsp[-1].ll_node), EXPR_LIST); }
|
|
#line 6660 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 288:
|
|
#line 2424 "gram1.y" /* yacc.c:1646 */
|
|
{ as_op_kwd_ = YES; }
|
|
#line 6666 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 289:
|
|
#line 2428 "gram1.y" /* yacc.c:1646 */
|
|
{ as_op_kwd_ = NO; }
|
|
#line 6672 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 290:
|
|
#line 2433 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
PTR_SYMB s;
|
|
s = make_scalar((yyvsp[0].hash_entry), TYNULL, LOCAL);
|
|
s->attr = s->attr | type_opt;
|
|
(yyval.ll_node) = make_llnd(fi,VAR_REF, LLNULL, LLNULL, s);
|
|
}
|
|
#line 6683 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 291:
|
|
#line 2440 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB s;
|
|
s = make_function((yyvsp[-1].hash_entry), global_default, LOCAL);
|
|
s->variant = INTERFACE_NAME;
|
|
s->attr = s->attr | type_opt;
|
|
(yyval.ll_node) = make_llnd(fi,OPERATOR_OP, LLNULL, LLNULL, s);
|
|
}
|
|
#line 6694 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 292:
|
|
#line 2447 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB s;
|
|
s = make_procedure(look_up_sym("="), LOCAL);
|
|
s->variant = INTERFACE_NAME;
|
|
s->attr = s->attr | type_opt;
|
|
(yyval.ll_node) = make_llnd(fi,ASSIGNMENT_OP, LLNULL, LLNULL, s);
|
|
}
|
|
#line 6705 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 293:
|
|
#line 2457 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); }
|
|
#line 6711 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 294:
|
|
#line 2459 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); }
|
|
#line 6717 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 295:
|
|
#line 2463 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB p;
|
|
|
|
/* The check if name and expr have compatible types has
|
|
not been done yet. */
|
|
p = make_constant((yyvsp[-2].hash_entry), TYNULL);
|
|
p->attr = p->attr | PARAMETER_BIT;
|
|
p->entry.const_value = (yyvsp[0].ll_node);
|
|
(yyval.ll_node) = make_llnd(fi,CONST_REF, LLNULL, LLNULL, p);
|
|
}
|
|
#line 6731 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 296:
|
|
#line 2475 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi, MODULE_PROC_STMT, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL); }
|
|
#line 6737 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 297:
|
|
#line 2478 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB s;
|
|
PTR_LLND q;
|
|
|
|
s = make_function((yyvsp[0].hash_entry), TYNULL, LOCAL);
|
|
s->variant = ROUTINE_NAME;
|
|
q = make_llnd(fi, VAR_REF, LLNULL, LLNULL, s);
|
|
(yyval.ll_node) = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
|
|
}
|
|
#line 6750 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 298:
|
|
#line 2487 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND p, q;
|
|
PTR_SYMB s;
|
|
|
|
s = make_function((yyvsp[0].hash_entry), TYNULL, LOCAL);
|
|
s->variant = ROUTINE_NAME;
|
|
p = make_llnd(fi, VAR_REF, LLNULL, LLNULL, s);
|
|
q = make_llnd(fi,EXPR_LIST, p, LLNULL, SMNULL);
|
|
add_to_lowLevelList(q, (yyvsp[-2].ll_node));
|
|
}
|
|
#line 6764 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 299:
|
|
#line 2500 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi, USE_STMT, (yyvsp[0].symbol), LLNULL, LLNULL, LLNULL);
|
|
/*add_scope_level($3->entry.Template.func_hedr, YES);*/ /*17.06.01*/
|
|
copy_module_scope((yyvsp[0].symbol),LLNULL); /*17.03.03*/
|
|
colon_flag = NO;
|
|
}
|
|
#line 6774 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 300:
|
|
#line 2506 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi, USE_STMT, (yyvsp[-3].symbol), (yyvsp[0].ll_node), LLNULL, LLNULL);
|
|
/*add_scope_level(module_scope, YES); *//* 17.06.01*/
|
|
copy_module_scope((yyvsp[-3].symbol),(yyvsp[0].ll_node)); /*17.03.03 */
|
|
colon_flag = NO;
|
|
}
|
|
#line 6784 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 301:
|
|
#line 2512 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND l;
|
|
|
|
l = make_llnd(fi, ONLY_NODE, LLNULL, LLNULL, SMNULL);
|
|
(yyval.bf_node) = get_bfnd(fi, USE_STMT, (yyvsp[-3].symbol), l, LLNULL, LLNULL);
|
|
}
|
|
#line 6794 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 302:
|
|
#line 2518 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND l;
|
|
|
|
l = make_llnd(fi, ONLY_NODE, (yyvsp[0].ll_node), LLNULL, SMNULL);
|
|
(yyval.bf_node) = get_bfnd(fi, USE_STMT, (yyvsp[-4].symbol), l, LLNULL, LLNULL);
|
|
}
|
|
#line 6804 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 303:
|
|
#line 2526 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
if ((yyvsp[0].hash_entry)->id_attr == SMNULL)
|
|
warn1("Unknown module %s", (yyvsp[0].hash_entry)->ident,308);
|
|
(yyval.symbol) = make_global_entity((yyvsp[0].hash_entry), MODULE_NAME, global_default, NO);
|
|
module_scope = (yyval.symbol)->entry.Template.func_hedr;
|
|
|
|
}
|
|
#line 6816 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 304:
|
|
#line 2536 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); }
|
|
#line 6822 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 305:
|
|
#line 2538 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); }
|
|
#line 6828 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 306:
|
|
#line 2542 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 6834 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 307:
|
|
#line 2544 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_HASH oldhash,copyhash;
|
|
PTR_SYMB oldsym, newsym;
|
|
PTR_LLND m;
|
|
|
|
oldhash = just_look_up_sym_in_scope(module_scope, (yyvsp[0].hash_entry)->ident);
|
|
if (oldhash == HSNULL) {
|
|
errstr("Unknown identifier %s.", (yyvsp[0].hash_entry)->ident,309);
|
|
(yyval.ll_node)= LLNULL;
|
|
}
|
|
else {
|
|
oldsym = oldhash->id_attr;
|
|
copyhash=just_look_up_sym_in_scope(cur_scope(), (yyvsp[0].hash_entry)->ident);
|
|
if( copyhash && copyhash->id_attr && copyhash->id_attr->entry.Template.tag==module_scope->id)
|
|
{
|
|
newsym = copyhash->id_attr;
|
|
newsym->entry.Template.tag = 0;
|
|
}
|
|
else
|
|
{
|
|
newsym = make_local_entity((yyvsp[0].hash_entry), oldsym->variant, oldsym->type,LOCAL);
|
|
/* copies data in entry.Template structure and attr */
|
|
copy_sym_data(oldsym, newsym);
|
|
/*newsym->entry.Template.base_name = oldsym;*//*19.03.03*/
|
|
}
|
|
/* l = make_llnd(fi, VAR_REF, LLNULL, LLNULL, oldsym);*/
|
|
m = make_llnd(fi, VAR_REF, LLNULL, LLNULL, newsym);
|
|
(yyval.ll_node) = make_llnd(fi, RENAME_NODE, m, LLNULL, oldsym);
|
|
}
|
|
}
|
|
#line 6868 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 308:
|
|
#line 2577 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); }
|
|
#line 6874 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 309:
|
|
#line 2579 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); }
|
|
#line 6880 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 310:
|
|
#line 2583 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_HASH oldhash,copyhash;
|
|
PTR_SYMB oldsym, newsym;
|
|
PTR_LLND l, m;
|
|
|
|
oldhash = just_look_up_sym_in_scope(module_scope, (yyvsp[0].hash_entry)->ident);
|
|
if (oldhash == HSNULL) {
|
|
errstr("Unknown identifier %s", (yyvsp[0].hash_entry)->ident,309);
|
|
(yyval.ll_node)= LLNULL;
|
|
}
|
|
else {
|
|
oldsym = oldhash->id_attr;
|
|
copyhash = just_look_up_sym_in_scope(cur_scope(), (yyvsp[0].hash_entry)->ident);
|
|
if(copyhash && copyhash->id_attr && copyhash->id_attr->entry.Template.tag==module_scope->id)
|
|
{
|
|
delete_symbol(copyhash->id_attr);
|
|
copyhash->id_attr = SMNULL;
|
|
}
|
|
newsym = make_local_entity((yyvsp[-2].hash_entry), oldsym->variant, oldsym->type, LOCAL);
|
|
/* copies data in entry.Template structure and attr */
|
|
copy_sym_data(oldsym, newsym);
|
|
|
|
/*newsym->entry.Template.base_name = oldsym;*//*19.03.03*/
|
|
l = make_llnd(fi, VAR_REF, LLNULL, LLNULL, oldsym);
|
|
m = make_llnd(fi, VAR_REF, LLNULL, LLNULL, newsym);
|
|
(yyval.ll_node) = make_llnd(fi, RENAME_NODE, m, l, SMNULL);
|
|
}
|
|
}
|
|
#line 6912 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 311:
|
|
#line 2621 "gram1.y" /* yacc.c:1646 */
|
|
{ ndim = 0; explicit_shape = 1; (yyval.ll_node) = LLNULL; }
|
|
#line 6918 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 312:
|
|
#line 2623 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[-1].ll_node); }
|
|
#line 6924 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 313:
|
|
#line 2626 "gram1.y" /* yacc.c:1646 */
|
|
{ ndim = 0; explicit_shape = 1;}
|
|
#line 6930 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 314:
|
|
#line 2627 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
|
|
(yyval.ll_node)->type = global_default;
|
|
}
|
|
#line 6939 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 315:
|
|
#line 2632 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); }
|
|
#line 6945 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 316:
|
|
#line 2636 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
if(ndim == maxdim)
|
|
err("Too many dimensions", 43);
|
|
else if(ndim < maxdim)
|
|
(yyval.ll_node) = (yyvsp[0].ll_node);
|
|
++ndim;
|
|
}
|
|
#line 6957 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 317:
|
|
#line 2644 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
if(ndim == maxdim)
|
|
err("Too many dimensions", 43);
|
|
else if(ndim < maxdim)
|
|
(yyval.ll_node) = make_llnd(fi, DDOT, LLNULL, LLNULL, SMNULL);
|
|
++ndim;
|
|
explicit_shape = 0;
|
|
}
|
|
#line 6970 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 318:
|
|
#line 2653 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
if(ndim == maxdim)
|
|
err("Too many dimensions", 43);
|
|
else if(ndim < maxdim)
|
|
(yyval.ll_node) = make_llnd(fi,DDOT, (yyvsp[-1].ll_node), LLNULL, SMNULL);
|
|
++ndim;
|
|
explicit_shape = 0;
|
|
}
|
|
#line 6983 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 319:
|
|
#line 2662 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
if(ndim == maxdim)
|
|
err("Too many dimensions", 43);
|
|
else if(ndim < maxdim)
|
|
(yyval.ll_node) = make_llnd(fi,DDOT, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), SMNULL);
|
|
++ndim;
|
|
}
|
|
#line 6995 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 320:
|
|
#line 2672 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,STAR_RANGE, LLNULL, LLNULL, SMNULL);
|
|
(yyval.ll_node)->type = global_default;
|
|
explicit_shape = 0;
|
|
}
|
|
#line 7005 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 322:
|
|
#line 2681 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); }
|
|
#line 7011 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 323:
|
|
#line 2683 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); }
|
|
#line 7017 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 324:
|
|
#line 2687 "gram1.y" /* yacc.c:1646 */
|
|
{PTR_LABEL p;
|
|
p = make_label_node(fi,convci(yyleng, yytext));
|
|
p->scope = cur_scope();
|
|
(yyval.ll_node) = make_llnd_label(fi,LABEL_REF, p);
|
|
}
|
|
#line 7027 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 325:
|
|
#line 2695 "gram1.y" /* yacc.c:1646 */
|
|
{ /*PTR_LLND l;*/
|
|
|
|
/* l = make_llnd(fi, EXPR_LIST, $3, LLNULL, SMNULL);*/
|
|
(yyval.bf_node) = get_bfnd(fi,IMPL_DECL, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL);
|
|
redefine_func_arg_type();
|
|
}
|
|
#line 7038 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 326:
|
|
#line 2710 "gram1.y" /* yacc.c:1646 */
|
|
{ /*undeftype = YES;
|
|
setimpl(TYNULL, (int)'a', (int)'z'); FB COMMENTED---> NOT QUITE RIGHT BUT AVOID PB WITH COMMON*/
|
|
(yyval.bf_node) = get_bfnd(fi,IMPL_DECL, SMNULL, LLNULL, LLNULL, LLNULL);
|
|
}
|
|
#line 7047 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 327:
|
|
#line 2717 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); }
|
|
#line 7053 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 328:
|
|
#line 2719 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); }
|
|
#line 7059 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 329:
|
|
#line 2723 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
|
|
(yyval.ll_node) = make_llnd(fi, IMPL_TYPE, (yyvsp[-1].ll_node), LLNULL, SMNULL);
|
|
(yyval.ll_node)->type = vartype;
|
|
}
|
|
#line 7069 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 330:
|
|
#line 2738 "gram1.y" /* yacc.c:1646 */
|
|
{ implkwd = YES; }
|
|
#line 7075 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 331:
|
|
#line 2739 "gram1.y" /* yacc.c:1646 */
|
|
{ vartype = (yyvsp[0].data_type); }
|
|
#line 7081 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 332:
|
|
#line 2743 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.data_type) = (yyvsp[0].data_type); }
|
|
#line 7087 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 333:
|
|
#line 2745 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.data_type) = (yyvsp[0].data_type);}
|
|
#line 7093 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 334:
|
|
#line 2757 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); }
|
|
#line 7099 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 335:
|
|
#line 2759 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); }
|
|
#line 7105 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 336:
|
|
#line 2763 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
setimpl(vartype, (int)(yyvsp[0].charv), (int)(yyvsp[0].charv));
|
|
(yyval.ll_node) = make_llnd(fi,CHAR_VAL, LLNULL, LLNULL, SMNULL);
|
|
(yyval.ll_node)->entry.cval = (yyvsp[0].charv);
|
|
}
|
|
#line 7115 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 337:
|
|
#line 2769 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND p,q;
|
|
|
|
setimpl(vartype, (int)(yyvsp[-2].charv), (int)(yyvsp[0].charv));
|
|
p = make_llnd(fi,CHAR_VAL, LLNULL, LLNULL, SMNULL);
|
|
p->entry.cval = (yyvsp[-2].charv);
|
|
q = make_llnd(fi,CHAR_VAL, LLNULL, LLNULL, SMNULL);
|
|
q->entry.cval = (yyvsp[0].charv);
|
|
(yyval.ll_node)= make_llnd(fi,DDOT, p, q, SMNULL);
|
|
}
|
|
#line 7129 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 338:
|
|
#line 2781 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
if(yyleng!=1 || yytext[0]<'a' || yytext[0]>'z')
|
|
{
|
|
err("IMPLICIT item must be single letter", 37);
|
|
(yyval.charv) = '\0';
|
|
}
|
|
else (yyval.charv) = yytext[0];
|
|
}
|
|
#line 7142 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 339:
|
|
#line 2792 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
if (parstate == OUTSIDE)
|
|
{ PTR_BFND p;
|
|
|
|
p = get_bfnd(fi,PROG_HEDR,
|
|
make_program(look_up_sym("_MAIN")),
|
|
LLNULL, LLNULL, LLNULL);
|
|
set_blobs(p, global_bfnd, NEW_GROUP1);
|
|
add_scope_level(p, NO);
|
|
position = IN_PROC;
|
|
parstate = INSIDE;
|
|
}
|
|
|
|
}
|
|
#line 7161 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 340:
|
|
#line 2809 "gram1.y" /* yacc.c:1646 */
|
|
{ switch(parstate)
|
|
{
|
|
case OUTSIDE:
|
|
{ PTR_BFND p;
|
|
|
|
p = get_bfnd(fi,PROG_HEDR,
|
|
make_program(look_up_sym("_MAIN")),
|
|
LLNULL, LLNULL, LLNULL);
|
|
set_blobs(p, global_bfnd, NEW_GROUP1);
|
|
add_scope_level(p, NO);
|
|
position = IN_PROC;
|
|
parstate = INDCL; }
|
|
break;
|
|
case INSIDE: parstate = INDCL;
|
|
case INDCL: break;
|
|
|
|
case INDATA:
|
|
/* err(
|
|
"Statement order error: declaration after DATA or function statement",
|
|
29);*/
|
|
break;
|
|
|
|
default:
|
|
err("Declaration among executables", 30);
|
|
}
|
|
}
|
|
#line 7192 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 343:
|
|
#line 2847 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL; endioctl(); }
|
|
#line 7198 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 344:
|
|
#line 2849 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); endioctl();}
|
|
#line 7204 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 345:
|
|
#line 2853 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 7210 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 346:
|
|
#line 2855 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 7216 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 347:
|
|
#line 2857 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND l;
|
|
l = make_llnd(fi, KEYWORD_ARG, (yyvsp[-1].ll_node), (yyvsp[0].ll_node), SMNULL);
|
|
l->type = (yyvsp[0].ll_node)->type;
|
|
(yyval.ll_node) = l;
|
|
}
|
|
#line 7226 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 348:
|
|
#line 2868 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST);
|
|
endioctl();
|
|
}
|
|
#line 7234 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 349:
|
|
#line 2872 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-3].ll_node), (yyvsp[0].ll_node), EXPR_LIST);
|
|
endioctl();
|
|
}
|
|
#line 7242 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 350:
|
|
#line 2878 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); }
|
|
#line 7248 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 351:
|
|
#line 2880 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); }
|
|
#line 7254 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 352:
|
|
#line 2884 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 7260 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 353:
|
|
#line 2886 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[-1].ll_node); }
|
|
#line 7266 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 354:
|
|
#line 2888 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 7272 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 355:
|
|
#line 2892 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 7278 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 356:
|
|
#line 2894 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 7284 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 357:
|
|
#line 2898 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 7290 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 358:
|
|
#line 2900 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node("+", ADD_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
|
|
#line 7296 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 359:
|
|
#line 2902 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node("-", SUBT_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
|
|
#line 7302 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 360:
|
|
#line 2904 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node("*", MULT_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
|
|
#line 7308 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 361:
|
|
#line 2906 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node("/", DIV_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
|
|
#line 7314 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 362:
|
|
#line 2908 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node("**", EXP_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
|
|
#line 7320 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 363:
|
|
#line 2910 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = defined_op_node((yyvsp[-1].hash_entry), (yyvsp[0].ll_node), LLNULL); }
|
|
#line 7326 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 364:
|
|
#line 2912 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node("+", UNARY_ADD_OP, (yyvsp[0].ll_node), LLNULL); }
|
|
#line 7332 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 365:
|
|
#line 2914 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node("-", MINUS_OP, (yyvsp[0].ll_node), LLNULL); }
|
|
#line 7338 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 366:
|
|
#line 2916 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node(".eq.", EQ_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
|
|
#line 7344 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 367:
|
|
#line 2918 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node(".gt.", GT_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
|
|
#line 7350 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 368:
|
|
#line 2920 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node(".lt.", LT_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
|
|
#line 7356 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 369:
|
|
#line 2922 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node(".ge.", GTEQL_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
|
|
#line 7362 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 370:
|
|
#line 2924 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node(".ge.", LTEQL_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
|
|
#line 7368 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 371:
|
|
#line 2926 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node(".ne.", NOTEQL_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
|
|
#line 7374 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 372:
|
|
#line 2928 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node(".eqv.", EQV_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
|
|
#line 7380 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 373:
|
|
#line 2930 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node(".neqv.", NEQV_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
|
|
#line 7386 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 374:
|
|
#line 2932 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node(".xor.", XOR_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
|
|
#line 7392 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 375:
|
|
#line 2934 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node(".or.", OR_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
|
|
#line 7398 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 376:
|
|
#line 2936 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node(".and.", AND_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
|
|
#line 7404 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 377:
|
|
#line 2938 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node(".not.", NOT_OP, (yyvsp[0].ll_node), LLNULL); }
|
|
#line 7410 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 378:
|
|
#line 2940 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = intrinsic_op_node("//", CONCAT_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
|
|
#line 7416 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 379:
|
|
#line 2942 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = defined_op_node((yyvsp[-1].hash_entry), (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
|
|
#line 7422 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 380:
|
|
#line 2945 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.token) = ADD_OP; }
|
|
#line 7428 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 381:
|
|
#line 2946 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.token) = SUBT_OP; }
|
|
#line 7434 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 382:
|
|
#line 2958 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB s;
|
|
PTR_TYPE t;
|
|
/* PTR_LLND l;*/
|
|
|
|
if (!(s = (yyvsp[0].hash_entry)->id_attr))
|
|
{
|
|
s = make_scalar((yyvsp[0].hash_entry), TYNULL, LOCAL);
|
|
s->decl = SOFT;
|
|
}
|
|
|
|
switch (s->variant)
|
|
{
|
|
case CONST_NAME:
|
|
(yyval.ll_node) = make_llnd(fi,CONST_REF,LLNULL,LLNULL, s);
|
|
t = s->type;
|
|
if ((t != TYNULL) &&
|
|
((t->variant == T_ARRAY) || (t->variant == T_STRING) ))
|
|
(yyval.ll_node)->variant = ARRAY_REF;
|
|
|
|
(yyval.ll_node)->type = t;
|
|
break;
|
|
case DEFAULT: /* if common region with same name has been
|
|
declared. */
|
|
s = make_scalar((yyvsp[0].hash_entry), TYNULL, LOCAL);
|
|
s->decl = SOFT;
|
|
|
|
case VARIABLE_NAME:
|
|
(yyval.ll_node) = make_llnd(fi,VAR_REF,LLNULL,LLNULL, s);
|
|
t = s->type;
|
|
if (t != TYNULL) {
|
|
if ((t->variant == T_ARRAY) || (t->variant == T_STRING) ||
|
|
((t->variant == T_POINTER) && (t->entry.Template.base_type->variant == T_ARRAY) ) )
|
|
(yyval.ll_node)->variant = ARRAY_REF;
|
|
|
|
/* if (t->variant == T_DERIVED_TYPE)
|
|
$$->variant = RECORD_REF; */
|
|
}
|
|
(yyval.ll_node)->type = t;
|
|
break;
|
|
case TYPE_NAME:
|
|
(yyval.ll_node) = make_llnd(fi,TYPE_REF,LLNULL,LLNULL, s);
|
|
(yyval.ll_node)->type = s->type;
|
|
break;
|
|
case INTERFACE_NAME:
|
|
(yyval.ll_node) = make_llnd(fi, INTERFACE_REF,LLNULL,LLNULL, s);
|
|
(yyval.ll_node)->type = s->type;
|
|
break;
|
|
case FUNCTION_NAME:
|
|
if(isResultVar(s)) {
|
|
(yyval.ll_node) = make_llnd(fi,VAR_REF,LLNULL,LLNULL, s);
|
|
t = s->type;
|
|
if (t != TYNULL) {
|
|
if ((t->variant == T_ARRAY) || (t->variant == T_STRING) ||
|
|
((t->variant == T_POINTER) && (t->entry.Template.base_type->variant == T_ARRAY) ) )
|
|
(yyval.ll_node)->variant = ARRAY_REF;
|
|
}
|
|
(yyval.ll_node)->type = t;
|
|
break;
|
|
}
|
|
default:
|
|
(yyval.ll_node) = make_llnd(fi,VAR_REF,LLNULL,LLNULL, s);
|
|
(yyval.ll_node)->type = s->type;
|
|
break;
|
|
}
|
|
/* if ($$->variant == T_POINTER) {
|
|
l = $$;
|
|
$$ = make_llnd(fi, DEREF_OP, l, LLNULL, SMNULL);
|
|
$$->type = l->type->entry.Template.base_type;
|
|
}
|
|
*/ /*11.02.03*/
|
|
}
|
|
#line 7510 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 383:
|
|
#line 3032 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB s;
|
|
(yyval.ll_node) = (yyvsp[0].ll_node);
|
|
s= (yyval.ll_node)->entry.Template.symbol;
|
|
if ((((yyvsp[0].ll_node)->variant == VAR_REF) || ((yyvsp[0].ll_node)->variant == ARRAY_REF)) && (s->scope !=cur_scope())) /*global_bfnd*/
|
|
{
|
|
if(((s->variant == FUNCTION_NAME) && (!isResultVar(s))) || (s->variant == PROCEDURE_NAME) || (s->variant == ROUTINE_NAME))
|
|
{ s = (yyval.ll_node)->entry.Template.symbol = make_scalar(s->parent, TYNULL, LOCAL);
|
|
(yyval.ll_node)->type = s->type;
|
|
}
|
|
}
|
|
}
|
|
#line 7526 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 384:
|
|
#line 3044 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 7532 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 385:
|
|
#line 3046 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 7538 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 386:
|
|
#line 3050 "gram1.y" /* yacc.c:1646 */
|
|
{ int num_triplets;
|
|
PTR_SYMB s; /*, sym;*/
|
|
/* PTR_LLND l; */
|
|
PTR_TYPE tp;
|
|
/* l = $1; */
|
|
s = (yyvsp[-4].ll_node)->entry.Template.symbol;
|
|
|
|
/* Handle variable to function conversion. */
|
|
if (((yyvsp[-4].ll_node)->variant == VAR_REF) &&
|
|
(((s->variant == VARIABLE_NAME) && (s->type) &&
|
|
(s->type->variant != T_ARRAY)) ||
|
|
(s->variant == ROUTINE_NAME))) {
|
|
s = (yyvsp[-4].ll_node)->entry.Template.symbol = make_function(s->parent, TYNULL, LOCAL);
|
|
(yyvsp[-4].ll_node)->variant = FUNC_CALL;
|
|
}
|
|
if (((yyvsp[-4].ll_node)->variant == VAR_REF) && (s->variant == FUNCTION_NAME)) {
|
|
if(isResultVar(s))
|
|
(yyvsp[-4].ll_node)->variant = ARRAY_REF;
|
|
else
|
|
(yyvsp[-4].ll_node)->variant = FUNC_CALL;
|
|
}
|
|
if (((yyvsp[-4].ll_node)->variant == VAR_REF) && (s->variant == PROGRAM_NAME)) {
|
|
errstr("The name '%s' is invalid in this context",s->ident,285);
|
|
(yyvsp[-4].ll_node)->variant = FUNC_CALL;
|
|
}
|
|
/* l = $1; */
|
|
num_triplets = is_array_section_ref((yyvsp[-1].ll_node));
|
|
switch ((yyvsp[-4].ll_node)->variant)
|
|
{
|
|
case TYPE_REF:
|
|
(yyvsp[-4].ll_node)->variant = STRUCTURE_CONSTRUCTOR;
|
|
(yyvsp[-4].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);
|
|
(yyval.ll_node) = (yyvsp[-4].ll_node);
|
|
(yyval.ll_node)->type = lookup_type(s->parent);
|
|
/* $$ = make_llnd(fi, STRUCTURE_CONSTRUCTOR, $1, $4, SMNULL);
|
|
$$->type = $1->type;*//*18.02.03*/
|
|
break;
|
|
case INTERFACE_REF:
|
|
/* sym = resolve_overloading(s, $4);
|
|
if (sym != SMNULL)
|
|
{
|
|
l = make_llnd(fi, FUNC_CALL, $4, LLNULL, sym);
|
|
l->type = sym->type;
|
|
$$ = $1; $$->variant = OVERLOADED_CALL;
|
|
$$->entry.Template.ll_ptr1 = l;
|
|
$$->type = sym->type;
|
|
}
|
|
else {
|
|
errstr("can't resolve call %s", s->ident,310);
|
|
}
|
|
break;
|
|
*/ /*podd 01.02.03*/
|
|
|
|
(yyvsp[-4].ll_node)->variant = FUNC_CALL;
|
|
|
|
case FUNC_CALL:
|
|
(yyvsp[-4].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);
|
|
(yyval.ll_node) = (yyvsp[-4].ll_node);
|
|
if(s->type)
|
|
(yyval.ll_node)->type = s->type;
|
|
else
|
|
(yyval.ll_node)->type = global_default;
|
|
/*late_bind_if_needed($$);*/ /*podd 02.02.23*/
|
|
break;
|
|
case DEREF_OP:
|
|
case ARRAY_REF:
|
|
/* array element */
|
|
if (num_triplets == 0) {
|
|
if ((yyvsp[-1].ll_node) == LLNULL) {
|
|
s = (yyvsp[-4].ll_node)->entry.Template.symbol = make_function(s->parent, TYNULL, LOCAL);
|
|
s->entry.func_decl.num_output = 1;
|
|
(yyvsp[-4].ll_node)->variant = FUNC_CALL;
|
|
(yyval.ll_node) = (yyvsp[-4].ll_node);
|
|
} else if ((yyvsp[-4].ll_node)->type->variant == T_STRING) {
|
|
PTR_LLND temp = (yyvsp[-1].ll_node);
|
|
int num_input = 0;
|
|
|
|
while (temp) {
|
|
++num_input;
|
|
temp = temp->entry.Template.ll_ptr2;
|
|
}
|
|
(yyvsp[-4].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);
|
|
s = (yyvsp[-4].ll_node)->entry.Template.symbol = make_function(s->parent, TYNULL, LOCAL);
|
|
s->entry.func_decl.num_output = 1;
|
|
s->entry.func_decl.num_input = num_input;
|
|
(yyvsp[-4].ll_node)->variant = FUNC_CALL;
|
|
(yyval.ll_node) = (yyvsp[-4].ll_node);
|
|
} else {
|
|
(yyvsp[-4].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);
|
|
(yyval.ll_node) = (yyvsp[-4].ll_node);
|
|
(yyval.ll_node)->type = (yyvsp[-4].ll_node)->type->entry.ar_decl.base_type;
|
|
}
|
|
}
|
|
/* substring */
|
|
else if ((num_triplets == 1) &&
|
|
((yyvsp[-4].ll_node)->type->variant == T_STRING)) {
|
|
/*
|
|
$1->entry.Template.ll_ptr1 = $4;
|
|
$$ = $1; $$->type = global_string;
|
|
*/
|
|
(yyval.ll_node) = make_llnd(fi,
|
|
ARRAY_OP, LLNULL, LLNULL, SMNULL);
|
|
(yyval.ll_node)->entry.Template.ll_ptr1 = (yyvsp[-4].ll_node);
|
|
(yyval.ll_node)->entry.Template.ll_ptr2 = (yyvsp[-1].ll_node)->entry.Template.ll_ptr1;
|
|
(yyval.ll_node)->type = global_string;
|
|
}
|
|
/* array section */
|
|
else {
|
|
(yyvsp[-4].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);
|
|
(yyval.ll_node) = (yyvsp[-4].ll_node); tp = make_type(fi, T_ARRAY); /**18.03.17*/
|
|
tp->entry.ar_decl.base_type = (yyvsp[-4].ll_node)->type->entry.ar_decl.base_type; /**18.03.17 $1->type */
|
|
tp->entry.ar_decl.num_dimensions = num_triplets;
|
|
(yyval.ll_node)->type = tp;
|
|
}
|
|
break;
|
|
default:
|
|
if((yyvsp[-4].ll_node)->entry.Template.symbol)
|
|
errstr("Can't subscript %s",(yyvsp[-4].ll_node)->entry.Template.symbol->ident, 44);
|
|
else
|
|
err("Can't subscript",44);
|
|
}
|
|
/*if ($$->variant == T_POINTER) {
|
|
l = $$;
|
|
$$ = make_llnd(fi, DEREF_OP, l, LLNULL, SMNULL);
|
|
$$->type = l->type->entry.Template.base_type;
|
|
}
|
|
*/ /*11.02.03*/
|
|
|
|
endioctl();
|
|
}
|
|
#line 7673 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 387:
|
|
#line 3181 "gram1.y" /* yacc.c:1646 */
|
|
{ int num_triplets;
|
|
PTR_SYMB s;
|
|
PTR_LLND l;
|
|
|
|
s = (yyvsp[-5].ll_node)->entry.Template.symbol;
|
|
/* if ($1->type->variant == T_POINTER) {
|
|
l = $1;
|
|
$1 = make_llnd(fi, DEREF_OP, l, LLNULL, SMNULL);
|
|
$1->type = l->type->entry.Template.base_type;
|
|
} */
|
|
if (((yyvsp[-5].ll_node)->type->variant != T_ARRAY) ||
|
|
((yyvsp[-5].ll_node)->type->entry.ar_decl.base_type->variant != T_STRING)) {
|
|
errstr("Can't take substring of %s", s->ident, 45);
|
|
}
|
|
else {
|
|
num_triplets = is_array_section_ref((yyvsp[-2].ll_node));
|
|
/* array element */
|
|
if (num_triplets == 0) {
|
|
(yyvsp[-5].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-2].ll_node);
|
|
/* $1->entry.Template.ll_ptr2 = $6;*/
|
|
/* $$ = $1;*/
|
|
l=(yyvsp[-5].ll_node);
|
|
/*$$->type = $1->type->entry.ar_decl.base_type;*/
|
|
l->type = global_string; /**18.03.17* $1->type->entry.ar_decl.base_type;*/
|
|
}
|
|
/* array section */
|
|
else {
|
|
(yyvsp[-5].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-2].ll_node);
|
|
/*$1->entry.Template.ll_ptr2 = $6;
|
|
$$ = $1; $$->type = make_type(fi, T_ARRAY);
|
|
$$->type->entry.ar_decl.base_type = $1->type;
|
|
$$->type->entry.ar_decl.num_dimensions = num_triplets;
|
|
*/
|
|
l = (yyvsp[-5].ll_node); l->type = make_type(fi, T_ARRAY);
|
|
l->type->entry.ar_decl.base_type = global_string; /**18.03.17* $1->type*/
|
|
l->type->entry.ar_decl.num_dimensions = num_triplets;
|
|
}
|
|
(yyval.ll_node) = make_llnd(fi, ARRAY_OP, l, (yyvsp[0].ll_node), SMNULL);
|
|
(yyval.ll_node)->type = l->type;
|
|
|
|
/* if ($$->variant == T_POINTER) {
|
|
l = $$;
|
|
$$ = make_llnd(fi, DEREF_OP, l, LLNULL, SMNULL);
|
|
$$->type = l->type->entry.Template.base_type;
|
|
}
|
|
*/ /*11.02.03*/
|
|
}
|
|
endioctl();
|
|
}
|
|
#line 7727 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 388:
|
|
#line 3231 "gram1.y" /* yacc.c:1646 */
|
|
{ int num_triplets;
|
|
PTR_LLND l,l1,l2;
|
|
PTR_TYPE tp;
|
|
|
|
/* if ($1->variant == T_POINTER) {
|
|
l = $1;
|
|
$1 = make_llnd(fi, DEREF_OP, l, LLNULL, SMNULL);
|
|
$1->type = l->type->entry.Template.base_type;
|
|
} */
|
|
|
|
num_triplets = is_array_section_ref((yyvsp[-1].ll_node));
|
|
(yyval.ll_node) = (yyvsp[-3].ll_node);
|
|
l2 = (yyvsp[-3].ll_node)->entry.Template.ll_ptr2;
|
|
l1 = (yyvsp[-3].ll_node)->entry.Template.ll_ptr1;
|
|
if(l2 && l2->type->variant == T_STRING)/*substring*/
|
|
if(num_triplets == 1){
|
|
l = make_llnd(fi, ARRAY_OP, LLNULL, LLNULL, SMNULL);
|
|
l->entry.Template.ll_ptr1 = l2;
|
|
l->entry.Template.ll_ptr2 = (yyvsp[-1].ll_node)->entry.Template.ll_ptr1;
|
|
l->type = global_string;
|
|
(yyval.ll_node)->entry.Template.ll_ptr2 = l;
|
|
} else
|
|
err("Can't subscript",44);
|
|
else if (l2 && l2->type->variant == T_ARRAY) {
|
|
if(num_triplets > 0) { /*array section*/
|
|
tp = make_type(fi,T_ARRAY);
|
|
tp->entry.ar_decl.base_type = (yyvsp[-3].ll_node)->type->entry.ar_decl.base_type;
|
|
tp->entry.ar_decl.num_dimensions = num_triplets;
|
|
(yyval.ll_node)->type = tp;
|
|
l2->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);
|
|
l2->type = (yyval.ll_node)->type;
|
|
}
|
|
else { /*array element*/
|
|
l2->type = l2->type->entry.ar_decl.base_type;
|
|
l2->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);
|
|
if(l1->type->variant != T_ARRAY)
|
|
(yyval.ll_node)->type = l2->type;
|
|
}
|
|
} else
|
|
{err("Can't subscript",44); /*fprintf(stderr,"%d %d",$1->variant,l2);*/}
|
|
/*errstr("Can't subscript %s",l2->entry.Template.symbol->ident,441);*/
|
|
}
|
|
#line 7774 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 389:
|
|
#line 3275 "gram1.y" /* yacc.c:1646 */
|
|
{ int num_triplets;
|
|
PTR_LLND l,q;
|
|
|
|
/* if ($1->variant == T_POINTER) {
|
|
l = $1;
|
|
$1 = make_llnd(fi, DEREF_OP, l, LLNULL, SMNULL);
|
|
$1->type = l->type->entry.Template.base_type;
|
|
} */
|
|
|
|
(yyval.ll_node) = (yyvsp[-4].ll_node);
|
|
if (((yyvsp[-4].ll_node)->type->variant != T_ARRAY) &&
|
|
((yyvsp[-4].ll_node)->type->entry.ar_decl.base_type->variant != T_STRING)) {
|
|
err("Can't take substring",45);
|
|
}
|
|
else {
|
|
num_triplets = is_array_section_ref((yyvsp[-2].ll_node));
|
|
l = (yyvsp[-4].ll_node)->entry.Template.ll_ptr2;
|
|
if(l) {
|
|
/* array element */
|
|
if (num_triplets == 0) {
|
|
l->entry.Template.ll_ptr1 = (yyvsp[-2].ll_node);
|
|
l->type = global_string;
|
|
}
|
|
/* array section */
|
|
else {
|
|
l->entry.Template.ll_ptr1 = (yyvsp[-2].ll_node);
|
|
l->type = make_type(fi, T_ARRAY);
|
|
l->type->entry.ar_decl.base_type = global_string;
|
|
l->type->entry.ar_decl.num_dimensions = num_triplets;
|
|
}
|
|
q = make_llnd(fi, ARRAY_OP, l, (yyvsp[0].ll_node), SMNULL);
|
|
q->type = l->type;
|
|
(yyval.ll_node)->entry.Template.ll_ptr2 = q;
|
|
if((yyvsp[-4].ll_node)->entry.Template.ll_ptr1->type->variant != T_ARRAY)
|
|
(yyval.ll_node)->type = q->type;
|
|
}
|
|
}
|
|
}
|
|
#line 7817 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 390:
|
|
#line 3317 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_TYPE t;
|
|
PTR_SYMB field;
|
|
/* PTR_BFND at_scope;*/
|
|
PTR_LLND l;
|
|
|
|
|
|
/* if ($1->variant == T_POINTER) {
|
|
l = $1;
|
|
$1 = make_llnd(fi, DEREF_OP, l, LLNULL, SMNULL);
|
|
$1->type = l->type->entry.Template.base_type;
|
|
} */
|
|
|
|
t = (yyvsp[-2].ll_node)->type;
|
|
|
|
if (( ( ((yyvsp[-2].ll_node)->variant == VAR_REF)
|
|
|| ((yyvsp[-2].ll_node)->variant == CONST_REF)
|
|
|| ((yyvsp[-2].ll_node)->variant == ARRAY_REF)
|
|
|| ((yyvsp[-2].ll_node)->variant == RECORD_REF)) && (t->variant == T_DERIVED_TYPE))
|
|
||((((yyvsp[-2].ll_node)->variant == ARRAY_REF) || ((yyvsp[-2].ll_node)->variant == RECORD_REF)) && (t->variant == T_ARRAY) &&
|
|
(t = t->entry.ar_decl.base_type) && (t->variant == T_DERIVED_TYPE)))
|
|
{
|
|
t->name = lookup_type_symbol(t->name);
|
|
if ((field = component(t->name, yytext))) {
|
|
l = make_llnd(fi, VAR_REF, LLNULL, LLNULL, field);
|
|
l->type = field->type;
|
|
if(field->type->variant == T_ARRAY || field->type->variant == T_STRING)
|
|
l->variant = ARRAY_REF;
|
|
(yyval.ll_node) = make_llnd(fi, RECORD_REF, (yyvsp[-2].ll_node), l, SMNULL);
|
|
if((yyvsp[-2].ll_node)->type->variant != T_ARRAY)
|
|
(yyval.ll_node)->type = field->type;
|
|
else {
|
|
(yyval.ll_node)->type = make_type(fi,T_ARRAY);
|
|
if(field->type->variant != T_ARRAY)
|
|
(yyval.ll_node)->type->entry.ar_decl.base_type = field->type;
|
|
else
|
|
(yyval.ll_node)->type->entry.ar_decl.base_type = field->type->entry.ar_decl.base_type;
|
|
(yyval.ll_node)->type->entry.ar_decl.num_dimensions = t->entry.ar_decl.num_dimensions;
|
|
}
|
|
}
|
|
else
|
|
errstr("Illegal component %s", yytext,311);
|
|
}
|
|
else
|
|
errstr("Can't take component %s", yytext,311);
|
|
}
|
|
#line 7867 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 391:
|
|
#line 3375 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 7873 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 392:
|
|
#line 3377 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 7879 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 393:
|
|
#line 3379 "gram1.y" /* yacc.c:1646 */
|
|
{ int num_triplets;
|
|
PTR_TYPE tp;
|
|
/* PTR_LLND l;*/
|
|
if ((yyvsp[-4].ll_node)->type->variant == T_ARRAY)
|
|
{
|
|
num_triplets = is_array_section_ref((yyvsp[-1].ll_node));
|
|
/* array element */
|
|
if (num_triplets == 0) {
|
|
(yyvsp[-4].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);
|
|
(yyval.ll_node) = (yyvsp[-4].ll_node);
|
|
(yyval.ll_node)->type = (yyvsp[-4].ll_node)->type->entry.ar_decl.base_type;
|
|
}
|
|
/* substring */
|
|
/* else if ((num_triplets == 1) &&
|
|
($1->type->variant == T_STRING)) {
|
|
$1->entry.Template.ll_ptr1 = $4;
|
|
$$ = $1; $$->type = global_string;
|
|
} */ /*podd*/
|
|
/* array section */
|
|
else {
|
|
(yyvsp[-4].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);
|
|
(yyval.ll_node) = (yyvsp[-4].ll_node); tp = make_type(fi, T_ARRAY);
|
|
tp->entry.ar_decl.base_type = (yyvsp[-4].ll_node)->type->entry.ar_decl.base_type; /**18.03.17* $1->type */
|
|
tp->entry.ar_decl.num_dimensions = num_triplets;
|
|
(yyval.ll_node)->type = tp;
|
|
}
|
|
}
|
|
else err("can't subscript",44);
|
|
|
|
/* if ($$->variant == T_POINTER) {
|
|
l = $$;
|
|
$$ = make_llnd(fi, DEREF_OP, l, LLNULL, SMNULL);
|
|
$$->type = l->type->entry.Template.base_type;
|
|
}
|
|
*/ /*11.02.03*/
|
|
|
|
endioctl();
|
|
}
|
|
#line 7922 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 394:
|
|
#line 3419 "gram1.y" /* yacc.c:1646 */
|
|
{ int num_triplets;
|
|
PTR_LLND l,l1,l2;
|
|
|
|
/* if ($1->variant == T_POINTER) {
|
|
l = $1;
|
|
$1 = make_llnd(fi, DEREF_OP, l, LLNULL, SMNULL);
|
|
$1->type = l->type->entry.Template.base_type;
|
|
} */
|
|
|
|
num_triplets = is_array_section_ref((yyvsp[-1].ll_node));
|
|
(yyval.ll_node) = (yyvsp[-3].ll_node);
|
|
l2 = (yyvsp[-3].ll_node)->entry.Template.ll_ptr2;
|
|
l1 = (yyvsp[-3].ll_node)->entry.Template.ll_ptr1;
|
|
if(l2 && l2->type->variant == T_STRING)/*substring*/
|
|
if(num_triplets == 1){
|
|
l = make_llnd(fi, ARRAY_OP, LLNULL, LLNULL, SMNULL);
|
|
l->entry.Template.ll_ptr1 = l2;
|
|
l->entry.Template.ll_ptr2 = (yyvsp[-1].ll_node)->entry.Template.ll_ptr1;
|
|
l->type = global_string;
|
|
(yyval.ll_node)->entry.Template.ll_ptr2 = l;
|
|
} else
|
|
err("Can't subscript",44);
|
|
else if (l2 && l2->type->variant == T_ARRAY) {
|
|
if(num_triplets > 0) { /*array section*/
|
|
(yyval.ll_node)->type = make_type(fi,T_ARRAY);
|
|
(yyval.ll_node)->type->entry.ar_decl.base_type = l2->type->entry.ar_decl.base_type;
|
|
(yyval.ll_node)->type->entry.ar_decl.num_dimensions = num_triplets;
|
|
l2->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);
|
|
l2->type = (yyval.ll_node)->type;
|
|
}
|
|
else { /*array element*/
|
|
l2->type = l2->type->entry.ar_decl.base_type;
|
|
l2->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);
|
|
if(l1->type->variant != T_ARRAY)
|
|
(yyval.ll_node)->type = l2->type;
|
|
}
|
|
} else
|
|
err("Can't subscript",44);
|
|
}
|
|
#line 7966 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 395:
|
|
#line 3461 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
if ((yyvsp[-1].ll_node)->type->variant == T_STRING) {
|
|
(yyvsp[-1].ll_node)->entry.Template.ll_ptr1 = (yyvsp[0].ll_node);
|
|
(yyval.ll_node) = (yyvsp[-1].ll_node); (yyval.ll_node)->type = global_string;
|
|
}
|
|
else errstr("can't subscript of %s", (yyvsp[-1].ll_node)->entry.Template.symbol->ident,44);
|
|
}
|
|
#line 7978 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 396:
|
|
#line 3471 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL; }
|
|
#line 7984 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 397:
|
|
#line 3473 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 7990 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 398:
|
|
#line 3477 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi, DDOT, (yyvsp[-3].ll_node), (yyvsp[-1].ll_node), SMNULL); }
|
|
#line 7996 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 399:
|
|
#line 3481 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL; }
|
|
#line 8002 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 400:
|
|
#line 3483 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 8008 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 401:
|
|
#line 3487 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 8014 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 402:
|
|
#line 3489 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_TYPE t;
|
|
t = make_type_node((yyvsp[-2].ll_node)->type, (yyvsp[0].ll_node));
|
|
(yyval.ll_node) = (yyvsp[-2].ll_node);
|
|
(yyval.ll_node)->type = t;
|
|
}
|
|
#line 8024 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 403:
|
|
#line 3495 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 8030 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 404:
|
|
#line 3497 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_TYPE t;
|
|
t = make_type_node((yyvsp[-2].ll_node)->type, (yyvsp[0].ll_node));
|
|
(yyval.ll_node) = (yyvsp[-2].ll_node);
|
|
(yyval.ll_node)->type = t;
|
|
}
|
|
#line 8040 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 405:
|
|
#line 3503 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
if ((yyvsp[0].ll_node) != LLNULL)
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi, ARRAY_OP, (yyvsp[-1].ll_node), (yyvsp[0].ll_node), SMNULL);
|
|
(yyval.ll_node)->type = global_string;
|
|
}
|
|
else
|
|
(yyval.ll_node) = (yyvsp[-1].ll_node);
|
|
}
|
|
#line 8054 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 406:
|
|
#line 3516 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,BOOL_VAL, LLNULL, LLNULL, SMNULL);
|
|
(yyval.ll_node)->entry.bval = 1;
|
|
(yyval.ll_node)->type = global_bool;
|
|
}
|
|
#line 8064 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 407:
|
|
#line 3522 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,BOOL_VAL, LLNULL, LLNULL, SMNULL);
|
|
(yyval.ll_node)->entry.bval = 0;
|
|
(yyval.ll_node)->type = global_bool;
|
|
}
|
|
#line 8074 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 408:
|
|
#line 3529 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,FLOAT_VAL, LLNULL, LLNULL, SMNULL);
|
|
(yyval.ll_node)->entry.string_val = copys(yytext);
|
|
(yyval.ll_node)->type = global_float;
|
|
}
|
|
#line 8084 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 409:
|
|
#line 3535 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,DOUBLE_VAL, LLNULL, LLNULL, SMNULL);
|
|
(yyval.ll_node)->entry.string_val = copys(yytext);
|
|
(yyval.ll_node)->type = global_double;
|
|
}
|
|
#line 8094 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 410:
|
|
#line 3543 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,INT_VAL, LLNULL, LLNULL, SMNULL);
|
|
(yyval.ll_node)->entry.ival = atoi(yytext);
|
|
(yyval.ll_node)->type = global_int;
|
|
}
|
|
#line 8104 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 411:
|
|
#line 3551 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_TYPE t;
|
|
PTR_LLND p,q;
|
|
(yyval.ll_node) = make_llnd(fi,STRING_VAL, LLNULL, LLNULL, SMNULL);
|
|
(yyval.ll_node)->entry.string_val = copys(yytext);
|
|
if(yyquote=='\"')
|
|
t = global_string_2;
|
|
else
|
|
t = global_string;
|
|
|
|
p = make_llnd(fi,INT_VAL, LLNULL, LLNULL, SMNULL);
|
|
p->entry.ival = yyleng;
|
|
p->type = global_int;
|
|
q = make_llnd(fi, LEN_OP, p, LLNULL, SMNULL);
|
|
(yyval.ll_node)->type = make_type_node(t, q);
|
|
}
|
|
#line 8124 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 412:
|
|
#line 3567 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_TYPE t;
|
|
(yyval.ll_node) = make_llnd(fi,STRING_VAL, LLNULL, LLNULL, SMNULL);
|
|
(yyval.ll_node)->entry.string_val = copys(yytext);
|
|
if(yyquote=='\"')
|
|
t = global_string_2;
|
|
else
|
|
t = global_string;
|
|
(yyval.ll_node)->type = make_type_node(t, (yyvsp[-2].ll_node));
|
|
}
|
|
#line 8138 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 413:
|
|
#line 3577 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_TYPE t;
|
|
(yyval.ll_node) = make_llnd(fi,STRING_VAL, LLNULL, LLNULL, SMNULL);
|
|
(yyval.ll_node)->entry.string_val = copys(yytext);
|
|
if(yyquote=='\"')
|
|
t = global_string_2;
|
|
else
|
|
t = global_string;
|
|
(yyval.ll_node)->type = make_type_node(t, (yyvsp[-2].ll_node));
|
|
}
|
|
#line 8152 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 414:
|
|
#line 3590 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,COMPLEX_VAL, (yyvsp[-3].ll_node), (yyvsp[-1].ll_node), SMNULL);
|
|
(yyval.ll_node)->type = global_complex;
|
|
}
|
|
#line 8161 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 415:
|
|
#line 3597 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 8167 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 416:
|
|
#line 3599 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 8173 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 417:
|
|
#line 3622 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,DDOT,(yyvsp[-2].ll_node),(yyvsp[0].ll_node),SMNULL); }
|
|
#line 8179 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 418:
|
|
#line 3624 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,DDOT,(yyvsp[-1].ll_node),LLNULL,SMNULL); }
|
|
#line 8185 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 419:
|
|
#line 3626 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,DDOT,make_llnd(fi,DDOT,(yyvsp[-4].ll_node),(yyvsp[-2].ll_node),SMNULL),(yyvsp[0].ll_node),SMNULL); }
|
|
#line 8191 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 420:
|
|
#line 3628 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,DDOT,make_llnd(fi,DDOT,(yyvsp[-3].ll_node),LLNULL,SMNULL),(yyvsp[0].ll_node),SMNULL); }
|
|
#line 8197 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 421:
|
|
#line 3630 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,DDOT, make_llnd(fi,DDOT,LLNULL,(yyvsp[-2].ll_node),SMNULL),(yyvsp[0].ll_node),SMNULL); }
|
|
#line 8203 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 422:
|
|
#line 3632 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,DDOT,make_llnd(fi,DDOT,LLNULL,LLNULL,SMNULL),(yyvsp[0].ll_node),SMNULL); }
|
|
#line 8209 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 423:
|
|
#line 3634 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,DDOT,LLNULL,(yyvsp[0].ll_node),SMNULL); }
|
|
#line 8215 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 424:
|
|
#line 3636 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,DDOT,LLNULL,LLNULL,SMNULL); }
|
|
#line 8221 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 425:
|
|
#line 3639 "gram1.y" /* yacc.c:1646 */
|
|
{in_vec=YES;}
|
|
#line 8227 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 426:
|
|
#line 3639 "gram1.y" /* yacc.c:1646 */
|
|
{in_vec=NO;}
|
|
#line 8233 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 427:
|
|
#line 3640 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_TYPE array_type;
|
|
(yyval.ll_node) = make_llnd (fi,CONSTRUCTOR_REF,(yyvsp[-2].ll_node),LLNULL,SMNULL);
|
|
/*$$->type = $2->type;*/ /*28.02.03*/
|
|
array_type = make_type(fi, T_ARRAY);
|
|
array_type->entry.ar_decl.num_dimensions = 1;
|
|
if((yyvsp[-2].ll_node)->type->variant == T_ARRAY)
|
|
array_type->entry.ar_decl.base_type = (yyvsp[-2].ll_node)->type->entry.ar_decl.base_type;
|
|
else
|
|
array_type->entry.ar_decl.base_type = (yyvsp[-2].ll_node)->type;
|
|
(yyval.ll_node)->type = array_type;
|
|
}
|
|
#line 8249 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 428:
|
|
#line 3654 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 8255 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 429:
|
|
#line 3656 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 8261 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 430:
|
|
#line 3679 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); }
|
|
#line 8267 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 431:
|
|
#line 3681 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-3].ll_node), (yyvsp[0].ll_node), EXPR_LIST); endioctl(); }
|
|
#line 8273 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 432:
|
|
#line 3683 "gram1.y" /* yacc.c:1646 */
|
|
{ stat_alloc = make_llnd(fi, SPEC_PAIR, (yyvsp[-1].ll_node), (yyvsp[0].ll_node), SMNULL);
|
|
endioctl();
|
|
}
|
|
#line 8281 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 433:
|
|
#line 3699 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); }
|
|
#line 8287 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 434:
|
|
#line 3701 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-3].ll_node), (yyvsp[0].ll_node), EXPR_LIST); endioctl(); }
|
|
#line 8293 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 435:
|
|
#line 3703 "gram1.y" /* yacc.c:1646 */
|
|
{ stat_alloc = make_llnd(fi, SPEC_PAIR, (yyvsp[-1].ll_node), (yyvsp[0].ll_node), SMNULL);
|
|
endioctl();
|
|
}
|
|
#line 8301 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 436:
|
|
#line 3716 "gram1.y" /* yacc.c:1646 */
|
|
{stat_alloc = LLNULL;}
|
|
#line 8307 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 437:
|
|
#line 3720 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); }
|
|
#line 8313 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 438:
|
|
#line 3722 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); }
|
|
#line 8319 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 439:
|
|
#line 3730 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = (yyvsp[0].bf_node); }
|
|
#line 8325 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 440:
|
|
#line 3732 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = (yyvsp[0].bf_node); }
|
|
#line 8331 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 441:
|
|
#line 3734 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = (yyvsp[0].bf_node); }
|
|
#line 8337 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 442:
|
|
#line 3736 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = (yyvsp[0].bf_node);
|
|
(yyval.bf_node)->entry.Template.ll_ptr3 = (yyvsp[-1].ll_node);
|
|
}
|
|
#line 8346 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 443:
|
|
#line 3790 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_BFND biff;
|
|
|
|
(yyval.bf_node) = get_bfnd(fi,CONTROL_END, SMNULL, LLNULL, LLNULL, LLNULL);
|
|
bind();
|
|
biff = cur_scope();
|
|
if ((biff->variant == FUNC_HEDR) || (biff->variant == PROC_HEDR)
|
|
|| (biff->variant == PROS_HEDR)
|
|
|| (biff->variant == PROG_HEDR)
|
|
|| (biff->variant == BLOCK_DATA)) {
|
|
if(biff->control_parent == global_bfnd) position = IN_OUTSIDE;
|
|
else if(!is_interface_stat(biff->control_parent)) position++;
|
|
} else if (biff->variant == MODULE_STMT)
|
|
position = IN_OUTSIDE;
|
|
else err("Unexpected END statement read", 52);
|
|
/* FB ADDED set the control parent so the empty function unparse right*/
|
|
if ((yyval.bf_node))
|
|
(yyval.bf_node)->control_parent = biff;
|
|
delete_beyond_scope_level(pred_bfnd);
|
|
}
|
|
#line 8370 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 444:
|
|
#line 3812 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
make_extend((yyvsp[0].symbol));
|
|
(yyval.bf_node) = BFNULL;
|
|
/* delete_beyond_scope_level(pred_bfnd); */
|
|
}
|
|
#line 8380 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 445:
|
|
#line 3825 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,CONTROL_END, SMNULL, LLNULL, LLNULL, LLNULL);
|
|
bind();
|
|
delete_beyond_scope_level(pred_bfnd);
|
|
position = IN_OUTSIDE;
|
|
}
|
|
#line 8390 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 446:
|
|
#line 3834 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = (yyvsp[0].bf_node); }
|
|
#line 8396 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 447:
|
|
#line 3837 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = (yyvsp[0].bf_node);
|
|
(yyval.bf_node)->entry.Template.ll_ptr3 = (yyvsp[-1].ll_node);
|
|
}
|
|
#line 8405 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 448:
|
|
#line 3887 "gram1.y" /* yacc.c:1646 */
|
|
{ thiswasbranch = NO;
|
|
(yyvsp[-1].bf_node)->variant = LOGIF_NODE;
|
|
(yyval.bf_node) = make_logif((yyvsp[-1].bf_node), (yyvsp[0].bf_node));
|
|
set_blobs((yyvsp[-1].bf_node), pred_bfnd, SAME_GROUP);
|
|
}
|
|
#line 8415 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 449:
|
|
#line 3893 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = (yyvsp[-1].bf_node);
|
|
set_blobs((yyval.bf_node), pred_bfnd, NEW_GROUP1);
|
|
}
|
|
#line 8424 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 450:
|
|
#line 3898 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = (yyvsp[-1].bf_node);
|
|
(yyval.bf_node)->entry.Template.ll_ptr3 = (yyvsp[-2].ll_node);
|
|
set_blobs((yyval.bf_node), pred_bfnd, NEW_GROUP1);
|
|
}
|
|
#line 8434 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 451:
|
|
#line 3916 "gram1.y" /* yacc.c:1646 */
|
|
{ make_elseif((yyvsp[-3].ll_node),(yyvsp[0].symbol)); lastwasbranch = NO; (yyval.bf_node) = BFNULL;}
|
|
#line 8440 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 452:
|
|
#line 3918 "gram1.y" /* yacc.c:1646 */
|
|
{ make_else((yyvsp[0].symbol)); lastwasbranch = NO; (yyval.bf_node) = BFNULL; }
|
|
#line 8446 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 453:
|
|
#line 3920 "gram1.y" /* yacc.c:1646 */
|
|
{ make_endif((yyvsp[0].symbol)); (yyval.bf_node) = BFNULL; }
|
|
#line 8452 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 454:
|
|
#line 3922 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = (yyvsp[0].bf_node); }
|
|
#line 8458 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 455:
|
|
#line 3924 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi, CONTAINS_STMT, SMNULL, LLNULL, LLNULL, LLNULL); }
|
|
#line 8464 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 456:
|
|
#line 3927 "gram1.y" /* yacc.c:1646 */
|
|
{ thiswasbranch = NO;
|
|
(yyvsp[-1].bf_node)->variant = FORALL_STAT;
|
|
(yyval.bf_node) = make_logif((yyvsp[-1].bf_node), (yyvsp[0].bf_node));
|
|
set_blobs((yyvsp[-1].bf_node), pred_bfnd, SAME_GROUP);
|
|
}
|
|
#line 8474 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 457:
|
|
#line 3933 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = (yyvsp[0].bf_node); }
|
|
#line 8480 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 458:
|
|
#line 3935 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = (yyvsp[0].bf_node); (yyval.bf_node)->entry.Template.ll_ptr3 = (yyvsp[-1].ll_node);}
|
|
#line 8486 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 459:
|
|
#line 3937 "gram1.y" /* yacc.c:1646 */
|
|
{ make_endforall((yyvsp[0].symbol)); (yyval.bf_node) = BFNULL; }
|
|
#line 8492 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 460:
|
|
#line 3940 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = (yyvsp[0].bf_node); }
|
|
#line 8498 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 461:
|
|
#line 3942 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = (yyvsp[0].bf_node); }
|
|
#line 8504 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 462:
|
|
#line 3944 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = (yyvsp[0].bf_node); }
|
|
#line 8510 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 463:
|
|
#line 3971 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
/* if($5 && $5->labdefined)
|
|
execerr("no backward DO loops", (char *)NULL); */
|
|
(yyval.bf_node) = make_do(WHILE_NODE, LBNULL, SMNULL, (yyvsp[-1].ll_node), LLNULL, LLNULL);
|
|
/*$$->entry.Template.ll_ptr3 = $1;*/
|
|
}
|
|
#line 8521 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 464:
|
|
#line 3980 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
if( (yyvsp[-3].label) && (yyvsp[-3].label)->labdefined)
|
|
err("No backward DO loops", 46);
|
|
(yyval.bf_node) = make_do(WHILE_NODE, (yyvsp[-3].label), SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL);
|
|
}
|
|
#line 8531 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 465:
|
|
#line 3988 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL; }
|
|
#line 8537 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 466:
|
|
#line 3990 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[-1].ll_node);}
|
|
#line 8543 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 467:
|
|
#line 3992 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[-1].ll_node);}
|
|
#line 8549 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 468:
|
|
#line 3997 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
if( (yyvsp[-7].label) && (yyvsp[-7].label)->labdefined)
|
|
err("No backward DO loops", 46);
|
|
(yyval.bf_node) = make_do(FOR_NODE, (yyvsp[-7].label), (yyvsp[-4].symbol), (yyvsp[-2].ll_node), (yyvsp[0].ll_node), LLNULL);
|
|
}
|
|
#line 8559 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 469:
|
|
#line 4004 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
if( (yyvsp[-9].label) && (yyvsp[-9].label)->labdefined)
|
|
err("No backward DO loops", 46);
|
|
(yyval.bf_node) = make_do(FOR_NODE, (yyvsp[-9].label), (yyvsp[-6].symbol), (yyvsp[-4].ll_node), (yyvsp[-2].ll_node), (yyvsp[0].ll_node));
|
|
}
|
|
#line 8569 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 470:
|
|
#line 4012 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi, CASE_NODE, (yyvsp[0].symbol), (yyvsp[-1].ll_node), LLNULL, LLNULL); }
|
|
#line 8575 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 471:
|
|
#line 4014 "gram1.y" /* yacc.c:1646 */
|
|
{ /*PTR_LLND p;*/
|
|
/* p = make_llnd(fi, DEFAULT, LLNULL, LLNULL, SMNULL); */
|
|
(yyval.bf_node) = get_bfnd(fi, DEFAULT_NODE, (yyvsp[0].symbol), LLNULL, LLNULL, LLNULL); }
|
|
#line 8583 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 472:
|
|
#line 4018 "gram1.y" /* yacc.c:1646 */
|
|
{ make_endselect((yyvsp[0].symbol)); (yyval.bf_node) = BFNULL; }
|
|
#line 8589 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 473:
|
|
#line 4021 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi, SWITCH_NODE, SMNULL, (yyvsp[-1].ll_node), LLNULL, LLNULL) ; }
|
|
#line 8595 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 474:
|
|
#line 4023 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi, SWITCH_NODE, SMNULL, (yyvsp[-1].ll_node), LLNULL, (yyvsp[-7].ll_node)) ; }
|
|
#line 8601 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 475:
|
|
#line 4027 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[-1].ll_node); }
|
|
#line 8607 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 476:
|
|
#line 4033 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 8613 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 477:
|
|
#line 4035 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi, DDOT, (yyvsp[-1].ll_node), LLNULL, SMNULL); }
|
|
#line 8619 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 478:
|
|
#line 4037 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi, DDOT, LLNULL, (yyvsp[0].ll_node), SMNULL); }
|
|
#line 8625 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 479:
|
|
#line 4039 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi, DDOT, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), SMNULL); }
|
|
#line 8631 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 480:
|
|
#line 4043 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi, EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL); }
|
|
#line 8637 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 481:
|
|
#line 4045 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND p;
|
|
|
|
p = make_llnd(fi, EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
|
|
add_to_lowLevelList(p, (yyvsp[-2].ll_node));
|
|
}
|
|
#line 8647 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 482:
|
|
#line 4053 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.symbol) = SMNULL; }
|
|
#line 8653 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 483:
|
|
#line 4055 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.symbol) = make_local_entity((yyvsp[0].hash_entry), CONSTRUCT_NAME, global_default,
|
|
LOCAL); }
|
|
#line 8660 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 484:
|
|
#line 4061 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.hash_entry) = HSNULL;}
|
|
#line 8666 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 485:
|
|
#line 4063 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.hash_entry) = (yyvsp[0].hash_entry);}
|
|
#line 8672 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 486:
|
|
#line 4067 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.hash_entry) = look_up_sym(yytext);}
|
|
#line 8678 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 487:
|
|
#line 4071 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB s;
|
|
s = make_local_entity( (yyvsp[-1].hash_entry), CONSTRUCT_NAME, global_default, LOCAL);
|
|
(yyval.ll_node) = make_llnd(fi, VAR_REF, LLNULL, LLNULL, s);
|
|
}
|
|
#line 8687 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 488:
|
|
#line 4092 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = make_if((yyvsp[-1].ll_node)); }
|
|
#line 8693 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 489:
|
|
#line 4095 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = make_forall((yyvsp[-2].ll_node),(yyvsp[-1].ll_node)); }
|
|
#line 8699 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 490:
|
|
#line 4099 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi, EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL); }
|
|
#line 8705 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 491:
|
|
#line 4101 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND p;
|
|
p = make_llnd(fi, EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
|
|
add_to_lowLevelList(p, (yyvsp[-2].ll_node));
|
|
}
|
|
#line 8714 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 492:
|
|
#line 4108 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.ll_node) = make_llnd(fi, FORALL_OP, (yyvsp[0].ll_node), LLNULL, (yyvsp[-2].symbol)); }
|
|
#line 8720 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 493:
|
|
#line 4112 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node)=LLNULL;}
|
|
#line 8726 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 494:
|
|
#line 4114 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node)=(yyvsp[0].ll_node);}
|
|
#line 8732 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 495:
|
|
#line 4125 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB s;
|
|
s = (yyvsp[0].hash_entry)->id_attr;
|
|
if (!s || s->variant == DEFAULT)
|
|
{
|
|
s = make_scalar((yyvsp[0].hash_entry), TYNULL, LOCAL);
|
|
s->decl = SOFT;
|
|
}
|
|
(yyval.symbol) = s;
|
|
}
|
|
#line 8746 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 496:
|
|
#line 4138 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB s;
|
|
PTR_LLND l;
|
|
int vrnt;
|
|
|
|
/* s = make_scalar($1, TYNULL, LOCAL);*/ /*16.02.03*/
|
|
s = (yyvsp[-4].symbol);
|
|
if (s->variant != CONST_NAME) {
|
|
if(in_vec)
|
|
vrnt=SEQ;
|
|
else
|
|
vrnt=DDOT;
|
|
l = make_llnd(fi, SEQ, make_llnd(fi, vrnt, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), SMNULL),
|
|
LLNULL, SMNULL);
|
|
(yyval.ll_node) = make_llnd(fi,IOACCESS, LLNULL, l, s);
|
|
do_name_err = NO;
|
|
}
|
|
else {
|
|
err("Symbolic constant not allowed as DO variable", 47);
|
|
do_name_err = YES;
|
|
}
|
|
}
|
|
#line 8772 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 497:
|
|
#line 4161 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB s;
|
|
PTR_LLND l;
|
|
int vrnt;
|
|
/*s = make_scalar($1, TYNULL, LOCAL);*/ /*16.02.03*/
|
|
s = (yyvsp[-6].symbol);
|
|
if( s->variant != CONST_NAME ) {
|
|
if(in_vec)
|
|
vrnt=SEQ;
|
|
else
|
|
vrnt=DDOT;
|
|
l = make_llnd(fi, SEQ, make_llnd(fi, vrnt, (yyvsp[-4].ll_node), (yyvsp[-2].ll_node), SMNULL), (yyvsp[0].ll_node),
|
|
SMNULL);
|
|
(yyval.ll_node) = make_llnd(fi,IOACCESS, LLNULL, l, s);
|
|
do_name_err = NO;
|
|
}
|
|
else {
|
|
err("Symbolic constant not allowed as DO variable", 47);
|
|
do_name_err = YES;
|
|
}
|
|
}
|
|
#line 8797 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 498:
|
|
#line 4184 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.label) = LBNULL; }
|
|
#line 8803 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 499:
|
|
#line 4186 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.label) = make_label_node(fi,convci(yyleng, yytext));
|
|
(yyval.label)->scope = cur_scope();
|
|
}
|
|
#line 8812 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 500:
|
|
#line 4193 "gram1.y" /* yacc.c:1646 */
|
|
{ make_endwhere((yyvsp[0].symbol)); (yyval.bf_node) = BFNULL; }
|
|
#line 8818 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 501:
|
|
#line 4195 "gram1.y" /* yacc.c:1646 */
|
|
{ make_elsewhere((yyvsp[0].symbol)); lastwasbranch = NO; (yyval.bf_node) = BFNULL; }
|
|
#line 8824 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 502:
|
|
#line 4197 "gram1.y" /* yacc.c:1646 */
|
|
{ make_elsewhere_mask((yyvsp[-2].ll_node),(yyvsp[0].symbol)); lastwasbranch = NO; (yyval.bf_node) = BFNULL; }
|
|
#line 8830 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 503:
|
|
#line 4199 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi, WHERE_BLOCK_STMT, SMNULL, (yyvsp[-1].ll_node), LLNULL, LLNULL); }
|
|
#line 8836 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 504:
|
|
#line 4201 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi, WHERE_BLOCK_STMT, SMNULL, (yyvsp[-1].ll_node), LLNULL, (yyvsp[-5].ll_node)); }
|
|
#line 8842 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 505:
|
|
#line 4206 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND p, r;
|
|
PTR_SYMB s1, s2 = SMNULL, s3, arg_list;
|
|
PTR_HASH hash_entry;
|
|
|
|
/* if (just_look_up_sym("=") != HSNULL) {
|
|
p = intrinsic_op_node("=", EQUAL, $2, $4);
|
|
$$ = get_bfnd(fi, OVERLOADED_ASSIGN_STAT, SMNULL, p, $2, $4);
|
|
}
|
|
else */ if ((yyvsp[-2].ll_node)->variant == FUNC_CALL) {
|
|
if(parstate==INEXEC){
|
|
err("Declaration among executables", 30);
|
|
/* $$=BFNULL;*/
|
|
(yyval.bf_node) = get_bfnd(fi,STMTFN_STAT, SMNULL, (yyvsp[-2].ll_node), LLNULL, LLNULL);
|
|
}
|
|
else {
|
|
(yyvsp[-2].ll_node)->variant = STMTFN_DECL;
|
|
/* $2->entry.Template.ll_ptr2 = $4; */
|
|
if( (yyvsp[-2].ll_node)->entry.Template.ll_ptr1) {
|
|
r = (yyvsp[-2].ll_node)->entry.Template.ll_ptr1->entry.Template.ll_ptr1;
|
|
if(r->variant != VAR_REF && r->variant != ARRAY_REF){
|
|
err("A dummy argument of a statement function must be a scalar identifier", 333);
|
|
s1 = SMNULL;
|
|
}
|
|
else
|
|
s1 = r ->entry.Template.symbol;
|
|
} else
|
|
s1 = SMNULL;
|
|
if (s1)
|
|
s1->scope = cur_scope();
|
|
(yyval.bf_node) = get_bfnd(fi,STMTFN_STAT, SMNULL, (yyvsp[-2].ll_node), LLNULL, LLNULL);
|
|
add_scope_level((yyval.bf_node), NO);
|
|
arg_list = SMNULL;
|
|
if (s1)
|
|
{
|
|
/*arg_list = SMNULL;*/
|
|
p = (yyvsp[-2].ll_node)->entry.Template.ll_ptr1;
|
|
while (p != LLNULL)
|
|
{
|
|
/* if (p->entry.Template.ll_ptr1->variant != VAR_REF) {
|
|
errstr("cftn.gram:1: illegal statement function %s.", $2->entry.Template.symbol->ident);
|
|
break;
|
|
}
|
|
*/
|
|
r = p->entry.Template.ll_ptr1;
|
|
if(r->variant != VAR_REF && r->variant != ARRAY_REF){
|
|
err("A dummy argument of a statement function must be a scalar identifier", 333);
|
|
break;
|
|
}
|
|
hash_entry = look_up_sym(r->entry.Template.symbol->parent->ident);
|
|
s3 = make_scalar(hash_entry, s1->type, IO);
|
|
replace_symbol_in_expr(s3,(yyvsp[0].ll_node));
|
|
if (arg_list == SMNULL)
|
|
s2 = arg_list = s3;
|
|
else
|
|
{
|
|
s2->id_list = s3;
|
|
s2 = s3;
|
|
}
|
|
p = p->entry.Template.ll_ptr2;
|
|
}
|
|
}
|
|
(yyvsp[-2].ll_node)->entry.Template.ll_ptr1 = (yyvsp[0].ll_node);
|
|
install_param_list((yyvsp[-2].ll_node)->entry.Template.symbol,
|
|
arg_list, LLNULL, FUNCTION_NAME);
|
|
delete_beyond_scope_level((yyval.bf_node));
|
|
|
|
/* else
|
|
errstr("cftn.gram: Illegal statement function declaration %s.", $2->entry.Template.symbol->ident); */
|
|
}
|
|
}
|
|
else {
|
|
(yyval.bf_node) = get_bfnd(fi,ASSIGN_STAT,SMNULL, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), LLNULL);
|
|
parstate = INEXEC;
|
|
}
|
|
}
|
|
#line 8922 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 506:
|
|
#line 4282 "gram1.y" /* yacc.c:1646 */
|
|
{ /*PTR_SYMB s;*/
|
|
|
|
/*s = make_scalar($2, TYNULL, LOCAL);*/
|
|
(yyval.bf_node) = get_bfnd(fi, POINTER_ASSIGN_STAT, SMNULL, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), LLNULL);
|
|
}
|
|
#line 8932 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 507:
|
|
#line 4294 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB p;
|
|
|
|
p = make_scalar((yyvsp[0].hash_entry), TYNULL, LOCAL);
|
|
p->variant = LABEL_VAR;
|
|
(yyval.bf_node) = get_bfnd(fi,ASSLAB_STAT, p, (yyvsp[-2].ll_node),LLNULL,LLNULL);
|
|
}
|
|
#line 8943 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 508:
|
|
#line 4301 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,CONT_STAT,SMNULL,LLNULL,LLNULL,LLNULL); }
|
|
#line 8949 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 510:
|
|
#line 4304 "gram1.y" /* yacc.c:1646 */
|
|
{ inioctl = NO; }
|
|
#line 8955 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 511:
|
|
#line 4306 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND p;
|
|
|
|
p = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
|
|
p = make_llnd(fi,EXPR_LIST, (yyvsp[-2].ll_node), p, SMNULL);
|
|
(yyval.bf_node)= get_bfnd(fi,ARITHIF_NODE, SMNULL, (yyvsp[-6].ll_node),
|
|
make_llnd(fi,EXPR_LIST, (yyvsp[-4].ll_node), p, SMNULL), LLNULL);
|
|
thiswasbranch = YES;
|
|
}
|
|
#line 8968 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 512:
|
|
#line 4315 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = subroutine_call((yyvsp[0].symbol), LLNULL, LLNULL, PLAIN);
|
|
/* match_parameters($1, LLNULL);
|
|
$$= get_bfnd(fi,PROC_STAT, $1, LLNULL, LLNULL, LLNULL);
|
|
*/ endioctl();
|
|
}
|
|
#line 8979 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 513:
|
|
#line 4322 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = subroutine_call((yyvsp[-2].symbol), LLNULL, LLNULL, PLAIN);
|
|
/* match_parameters($1, LLNULL);
|
|
$$= get_bfnd(fi,PROC_STAT,$1,LLNULL,LLNULL,LLNULL);
|
|
*/ endioctl();
|
|
}
|
|
#line 8990 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 514:
|
|
#line 4329 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = subroutine_call((yyvsp[-3].symbol), (yyvsp[-1].ll_node), LLNULL, PLAIN);
|
|
/* match_parameters($1, $3);
|
|
$$= get_bfnd(fi,PROC_STAT,$1,$3,LLNULL,LLNULL);
|
|
*/ endioctl();
|
|
}
|
|
#line 9001 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 515:
|
|
#line 4337 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = get_bfnd(fi,RETURN_STAT,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL);
|
|
thiswasbranch = YES;
|
|
}
|
|
#line 9010 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 516:
|
|
#line 4342 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = get_bfnd(fi,(yyvsp[-2].token),SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL);
|
|
thiswasbranch = ((yyvsp[-2].token) == STOP_STAT);
|
|
}
|
|
#line 9019 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 517:
|
|
#line 4347 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi, CYCLE_STMT, (yyvsp[0].symbol), LLNULL, LLNULL, LLNULL); }
|
|
#line 9025 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 518:
|
|
#line 4350 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi, EXIT_STMT, (yyvsp[0].symbol), LLNULL, LLNULL, LLNULL); }
|
|
#line 9031 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 519:
|
|
#line 4353 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi, ALLOCATE_STMT, SMNULL, (yyvsp[-1].ll_node), stat_alloc, LLNULL); }
|
|
#line 9037 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 520:
|
|
#line 4356 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi, DEALLOCATE_STMT, SMNULL, (yyvsp[-1].ll_node), stat_alloc , LLNULL); }
|
|
#line 9043 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 521:
|
|
#line 4359 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi, NULLIFY_STMT, SMNULL, (yyvsp[-1].ll_node), LLNULL, LLNULL); }
|
|
#line 9049 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 522:
|
|
#line 4362 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi, WHERE_NODE, SMNULL, (yyvsp[-4].ll_node), (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
|
|
#line 9055 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 523:
|
|
#line 4380 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.ll_node) = LLNULL;}
|
|
#line 9061 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 524:
|
|
#line 4384 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node)=get_bfnd(fi,GOTO_NODE,SMNULL,LLNULL,LLNULL,(PTR_LLND)(yyvsp[0].ll_node));
|
|
thiswasbranch = YES;
|
|
}
|
|
#line 9070 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 525:
|
|
#line 4389 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB p;
|
|
|
|
if((yyvsp[0].hash_entry)->id_attr)
|
|
p = (yyvsp[0].hash_entry)->id_attr;
|
|
else {
|
|
p = make_scalar((yyvsp[0].hash_entry), TYNULL, LOCAL);
|
|
p->variant = LABEL_VAR;
|
|
}
|
|
|
|
if(p->variant == LABEL_VAR) {
|
|
(yyval.bf_node) = get_bfnd(fi,ASSGOTO_NODE,p,LLNULL,LLNULL,LLNULL);
|
|
thiswasbranch = YES;
|
|
}
|
|
else {
|
|
err("Must go to assigned variable", 48);
|
|
(yyval.bf_node) = BFNULL;
|
|
}
|
|
}
|
|
#line 9093 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 526:
|
|
#line 4408 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB p;
|
|
|
|
if((yyvsp[-4].hash_entry)->id_attr)
|
|
p = (yyvsp[-4].hash_entry)->id_attr;
|
|
else {
|
|
p = make_scalar((yyvsp[-4].hash_entry), TYNULL, LOCAL);
|
|
p->variant = LABEL_VAR;
|
|
}
|
|
|
|
if (p->variant == LABEL_VAR) {
|
|
(yyval.bf_node) = get_bfnd(fi,ASSGOTO_NODE,p,(yyvsp[-1].ll_node),LLNULL,LLNULL);
|
|
thiswasbranch = YES;
|
|
}
|
|
else {
|
|
err("Must go to assigned variable",48);
|
|
(yyval.bf_node) = BFNULL;
|
|
}
|
|
}
|
|
#line 9116 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 527:
|
|
#line 4427 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,COMGOTO_NODE, SMNULL, (yyvsp[-3].ll_node), (yyvsp[0].ll_node), LLNULL); }
|
|
#line 9122 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 530:
|
|
#line 4435 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.symbol) = make_procedure((yyvsp[-1].hash_entry), LOCAL); }
|
|
#line 9128 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 531:
|
|
#line 4439 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST);
|
|
endioctl();
|
|
}
|
|
#line 9137 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 532:
|
|
#line 4444 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = set_ll_list((yyvsp[-3].ll_node), (yyvsp[0].ll_node), EXPR_LIST);
|
|
endioctl();
|
|
}
|
|
#line 9146 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 533:
|
|
#line 4451 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 9152 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 534:
|
|
#line 4453 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi, KEYWORD_ARG, (yyvsp[-1].ll_node), (yyvsp[0].ll_node), SMNULL); }
|
|
#line 9158 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 535:
|
|
#line 4455 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,LABEL_ARG,(yyvsp[0].ll_node),LLNULL,SMNULL); }
|
|
#line 9164 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 536:
|
|
#line 4458 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.token) = PAUSE_NODE; }
|
|
#line 9170 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 537:
|
|
#line 4459 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.token) = STOP_STAT; }
|
|
#line 9176 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 538:
|
|
#line 4470 "gram1.y" /* yacc.c:1646 */
|
|
{ if(parstate == OUTSIDE)
|
|
{ PTR_BFND p;
|
|
|
|
p = get_bfnd(fi,PROG_HEDR, make_program(look_up_sym("_MAIN")), LLNULL, LLNULL, LLNULL);
|
|
set_blobs(p, global_bfnd, NEW_GROUP1);
|
|
add_scope_level(p, NO);
|
|
position = IN_PROC;
|
|
}
|
|
if(parstate < INDATA) enddcl();
|
|
parstate = INEXEC;
|
|
yystno = 0;
|
|
}
|
|
#line 9193 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 539:
|
|
#line 4485 "gram1.y" /* yacc.c:1646 */
|
|
{ intonly = YES; }
|
|
#line 9199 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 540:
|
|
#line 4489 "gram1.y" /* yacc.c:1646 */
|
|
{ intonly = NO; }
|
|
#line 9205 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 541:
|
|
#line 4497 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyvsp[-1].bf_node)->entry.Template.ll_ptr2 = (yyvsp[0].ll_node);
|
|
(yyval.bf_node) = (yyvsp[-1].bf_node); }
|
|
#line 9212 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 542:
|
|
#line 4500 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND p, q = LLNULL;
|
|
|
|
q = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
|
|
q->entry.string_val = (char *)"unit";
|
|
q->type = global_string;
|
|
p = make_llnd(fi, SPEC_PAIR, q, (yyvsp[0].ll_node), SMNULL);
|
|
(yyvsp[-1].bf_node)->entry.Template.ll_ptr2 = p;
|
|
endioctl();
|
|
(yyval.bf_node) = (yyvsp[-1].bf_node); }
|
|
#line 9226 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 543:
|
|
#line 4510 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND p, q, r;
|
|
|
|
p = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
|
|
p->entry.string_val = (char *)"*";
|
|
p->type = global_string;
|
|
q = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
|
|
q->entry.string_val = (char *)"unit";
|
|
q->type = global_string;
|
|
r = make_llnd(fi, SPEC_PAIR, p, q, SMNULL);
|
|
(yyvsp[-1].bf_node)->entry.Template.ll_ptr2 = r;
|
|
endioctl();
|
|
(yyval.bf_node) = (yyvsp[-1].bf_node); }
|
|
#line 9243 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 544:
|
|
#line 4523 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND p, q, r;
|
|
|
|
p = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
|
|
p->entry.string_val = (char *)"**";
|
|
p->type = global_string;
|
|
q = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
|
|
q->entry.string_val = (char *)"unit";
|
|
q->type = global_string;
|
|
r = make_llnd(fi, SPEC_PAIR, p, q, SMNULL);
|
|
(yyvsp[-1].bf_node)->entry.Template.ll_ptr2 = r;
|
|
endioctl();
|
|
(yyval.bf_node) = (yyvsp[-1].bf_node); }
|
|
#line 9260 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 545:
|
|
#line 4536 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyvsp[-1].bf_node)->entry.Template.ll_ptr2 = (yyvsp[0].ll_node);
|
|
(yyval.bf_node) = (yyvsp[-1].bf_node); }
|
|
#line 9267 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 546:
|
|
#line 4539 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = (yyvsp[0].bf_node); }
|
|
#line 9273 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 547:
|
|
#line 4541 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyvsp[-1].bf_node)->entry.Template.ll_ptr2 = (yyvsp[0].ll_node);
|
|
(yyval.bf_node) = (yyvsp[-1].bf_node); }
|
|
#line 9280 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 548:
|
|
#line 4544 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyvsp[-1].bf_node)->entry.Template.ll_ptr2 = (yyvsp[0].ll_node);
|
|
(yyval.bf_node) = (yyvsp[-1].bf_node); }
|
|
#line 9287 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 549:
|
|
#line 4547 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyvsp[-2].bf_node)->entry.Template.ll_ptr2 = (yyvsp[-1].ll_node);
|
|
(yyvsp[-2].bf_node)->entry.Template.ll_ptr1 = (yyvsp[0].ll_node);
|
|
(yyval.bf_node) = (yyvsp[-2].bf_node); }
|
|
#line 9295 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 550:
|
|
#line 4551 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyvsp[-3].bf_node)->entry.Template.ll_ptr2 = (yyvsp[-2].ll_node);
|
|
(yyvsp[-3].bf_node)->entry.Template.ll_ptr1 = (yyvsp[0].ll_node);
|
|
(yyval.bf_node) = (yyvsp[-3].bf_node); }
|
|
#line 9303 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 551:
|
|
#line 4560 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyvsp[-1].bf_node)->entry.Template.ll_ptr2 = (yyvsp[0].ll_node);
|
|
(yyval.bf_node) = (yyvsp[-1].bf_node); }
|
|
#line 9310 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 552:
|
|
#line 4563 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyvsp[-2].bf_node)->entry.Template.ll_ptr2 = (yyvsp[-1].ll_node);
|
|
(yyvsp[-2].bf_node)->entry.Template.ll_ptr1 = (yyvsp[0].ll_node);
|
|
(yyval.bf_node) = (yyvsp[-2].bf_node); }
|
|
#line 9318 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 553:
|
|
#line 4567 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = (yyvsp[0].bf_node); }
|
|
#line 9324 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 554:
|
|
#line 4569 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyvsp[-2].bf_node)->entry.Template.ll_ptr1 = (yyvsp[0].ll_node);
|
|
(yyval.bf_node) = (yyvsp[-2].bf_node); }
|
|
#line 9331 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 555:
|
|
#line 4575 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = (yyvsp[-2].bf_node); }
|
|
#line 9337 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 556:
|
|
#line 4579 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.bf_node) = get_bfnd(fi, BACKSPACE_STAT, SMNULL, LLNULL, LLNULL, LLNULL);}
|
|
#line 9343 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 557:
|
|
#line 4581 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.bf_node) = get_bfnd(fi, REWIND_STAT, SMNULL, LLNULL, LLNULL, LLNULL);}
|
|
#line 9349 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 558:
|
|
#line 4583 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.bf_node) = get_bfnd(fi, ENDFILE_STAT, SMNULL, LLNULL, LLNULL, LLNULL);}
|
|
#line 9355 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 559:
|
|
#line 4590 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = (yyvsp[-2].bf_node); }
|
|
#line 9361 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 560:
|
|
#line 4594 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.bf_node) = get_bfnd(fi, OPEN_STAT, SMNULL, LLNULL, LLNULL, LLNULL);}
|
|
#line 9367 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 561:
|
|
#line 4596 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.bf_node) = get_bfnd(fi, CLOSE_STAT, SMNULL, LLNULL, LLNULL, LLNULL);}
|
|
#line 9373 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 562:
|
|
#line 4600 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi, INQUIRE_STAT, SMNULL, LLNULL, (yyvsp[0].ll_node), LLNULL);}
|
|
#line 9379 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 563:
|
|
#line 4602 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi, INQUIRE_STAT, SMNULL, (yyvsp[0].ll_node), (yyvsp[-1].ll_node), LLNULL);}
|
|
#line 9385 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 564:
|
|
#line 4606 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND p;
|
|
PTR_LLND q = LLNULL;
|
|
|
|
if ((yyvsp[0].ll_node)->variant == INT_VAL)
|
|
{
|
|
PTR_LABEL r;
|
|
|
|
r = make_label_node(fi, (long) (yyvsp[0].ll_node)->entry.ival);
|
|
r->scope = cur_scope();
|
|
p = make_llnd_label(fi, LABEL_REF, r);
|
|
}
|
|
else p = (yyvsp[0].ll_node);
|
|
q = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
|
|
q->entry.string_val = (char *)"fmt";
|
|
q->type = global_string;
|
|
(yyval.ll_node) = make_llnd(fi, SPEC_PAIR, q, p, SMNULL);
|
|
endioctl();
|
|
}
|
|
#line 9408 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 565:
|
|
#line 4625 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND p;
|
|
PTR_LLND q;
|
|
|
|
p = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
|
|
p->entry.string_val = (char *)"*";
|
|
p->type = global_string;
|
|
q = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
|
|
q->entry.string_val = (char *)"fmt";
|
|
q->type = global_string;
|
|
(yyval.ll_node) = make_llnd(fi, SPEC_PAIR, q, p, SMNULL);
|
|
endioctl();
|
|
}
|
|
#line 9425 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 566:
|
|
#line 4641 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND p;
|
|
|
|
p = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
|
|
p->entry.string_val = (char *)"unit";
|
|
p->type = global_string;
|
|
(yyval.ll_node) = make_llnd(fi, SPEC_PAIR, p, (yyvsp[-1].ll_node), SMNULL);
|
|
endioctl();
|
|
}
|
|
#line 9438 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 567:
|
|
#line 4652 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = (yyvsp[-1].ll_node);
|
|
endioctl();
|
|
}
|
|
#line 9447 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 568:
|
|
#line 4659 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); endioctl();}
|
|
#line 9453 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 569:
|
|
#line 4661 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-3].ll_node), (yyvsp[0].ll_node), EXPR_LIST); endioctl();}
|
|
#line 9459 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 570:
|
|
#line 4665 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND p;
|
|
PTR_LLND q;
|
|
|
|
nioctl++;
|
|
if ((nioctl == 2) && ((yyvsp[0].ll_node)->variant == INT_VAL))
|
|
{
|
|
PTR_LABEL r;
|
|
|
|
r = make_label_node(fi, (long) (yyvsp[0].ll_node)->entry.ival);
|
|
r->scope = cur_scope();
|
|
p = make_llnd_label(fi, LABEL_REF, r);
|
|
}
|
|
else p = (yyvsp[0].ll_node);
|
|
q = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
|
|
if (nioctl == 1)
|
|
q->entry.string_val = (char *)"unit";
|
|
else {
|
|
if(((yyvsp[0].ll_node)->variant == VAR_REF) && (yyvsp[0].ll_node)->entry.Template.symbol->variant == NAMELIST_NAME)
|
|
q->entry.string_val = (char *)"nml";
|
|
else
|
|
q->entry.string_val = (char *)"fmt";
|
|
}
|
|
q->type = global_string;
|
|
(yyval.ll_node) = make_llnd(fi, SPEC_PAIR, q, p, SMNULL);
|
|
}
|
|
#line 9489 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 571:
|
|
#line 4691 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND p;
|
|
PTR_LLND q;
|
|
|
|
nioctl++;
|
|
p = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
|
|
p->entry.string_val = (char *)"*";
|
|
p->type = global_string;
|
|
q = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
|
|
if (nioctl == 1)
|
|
q->entry.string_val = (char *)"unit";
|
|
else q->entry.string_val = (char *)"fmt";
|
|
q->type = global_string;
|
|
(yyval.ll_node) = make_llnd(fi, SPEC_PAIR, q, p, SMNULL);
|
|
}
|
|
#line 9508 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 572:
|
|
#line 4706 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND p;
|
|
PTR_LLND q;
|
|
|
|
nioctl++;
|
|
p = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
|
|
p->entry.string_val = (char *)"**";
|
|
p->type = global_string;
|
|
q = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
|
|
if (nioctl == 1)
|
|
q->entry.string_val = (char *)"unit";
|
|
else q->entry.string_val = (char *)"fmt";
|
|
q->type = global_string;
|
|
(yyval.ll_node) = make_llnd(fi, SPEC_PAIR, q, p, SMNULL);
|
|
}
|
|
#line 9527 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 573:
|
|
#line 4721 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
PTR_LLND p;
|
|
char *q;
|
|
|
|
q = (yyvsp[-1].ll_node)->entry.string_val;
|
|
if ((strcmp(q, "end") == 0) || (strcmp(q, "err") == 0) || (strcmp(q, "eor") == 0) || ((strcmp(q,"fmt") == 0) && ((yyvsp[0].ll_node)->variant == INT_VAL)))
|
|
{
|
|
PTR_LABEL r;
|
|
|
|
r = make_label_node(fi, (long) (yyvsp[0].ll_node)->entry.ival);
|
|
r->scope = cur_scope();
|
|
p = make_llnd_label(fi, LABEL_REF, r);
|
|
}
|
|
else p = (yyvsp[0].ll_node);
|
|
|
|
(yyval.ll_node) = make_llnd(fi, SPEC_PAIR, (yyvsp[-1].ll_node), p, SMNULL); }
|
|
#line 9548 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 574:
|
|
#line 4738 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND p;
|
|
|
|
p = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
|
|
p->entry.string_val = (char *)"*";
|
|
p->type = global_string;
|
|
(yyval.ll_node) = make_llnd(fi, SPEC_PAIR, (yyvsp[-1].ll_node), p, SMNULL);
|
|
}
|
|
#line 9560 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 575:
|
|
#line 4746 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND p;
|
|
p = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
|
|
p->entry.string_val = (char *)"*";
|
|
p->type = global_string;
|
|
(yyval.ll_node) = make_llnd(fi, SPEC_PAIR, (yyvsp[-1].ll_node), p, SMNULL);
|
|
}
|
|
#line 9571 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 576:
|
|
#line 4755 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
|
|
(yyval.ll_node)->entry.string_val = copys(yytext);
|
|
(yyval.ll_node)->type = global_string;
|
|
}
|
|
#line 9580 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 577:
|
|
#line 4763 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.bf_node) = get_bfnd(fi, READ_STAT, SMNULL, LLNULL, LLNULL, LLNULL);}
|
|
#line 9586 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 578:
|
|
#line 4768 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.bf_node) = get_bfnd(fi, WRITE_STAT, SMNULL, LLNULL, LLNULL, LLNULL);}
|
|
#line 9592 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 579:
|
|
#line 4773 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
PTR_LLND p, q, l;
|
|
|
|
if ((yyvsp[-1].ll_node)->variant == INT_VAL)
|
|
{
|
|
PTR_LABEL r;
|
|
|
|
r = make_label_node(fi, (long) (yyvsp[-1].ll_node)->entry.ival);
|
|
r->scope = cur_scope();
|
|
p = make_llnd_label(fi, LABEL_REF, r);
|
|
}
|
|
else p = (yyvsp[-1].ll_node);
|
|
|
|
q = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
|
|
q->entry.string_val = (char *)"fmt";
|
|
q->type = global_string;
|
|
l = make_llnd(fi, SPEC_PAIR, q, p, SMNULL);
|
|
|
|
(yyval.bf_node) = get_bfnd(fi, PRINT_STAT, SMNULL, LLNULL, l, LLNULL);
|
|
endioctl();
|
|
}
|
|
#line 9618 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 580:
|
|
#line 4795 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND p, q, r;
|
|
|
|
p = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
|
|
p->entry.string_val = (char *)"*";
|
|
p->type = global_string;
|
|
q = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
|
|
q->entry.string_val = (char *)"fmt";
|
|
q->type = global_string;
|
|
r = make_llnd(fi, SPEC_PAIR, q, p, SMNULL);
|
|
(yyval.bf_node) = get_bfnd(fi, PRINT_STAT, SMNULL, LLNULL, r, LLNULL);
|
|
endioctl();
|
|
}
|
|
#line 9635 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 581:
|
|
#line 4811 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST);}
|
|
#line 9641 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 582:
|
|
#line 4813 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST);}
|
|
#line 9647 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 583:
|
|
#line 4817 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 9653 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 584:
|
|
#line 4819 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyvsp[-1].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-3].ll_node);
|
|
(yyval.ll_node) = (yyvsp[-1].ll_node);
|
|
}
|
|
#line 9662 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 585:
|
|
#line 4826 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); (yyval.ll_node)->type = (yyvsp[0].ll_node)->type;}
|
|
#line 9668 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 586:
|
|
#line 4828 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 9674 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 587:
|
|
#line 4830 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 9680 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 588:
|
|
#line 4834 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); (yyval.ll_node)->type = (yyvsp[-2].ll_node)->type;}
|
|
#line 9686 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 589:
|
|
#line 4836 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); (yyval.ll_node)->type = (yyvsp[-2].ll_node)->type;}
|
|
#line 9692 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 590:
|
|
#line 4838 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); (yyval.ll_node)->type = (yyvsp[-2].ll_node)->type;}
|
|
#line 9698 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 591:
|
|
#line 4840 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); (yyval.ll_node)->type = (yyvsp[-2].ll_node)->type;}
|
|
#line 9704 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 592:
|
|
#line 4842 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); (yyval.ll_node)->type = (yyvsp[-2].ll_node)->type;}
|
|
#line 9710 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 593:
|
|
#line 4844 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); (yyval.ll_node)->type = (yyvsp[-2].ll_node)->type;}
|
|
#line 9716 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 594:
|
|
#line 4848 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST);
|
|
(yyval.ll_node)->type = global_complex; }
|
|
#line 9723 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 595:
|
|
#line 4851 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node), LLNULL, EXPR_LIST);
|
|
(yyval.ll_node)->type = (yyvsp[-1].ll_node)->type; }
|
|
#line 9730 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 596:
|
|
#line 4854 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyvsp[-1].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-3].ll_node);
|
|
(yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node), LLNULL, EXPR_LIST);
|
|
(yyval.ll_node)->type = (yyvsp[-3].ll_node)->type;
|
|
}
|
|
#line 9740 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 597:
|
|
#line 4860 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyvsp[-1].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-3].ll_node);
|
|
(yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node), LLNULL, EXPR_LIST);
|
|
(yyval.ll_node)->type = (yyvsp[-3].ll_node)->type;
|
|
}
|
|
#line 9750 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 598:
|
|
#line 4866 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyvsp[-1].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-3].ll_node);
|
|
(yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node), LLNULL, EXPR_LIST);
|
|
(yyval.ll_node)->type = (yyvsp[-3].ll_node)->type;
|
|
}
|
|
#line 9760 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 599:
|
|
#line 4874 "gram1.y" /* yacc.c:1646 */
|
|
{ inioctl = YES; }
|
|
#line 9766 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 600:
|
|
#line 4878 "gram1.y" /* yacc.c:1646 */
|
|
{ startioctl();}
|
|
#line 9772 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 601:
|
|
#line 4886 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 9778 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 602:
|
|
#line 4888 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[-1].ll_node); }
|
|
#line 9784 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 603:
|
|
#line 4892 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 9790 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 604:
|
|
#line 4894 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 9796 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 605:
|
|
#line 4896 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,(yyvsp[-1].token), (yyvsp[-2].ll_node), (yyvsp[0].ll_node), SMNULL);
|
|
set_expr_type((yyval.ll_node));
|
|
}
|
|
#line 9805 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 606:
|
|
#line 4901 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,MULT_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), SMNULL);
|
|
set_expr_type((yyval.ll_node));
|
|
}
|
|
#line 9814 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 607:
|
|
#line 4906 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,DIV_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), SMNULL);
|
|
set_expr_type((yyval.ll_node));
|
|
}
|
|
#line 9823 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 608:
|
|
#line 4911 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,EXP_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), SMNULL);
|
|
set_expr_type((yyval.ll_node));
|
|
}
|
|
#line 9832 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 609:
|
|
#line 4916 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
if((yyvsp[-1].token) == SUBT_OP)
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,SUBT_OP, (yyvsp[0].ll_node), LLNULL, SMNULL);
|
|
set_expr_type((yyval.ll_node));
|
|
}
|
|
else (yyval.ll_node) = (yyvsp[0].ll_node);
|
|
}
|
|
#line 9845 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 610:
|
|
#line 4925 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,CONCAT_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), SMNULL);
|
|
set_expr_type((yyval.ll_node));
|
|
}
|
|
#line 9854 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 611:
|
|
#line 4930 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL; }
|
|
#line 9860 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 612:
|
|
#line 4935 "gram1.y" /* yacc.c:1646 */
|
|
{ comments = cur_comment = CMNULL; }
|
|
#line 9866 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 613:
|
|
#line 4937 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_CMNT p;
|
|
p = make_comment(fi,*commentbuf, HALF);
|
|
if (cur_comment)
|
|
cur_comment->next = p;
|
|
else {
|
|
if ((pred_bfnd->control_parent->variant == LOGIF_NODE) ||(pred_bfnd->control_parent->variant == FORALL_STAT))
|
|
|
|
pred_bfnd->control_parent->entry.Template.cmnt_ptr = p;
|
|
|
|
else last_bfnd->entry.Template.cmnt_ptr = p;
|
|
}
|
|
comments = cur_comment = CMNULL;
|
|
}
|
|
#line 9884 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 677:
|
|
#line 5020 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,HPF_TEMPLATE_STAT, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL); }
|
|
#line 9890 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 678:
|
|
#line 5022 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB s;
|
|
if((yyvsp[-2].bf_node)->entry.Template.ll_ptr2)
|
|
{
|
|
s = (yyvsp[0].ll_node)->entry.Template.ll_ptr1->entry.Template.symbol;
|
|
s->attr = s->attr | COMMON_BIT;
|
|
}
|
|
add_to_lowLevelList((yyvsp[0].ll_node), (yyvsp[-2].bf_node)->entry.Template.ll_ptr1);
|
|
}
|
|
#line 9903 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 679:
|
|
#line 5033 "gram1.y" /* yacc.c:1646 */
|
|
{PTR_SYMB s;
|
|
PTR_LLND q;
|
|
/* 27.06.18
|
|
if(! explicit_shape)
|
|
err("Explicit shape specification is required", 50);
|
|
*/
|
|
s = make_array((yyvsp[-1].hash_entry), TYNULL, (yyvsp[0].ll_node), ndim, LOCAL);
|
|
if(s->attr & TEMPLATE_BIT)
|
|
errstr( "Multiple declaration of identifier %s ", s->ident, 73);
|
|
if((s->attr & PROCESSORS_BIT) || (s->attr & TASK_BIT) || (s->attr & DVM_POINTER_BIT))
|
|
errstr( "Inconsistent declaration of identifier %s ", s->ident, 16);
|
|
else
|
|
s->attr = s->attr | TEMPLATE_BIT;
|
|
if((yyvsp[0].ll_node)) s->attr = s->attr | DIMENSION_BIT;
|
|
q = make_llnd(fi,ARRAY_REF, (yyvsp[0].ll_node), LLNULL, s);
|
|
s->type->entry.ar_decl.ranges = (yyvsp[0].ll_node);
|
|
(yyval.ll_node) = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
|
|
}
|
|
#line 9926 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 680:
|
|
#line 5054 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_DYNAMIC_DIR, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL);}
|
|
#line 9932 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 681:
|
|
#line 5058 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 9938 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 682:
|
|
#line 5060 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 9944 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 683:
|
|
#line 5064 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB s;
|
|
s = make_array((yyvsp[0].hash_entry), TYNULL, LLNULL, 0, LOCAL);
|
|
if(s->attr & DYNAMIC_BIT)
|
|
errstr( "Multiple declaration of identifier %s ", s->ident, 73);
|
|
if((s->attr & PROCESSORS_BIT) || (s->attr & TASK_BIT) || (s->attr & HEAP_BIT))
|
|
errstr("Inconsistent declaration of identifier %s", s->ident, 16);
|
|
else
|
|
s->attr = s->attr | DYNAMIC_BIT;
|
|
(yyval.ll_node) = make_llnd(fi,ARRAY_REF, LLNULL, LLNULL, s);
|
|
}
|
|
#line 9959 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 684:
|
|
#line 5077 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_INHERIT_DIR, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL);}
|
|
#line 9965 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 685:
|
|
#line 5081 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 9971 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 686:
|
|
#line 5083 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 9977 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 687:
|
|
#line 5087 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB s;
|
|
s = make_array((yyvsp[0].hash_entry), TYNULL, LLNULL, 0, LOCAL);
|
|
if((s->attr & PROCESSORS_BIT) ||(s->attr & TASK_BIT) || (s->attr & TEMPLATE_BIT) || (s->attr & ALIGN_BIT) || (s->attr & DISTRIBUTE_BIT))
|
|
errstr("Inconsistent declaration of identifier %s", s->ident, 16);
|
|
else
|
|
s->attr = s->attr | INHERIT_BIT;
|
|
(yyval.ll_node) = make_llnd(fi,ARRAY_REF, LLNULL, LLNULL, s);
|
|
}
|
|
#line 9990 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 688:
|
|
#line 5098 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND q;
|
|
q = set_ll_list((yyvsp[-1].ll_node),LLNULL,EXPR_LIST);
|
|
/* (void)fprintf(stderr,"hpf.gram: shadow\n");*/
|
|
(yyval.bf_node) = get_bfnd(fi,DVM_SHADOW_DIR,SMNULL,q,(yyvsp[0].ll_node),LLNULL);
|
|
}
|
|
#line 10000 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 689:
|
|
#line 5109 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[-1].ll_node);}
|
|
#line 10006 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 690:
|
|
#line 5113 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 10012 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 691:
|
|
#line 5115 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 10018 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 692:
|
|
#line 5119 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 10024 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 693:
|
|
#line 5121 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,DDOT, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), SMNULL);}
|
|
#line 10030 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 694:
|
|
#line 5123 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
if(parstate!=INEXEC)
|
|
err("Illegal shadow width specification", 56);
|
|
(yyval.ll_node) = make_llnd(fi,SHADOW_NAMES_OP, (yyvsp[-1].ll_node), LLNULL, SMNULL);
|
|
}
|
|
#line 10040 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 695:
|
|
#line 5138 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB s;
|
|
s = make_array((yyvsp[0].hash_entry), TYNULL, LLNULL, 0, LOCAL);
|
|
if(s->attr & SHADOW_BIT)
|
|
errstr( "Multiple declaration of identifier %s ", s->ident, 73);
|
|
if((s->attr & PROCESSORS_BIT) ||(s->attr & TASK_BIT) || (s->attr & TEMPLATE_BIT) || (s->attr & HEAP_BIT))
|
|
errstr( "Inconsistent declaration of identifier %s", s->ident, 16);
|
|
else
|
|
s->attr = s->attr | SHADOW_BIT;
|
|
(yyval.ll_node) = make_llnd(fi,ARRAY_REF, LLNULL, LLNULL, s);
|
|
}
|
|
#line 10055 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 696:
|
|
#line 5150 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB s;
|
|
PTR_LLND q, r;
|
|
if(! explicit_shape) {
|
|
err("Explicit shape specification is required", 50);
|
|
/* $$ = BFNULL;*/
|
|
}
|
|
s = make_array((yyvsp[-1].hash_entry), TYNULL, (yyvsp[0].ll_node), ndim, LOCAL);
|
|
if(s->attr & PROCESSORS_BIT)
|
|
errstr( "Multiple declaration of identifier %s ", s->ident, 73);
|
|
if((s->attr & ALIGN_BIT) ||(s->attr & DISTRIBUTE_BIT) ||(s->attr & TEMPLATE_BIT) || (s->attr & DYNAMIC_BIT) ||(s->attr & SHADOW_BIT) || (s->attr & TASK_BIT) || (s->attr & DVM_POINTER_BIT) || (s->attr & INHERIT_BIT))
|
|
errstr("Inconsistent declaration of identifier %s", s->ident, 16);
|
|
else
|
|
s->attr = s->attr | PROCESSORS_BIT;
|
|
if((yyvsp[0].ll_node)) s->attr = s->attr | DIMENSION_BIT;
|
|
q = make_llnd(fi,ARRAY_REF, (yyvsp[0].ll_node), LLNULL, s);
|
|
s->type->entry.ar_decl.ranges = (yyvsp[0].ll_node);
|
|
r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
|
|
(yyval.bf_node) = get_bfnd(fi,HPF_PROCESSORS_STAT, SMNULL, r, LLNULL, LLNULL);
|
|
}
|
|
#line 10079 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 697:
|
|
#line 5170 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB s;
|
|
PTR_LLND q, r;
|
|
if(! explicit_shape) {
|
|
err("Explicit shape specification is required", 50);
|
|
/* $$ = BFNULL;*/
|
|
}
|
|
s = make_array((yyvsp[-1].hash_entry), TYNULL, (yyvsp[0].ll_node), ndim, LOCAL);
|
|
if(s->attr & PROCESSORS_BIT)
|
|
errstr( "Multiple declaration of identifier %s ", s->ident, 73);
|
|
if((s->attr & ALIGN_BIT) ||(s->attr & DISTRIBUTE_BIT) ||(s->attr & TEMPLATE_BIT) || (s->attr & DYNAMIC_BIT) ||(s->attr & SHADOW_BIT) || (s->attr & TASK_BIT) || (s->attr & DVM_POINTER_BIT) || (s->attr & INHERIT_BIT))
|
|
errstr("Inconsistent declaration of identifier %s", s->ident, 16);
|
|
else
|
|
s->attr = s->attr | PROCESSORS_BIT;
|
|
if((yyvsp[0].ll_node)) s->attr = s->attr | DIMENSION_BIT;
|
|
q = make_llnd(fi,ARRAY_REF, (yyvsp[0].ll_node), LLNULL, s);
|
|
s->type->entry.ar_decl.ranges = (yyvsp[0].ll_node);
|
|
r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
|
|
(yyval.bf_node) = get_bfnd(fi,HPF_PROCESSORS_STAT, SMNULL, r, LLNULL, LLNULL);
|
|
}
|
|
#line 10103 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 698:
|
|
#line 5190 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB s;
|
|
PTR_LLND q, r;
|
|
if(! explicit_shape) {
|
|
err("Explicit shape specification is required", 50);
|
|
/*$$ = BFNULL;*/
|
|
}
|
|
s = make_array((yyvsp[-1].hash_entry), TYNULL, (yyvsp[0].ll_node), ndim, LOCAL);
|
|
if(s->attr & PROCESSORS_BIT)
|
|
errstr( "Multiple declaration of identifier %s ", s->ident, 73);
|
|
if((s->attr & ALIGN_BIT) ||(s->attr & DISTRIBUTE_BIT) ||(s->attr & TEMPLATE_BIT) || (s->attr & DYNAMIC_BIT) ||(s->attr & SHADOW_BIT) || (s->attr & TASK_BIT) || (s->attr & DVM_POINTER_BIT) || (s->attr & INHERIT_BIT) )
|
|
errstr("Inconsistent declaration of identifier %s", s->ident, 16);
|
|
else
|
|
s->attr = s->attr | PROCESSORS_BIT;
|
|
if((yyvsp[0].ll_node)) s->attr = s->attr | DIMENSION_BIT;
|
|
q = make_llnd(fi,ARRAY_REF, (yyvsp[0].ll_node), LLNULL, s);
|
|
s->type->entry.ar_decl.ranges = (yyvsp[0].ll_node);
|
|
r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
|
|
add_to_lowLevelList(r, (yyvsp[-3].bf_node)->entry.Template.ll_ptr1);
|
|
}
|
|
#line 10127 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 699:
|
|
#line 5212 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND q,r;
|
|
q = make_llnd(fi,VAR_REF, LLNULL, LLNULL, (yyvsp[0].symbol));
|
|
r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
|
|
(yyval.bf_node) = get_bfnd(fi,DVM_INDIRECT_GROUP_DIR, SMNULL, r, LLNULL, LLNULL);
|
|
}
|
|
#line 10137 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 700:
|
|
#line 5218 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND q,r;
|
|
q = make_llnd(fi,VAR_REF, LLNULL, LLNULL, (yyvsp[0].symbol));
|
|
r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
|
|
add_to_lowLevelList(r, (yyvsp[-2].bf_node)->entry.Template.ll_ptr1);
|
|
;
|
|
}
|
|
#line 10148 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 701:
|
|
#line 5227 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.symbol) = make_local_entity((yyvsp[0].hash_entry), REF_GROUP_NAME,global_default,LOCAL);
|
|
if((yyval.symbol)->attr & INDIRECT_BIT)
|
|
errstr( "Multiple declaration of identifier %s ", (yyval.symbol)->ident, 73);
|
|
(yyval.symbol)->attr = (yyval.symbol)->attr | INDIRECT_BIT;
|
|
}
|
|
#line 10158 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 702:
|
|
#line 5235 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND q,r;
|
|
q = make_llnd(fi,VAR_REF, LLNULL, LLNULL, (yyvsp[0].symbol));
|
|
r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
|
|
(yyval.bf_node) = get_bfnd(fi,DVM_REMOTE_GROUP_DIR, SMNULL, r, LLNULL, LLNULL);
|
|
}
|
|
#line 10168 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 703:
|
|
#line 5241 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND q,r;
|
|
q = make_llnd(fi,VAR_REF, LLNULL, LLNULL, (yyvsp[0].symbol));
|
|
r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
|
|
add_to_lowLevelList(r, (yyvsp[-2].bf_node)->entry.Template.ll_ptr1);
|
|
}
|
|
#line 10178 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 704:
|
|
#line 5249 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.symbol) = make_local_entity((yyvsp[0].hash_entry), REF_GROUP_NAME,global_default,LOCAL);
|
|
if((yyval.symbol)->attr & INDIRECT_BIT)
|
|
errstr( "Inconsistent declaration of identifier %s ", (yyval.symbol)->ident, 16);
|
|
}
|
|
#line 10187 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 705:
|
|
#line 5256 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND q,r;
|
|
q = make_llnd(fi,VAR_REF, LLNULL, LLNULL, (yyvsp[0].symbol));
|
|
r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
|
|
(yyval.bf_node) = get_bfnd(fi,DVM_REDUCTION_GROUP_DIR, SMNULL, r, LLNULL, LLNULL);
|
|
}
|
|
#line 10197 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 706:
|
|
#line 5262 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND q,r;
|
|
q = make_llnd(fi,VAR_REF, LLNULL, LLNULL, (yyvsp[0].symbol));
|
|
r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
|
|
add_to_lowLevelList(r, (yyvsp[-2].bf_node)->entry.Template.ll_ptr1);
|
|
;
|
|
}
|
|
#line 10208 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 707:
|
|
#line 5271 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.symbol) = make_local_entity((yyvsp[0].hash_entry), REDUCTION_GROUP_NAME,global_default,LOCAL);}
|
|
#line 10214 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 708:
|
|
#line 5275 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND q,r;
|
|
q = make_llnd(fi,VAR_REF, LLNULL, LLNULL, (yyvsp[0].symbol));
|
|
r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
|
|
(yyval.bf_node) = get_bfnd(fi,DVM_CONSISTENT_GROUP_DIR, SMNULL, r, LLNULL, LLNULL);
|
|
}
|
|
#line 10224 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 709:
|
|
#line 5281 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND q,r;
|
|
q = make_llnd(fi,VAR_REF, LLNULL, LLNULL, (yyvsp[0].symbol));
|
|
r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
|
|
add_to_lowLevelList(r, (yyvsp[-2].bf_node)->entry.Template.ll_ptr1);
|
|
}
|
|
#line 10234 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 710:
|
|
#line 5289 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.symbol) = make_local_entity((yyvsp[0].hash_entry), CONSISTENT_GROUP_NAME,global_default,LOCAL);}
|
|
#line 10240 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 711:
|
|
#line 5303 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB s;
|
|
if(parstate == INEXEC){
|
|
if (!(s = (yyvsp[-1].hash_entry)->id_attr))
|
|
{
|
|
s = make_array((yyvsp[-1].hash_entry), TYNULL, LLNULL, 0, LOCAL);
|
|
s->decl = SOFT;
|
|
}
|
|
} else
|
|
s = make_array((yyvsp[-1].hash_entry), TYNULL, LLNULL, 0, LOCAL);
|
|
|
|
(yyval.ll_node) = make_llnd(fi,ARRAY_REF, (yyvsp[0].ll_node), LLNULL, s);
|
|
}
|
|
#line 10257 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 712:
|
|
#line 5316 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL; opt_kwd_ = NO;}
|
|
#line 10263 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 713:
|
|
#line 5322 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND q;
|
|
if(!(yyvsp[-1].ll_node))
|
|
err("Distribution format list is omitted", 51);
|
|
/* if($6)
|
|
err("NEW_VALUE specification in DISTRIBUTE directive");*/
|
|
q = set_ll_list((yyvsp[-2].ll_node),LLNULL,EXPR_LIST);
|
|
(yyval.bf_node) = get_bfnd(fi,DVM_DISTRIBUTE_DIR,SMNULL,q,(yyvsp[-1].ll_node),(yyvsp[0].ll_node));
|
|
}
|
|
#line 10276 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 714:
|
|
#line 5338 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND q;
|
|
/* if(!$4)
|
|
{err("Distribution format is omitted", 51); errcnt--;}
|
|
*/
|
|
q = set_ll_list((yyvsp[-3].ll_node),LLNULL,EXPR_LIST);
|
|
/* r = LLNULL;
|
|
if($6){
|
|
r = set_ll_list($6,LLNULL,EXPR_LIST);
|
|
if($7) r = set_ll_list(r,$7,EXPR_LIST);
|
|
} else
|
|
if($7) r = set_ll_list(r,$7,EXPR_LIST);
|
|
*/
|
|
(yyval.bf_node) = get_bfnd(fi,DVM_REDISTRIBUTE_DIR,SMNULL,q,(yyvsp[-2].ll_node),(yyvsp[0].ll_node));}
|
|
#line 10294 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 715:
|
|
#line 5353 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
/* r = LLNULL;
|
|
if($5){
|
|
r = set_ll_list($5,LLNULL,EXPR_LIST);
|
|
if($6) r = set_ll_list(r,$6,EXPR_LIST);
|
|
} else
|
|
if($6) r = set_ll_list(r,$6,EXPR_LIST);
|
|
*/
|
|
(yyval.bf_node) = get_bfnd(fi,DVM_REDISTRIBUTE_DIR,SMNULL,(yyvsp[0].ll_node) ,(yyvsp[-5].ll_node),(yyvsp[-3].ll_node) );
|
|
}
|
|
#line 10309 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 716:
|
|
#line 5381 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 10315 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 717:
|
|
#line 5383 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 10321 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 718:
|
|
#line 5387 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 10327 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 719:
|
|
#line 5389 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 10333 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 720:
|
|
#line 5393 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB s;
|
|
|
|
if(parstate == INEXEC){
|
|
if (!(s = (yyvsp[0].hash_entry)->id_attr))
|
|
{
|
|
s = make_array((yyvsp[0].hash_entry), TYNULL, LLNULL, 0, LOCAL);
|
|
s->decl = SOFT;
|
|
}
|
|
if(s->attr & PROCESSORS_BIT)
|
|
errstr( "Illegal use of PROCESSORS name %s ", s->ident, 53);
|
|
if(s->attr & TASK_BIT)
|
|
errstr( "Illegal use of task array name %s ", s->ident, 71);
|
|
|
|
} else {
|
|
s = make_array((yyvsp[0].hash_entry), TYNULL, LLNULL, 0, LOCAL);
|
|
if(s->attr & DISTRIBUTE_BIT)
|
|
errstr( "Multiple declaration of identifier %s ", s->ident, 73);
|
|
else if( (s->attr & PROCESSORS_BIT) || (s->attr & TASK_BIT) || (s->attr & INHERIT_BIT))
|
|
errstr("Inconsistent declaration of identifier %s",s->ident, 16);
|
|
else
|
|
s->attr = s->attr | DISTRIBUTE_BIT;
|
|
}
|
|
if(s->attr & ALIGN_BIT)
|
|
errstr("A distributee may not have the ALIGN attribute:%s",s->ident, 54);
|
|
(yyval.ll_node) = make_llnd(fi,ARRAY_REF, LLNULL, LLNULL, s);
|
|
}
|
|
#line 10364 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 721:
|
|
#line 5422 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB s;
|
|
s = make_array((yyvsp[-3].hash_entry), TYNULL, LLNULL, 0, LOCAL);
|
|
|
|
if(parstate != INEXEC)
|
|
errstr( "Illegal distributee:%s", s->ident, 312);
|
|
else {
|
|
if(s->attr & PROCESSORS_BIT)
|
|
errstr( "Illegal use of PROCESSORS name %s ", s->ident, 53);
|
|
if(s->attr & TASK_BIT)
|
|
errstr( "Illegal use of task array name %s ", s->ident, 71);
|
|
if(s->attr & ALIGN_BIT)
|
|
errstr("A distributee may not have the ALIGN attribute:%s",s->ident, 54);
|
|
if(!(s->attr & DVM_POINTER_BIT))
|
|
errstr("Illegal distributee:%s", s->ident, 312);
|
|
/*s->attr = s->attr | DISTRIBUTE_BIT;*/
|
|
(yyval.ll_node) = make_llnd(fi,ARRAY_REF, (yyvsp[-1].ll_node), LLNULL, s);
|
|
}
|
|
|
|
}
|
|
#line 10388 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 722:
|
|
#line 5445 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB s;
|
|
if((s=(yyvsp[0].hash_entry)->id_attr) == SMNULL)
|
|
s = make_array((yyvsp[0].hash_entry), TYNULL, LLNULL, 0, LOCAL);
|
|
if((parstate == INEXEC) && !(s->attr & PROCESSORS_BIT))
|
|
errstr( "'%s' is not processor array ", s->ident, 67);
|
|
(yyval.symbol) = s;
|
|
}
|
|
#line 10400 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 723:
|
|
#line 5465 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL; }
|
|
#line 10406 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 724:
|
|
#line 5467 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[-1].ll_node);}
|
|
#line 10412 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 725:
|
|
#line 5471 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[-1].ll_node);}
|
|
#line 10418 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 726:
|
|
#line 5492 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 10424 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 727:
|
|
#line 5494 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-3].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 10430 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 728:
|
|
#line 5497 "gram1.y" /* yacc.c:1646 */
|
|
{ opt_kwd_ = YES; }
|
|
#line 10436 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 729:
|
|
#line 5506 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,BLOCK_OP, LLNULL, LLNULL, SMNULL);
|
|
}
|
|
#line 10444 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 730:
|
|
#line 5510 "gram1.y" /* yacc.c:1646 */
|
|
{ err("Distribution format BLOCK(n) is not permitted in FDVM", 55);
|
|
(yyval.ll_node) = make_llnd(fi,BLOCK_OP, (yyvsp[-1].ll_node), LLNULL, SMNULL);
|
|
endioctl();
|
|
}
|
|
#line 10453 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 731:
|
|
#line 5515 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,BLOCK_OP, LLNULL, LLNULL, (yyvsp[-1].symbol)); }
|
|
#line 10459 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 732:
|
|
#line 5517 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,BLOCK_OP, (yyvsp[-1].ll_node), LLNULL, (yyvsp[-3].symbol)); }
|
|
#line 10465 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 733:
|
|
#line 5519 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,BLOCK_OP, LLNULL, (yyvsp[-1].ll_node), SMNULL); }
|
|
#line 10471 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 734:
|
|
#line 5521 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
|
|
(yyval.ll_node)->entry.string_val = (char *) "*";
|
|
(yyval.ll_node)->type = global_string;
|
|
}
|
|
#line 10481 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 735:
|
|
#line 5527 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,INDIRECT_OP, LLNULL, LLNULL, (yyvsp[-1].symbol)); }
|
|
#line 10487 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 736:
|
|
#line 5529 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,INDIRECT_OP, (yyvsp[-1].ll_node), LLNULL, SMNULL); }
|
|
#line 10493 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 737:
|
|
#line 5533 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB s;
|
|
s = make_array((yyvsp[0].hash_entry), TYNULL, LLNULL, 0, LOCAL);
|
|
if((s->attr & PROCESSORS_BIT) ||(s->attr & TASK_BIT) || (s->attr & TEMPLATE_BIT))
|
|
errstr("Inconsistent declaration of identifier %s", s->ident, 16);
|
|
|
|
(yyval.symbol) = s;
|
|
}
|
|
#line 10505 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 738:
|
|
#line 5543 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,DERIVED_OP, (yyvsp[-4].ll_node), (yyvsp[0].ll_node), SMNULL); }
|
|
#line 10511 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 739:
|
|
#line 5547 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 10517 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 740:
|
|
#line 5549 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 10523 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 741:
|
|
#line 5554 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 10529 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 742:
|
|
#line 5556 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,DDOT, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), SMNULL);}
|
|
#line 10535 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 743:
|
|
#line 5560 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,ARRAY_REF, LLNULL, LLNULL, (yyvsp[0].symbol));
|
|
}
|
|
#line 10543 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 744:
|
|
#line 5564 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,ARRAY_REF, (yyvsp[-1].ll_node), LLNULL, (yyvsp[-3].symbol));
|
|
}
|
|
#line 10551 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 745:
|
|
#line 5570 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
if (!((yyval.symbol) = (yyvsp[0].hash_entry)->id_attr))
|
|
{
|
|
(yyval.symbol) = make_array((yyvsp[0].hash_entry), TYNULL, LLNULL,0,LOCAL);
|
|
(yyval.symbol)->decl = SOFT;
|
|
}
|
|
}
|
|
#line 10563 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 746:
|
|
#line 5580 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 10569 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 747:
|
|
#line 5582 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 10575 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 748:
|
|
#line 5586 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 10581 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 749:
|
|
#line 5588 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 10587 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 750:
|
|
#line 5590 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyvsp[-1].ll_node)->entry.Template.ll_ptr1 = (yyvsp[0].ll_node);
|
|
(yyval.ll_node) = (yyvsp[-1].ll_node);
|
|
}
|
|
#line 10596 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 751:
|
|
#line 5597 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB s;
|
|
s = make_scalar((yyvsp[0].hash_entry),TYNULL,LOCAL);
|
|
(yyval.ll_node) = make_llnd(fi,DUMMY_REF, LLNULL, LLNULL, s);
|
|
/*$$->type = global_int;*/
|
|
}
|
|
#line 10606 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 752:
|
|
#line 5614 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL; }
|
|
#line 10612 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 753:
|
|
#line 5616 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 10618 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 754:
|
|
#line 5620 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 10624 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 755:
|
|
#line 5622 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 10630 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 756:
|
|
#line 5626 "gram1.y" /* yacc.c:1646 */
|
|
{ if((yyvsp[0].ll_node)->type->variant != T_STRING)
|
|
errstr( "Illegal type of shadow_name", 627);
|
|
(yyval.ll_node) = (yyvsp[0].ll_node);
|
|
}
|
|
#line 10639 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 757:
|
|
#line 5633 "gram1.y" /* yacc.c:1646 */
|
|
{ char *q;
|
|
nioctl = 1;
|
|
q = (yyvsp[-1].ll_node)->entry.string_val;
|
|
if((!strcmp(q,"shadow")) && ((yyvsp[0].ll_node)->variant == INT_VAL)) (yyval.ll_node) = make_llnd(fi,SPEC_PAIR, (yyvsp[-1].ll_node), (yyvsp[0].ll_node), SMNULL);
|
|
else
|
|
{ err("Illegal shadow width specification", 56);
|
|
(yyval.ll_node) = LLNULL;
|
|
}
|
|
}
|
|
#line 10653 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 758:
|
|
#line 5643 "gram1.y" /* yacc.c:1646 */
|
|
{ char *ql, *qh;
|
|
PTR_LLND p1, p2;
|
|
nioctl = 2;
|
|
ql = (yyvsp[-4].ll_node)->entry.string_val;
|
|
qh = (yyvsp[-1].ll_node)->entry.string_val;
|
|
if((!strcmp(ql,"low_shadow")) && ((yyvsp[-3].ll_node)->variant == INT_VAL) && (!strcmp(qh,"high_shadow")) && ((yyvsp[0].ll_node)->variant == INT_VAL))
|
|
{
|
|
p1 = make_llnd(fi,SPEC_PAIR, (yyvsp[-4].ll_node), (yyvsp[-3].ll_node), SMNULL);
|
|
p2 = make_llnd(fi,SPEC_PAIR, (yyvsp[-1].ll_node), (yyvsp[0].ll_node), SMNULL);
|
|
(yyval.ll_node) = make_llnd(fi,CONS, p1, p2, SMNULL);
|
|
}
|
|
else
|
|
{ err("Illegal shadow width specification", 56);
|
|
(yyval.ll_node) = LLNULL;
|
|
}
|
|
}
|
|
#line 10674 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 759:
|
|
#line 5672 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND q;
|
|
q = set_ll_list((yyvsp[-1].ll_node),LLNULL,EXPR_LIST);
|
|
(yyval.bf_node) = (yyvsp[0].bf_node);
|
|
(yyval.bf_node)->entry.Template.ll_ptr1 = q;
|
|
}
|
|
#line 10684 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 760:
|
|
#line 5687 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND q;
|
|
q = set_ll_list((yyvsp[-1].ll_node),LLNULL,EXPR_LIST);
|
|
(yyval.bf_node) = (yyvsp[0].bf_node);
|
|
(yyval.bf_node)->variant = DVM_REALIGN_DIR;
|
|
(yyval.bf_node)->entry.Template.ll_ptr1 = q;
|
|
}
|
|
#line 10695 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 761:
|
|
#line 5694 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = (yyvsp[-3].bf_node);
|
|
(yyval.bf_node)->variant = DVM_REALIGN_DIR;
|
|
(yyval.bf_node)->entry.Template.ll_ptr1 = (yyvsp[0].ll_node);
|
|
}
|
|
#line 10705 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 762:
|
|
#line 5712 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 10711 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 763:
|
|
#line 5714 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 10717 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 764:
|
|
#line 5718 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB s;
|
|
s = make_array((yyvsp[0].hash_entry), TYNULL, LLNULL, 0, LOCAL);
|
|
if((s->attr & ALIGN_BIT))
|
|
errstr( "Multiple declaration of identifier %s ", s->ident, 73);
|
|
if((s->attr & PROCESSORS_BIT) || (s->attr & TASK_BIT) || (s->attr & INHERIT_BIT))
|
|
errstr( "Inconsistent declaration of identifier %s", s->ident, 16);
|
|
else if(s->attr & DISTRIBUTE_BIT)
|
|
errstr( "An alignee may not have the DISTRIBUTE attribute:'%s'", s->ident,57); else
|
|
s->attr = s->attr | ALIGN_BIT;
|
|
(yyval.ll_node) = make_llnd(fi,ARRAY_REF, LLNULL, LLNULL, s);
|
|
}
|
|
#line 10733 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 765:
|
|
#line 5732 "gram1.y" /* yacc.c:1646 */
|
|
{PTR_SYMB s;
|
|
s = (yyvsp[0].ll_node)->entry.Template.symbol;
|
|
if(s->attr & PROCESSORS_BIT)
|
|
errstr( "Illegal use of PROCESSORS name %s ", s->ident, 53);
|
|
else if(s->attr & TASK_BIT)
|
|
errstr( "Illegal use of task array name %s ", s->ident, 71);
|
|
else if( !(s->attr & DIMENSION_BIT) && !(s->attr & DVM_POINTER_BIT))
|
|
errstr("The alignee %s isn't an array", s->ident, 58);
|
|
else {
|
|
/* if(!(s->attr & DYNAMIC_BIT))
|
|
errstr("'%s' hasn't the DYNAMIC attribute", s->ident, 59);
|
|
*/
|
|
if(!(s->attr & ALIGN_BIT) && !(s->attr & INHERIT_BIT))
|
|
errstr("'%s' hasn't the ALIGN attribute", s->ident, 60);
|
|
if(s->attr & DISTRIBUTE_BIT)
|
|
errstr("An alignee may not have the DISTRIBUTE attribute: %s", s->ident, 57);
|
|
|
|
/* if(s->entry.var_decl.local == IO)
|
|
* errstr("An alignee may not be the dummy argument");
|
|
*/
|
|
}
|
|
(yyval.ll_node) = make_llnd(fi,ARRAY_REF, LLNULL, LLNULL, s);
|
|
}
|
|
#line 10761 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 766:
|
|
#line 5758 "gram1.y" /* yacc.c:1646 */
|
|
{ /* PTR_LLND r;
|
|
if($7) {
|
|
r = set_ll_list($6,LLNULL,EXPR_LIST);
|
|
r = set_ll_list(r,$7,EXPR_LIST);
|
|
}
|
|
else
|
|
r = $6;
|
|
*/
|
|
(yyval.bf_node) = get_bfnd(fi,DVM_ALIGN_DIR,SMNULL,LLNULL,(yyvsp[-4].ll_node),(yyvsp[0].ll_node));
|
|
}
|
|
#line 10776 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 767:
|
|
#line 5771 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,ARRAY_REF, (yyvsp[-1].ll_node), LLNULL, (yyvsp[-3].symbol));
|
|
}
|
|
#line 10784 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 768:
|
|
#line 5787 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 10790 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 769:
|
|
#line 5789 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 10796 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 770:
|
|
#line 5792 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 10802 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 771:
|
|
#line 5794 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
|
|
(yyval.ll_node)->entry.string_val = (char *) "*";
|
|
(yyval.ll_node)->type = global_string;
|
|
}
|
|
#line 10812 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 772:
|
|
#line 5800 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 10818 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 773:
|
|
#line 5804 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
/* if(parstate == INEXEC){ *for REALIGN directive*
|
|
if (!($$ = $1->id_attr))
|
|
{
|
|
$$ = make_array($1, TYNULL, LLNULL,0,LOCAL);
|
|
$$->decl = SOFT;
|
|
}
|
|
} else
|
|
$$ = make_array($1, TYNULL, LLNULL, 0, LOCAL);
|
|
*/
|
|
if (!((yyval.symbol) = (yyvsp[0].hash_entry)->id_attr))
|
|
{
|
|
(yyval.symbol) = make_array((yyvsp[0].hash_entry), TYNULL, LLNULL,0,LOCAL);
|
|
(yyval.symbol)->decl = SOFT;
|
|
}
|
|
(yyval.symbol)->attr = (yyval.symbol)->attr | ALIGN_BASE_BIT;
|
|
if((yyval.symbol)->attr & PROCESSORS_BIT)
|
|
errstr( "Illegal use of PROCESSORS name %s ", (yyval.symbol)->ident, 53);
|
|
else if((yyval.symbol)->attr & TASK_BIT)
|
|
errstr( "Illegal use of task array name %s ", (yyval.symbol)->ident, 71);
|
|
else
|
|
if((parstate == INEXEC) /* for REALIGN directive */
|
|
&& !((yyval.symbol)->attr & DIMENSION_BIT) && !((yyval.symbol)->attr & DVM_POINTER_BIT))
|
|
errstr("The align-target %s isn't declared as array", (yyval.symbol)->ident, 61);
|
|
}
|
|
#line 10848 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 774:
|
|
#line 5832 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 10854 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 775:
|
|
#line 5834 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 10860 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 776:
|
|
#line 5838 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB s;
|
|
s = make_scalar((yyvsp[0].hash_entry),TYNULL,LOCAL);
|
|
if(s->type->variant != T_INT || s->attr & PARAMETER_BIT)
|
|
errstr("The align-dummy %s isn't a scalar integer variable", s->ident, 62);
|
|
(yyval.ll_node) = make_llnd(fi,VAR_REF, LLNULL, LLNULL, s);
|
|
(yyval.ll_node)->type = global_int;
|
|
}
|
|
#line 10872 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 777:
|
|
#line 5846 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
|
|
(yyval.ll_node)->entry.string_val = (char *) "*";
|
|
(yyval.ll_node)->type = global_string;
|
|
}
|
|
#line 10882 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 778:
|
|
#line 5852 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,DDOT, LLNULL, LLNULL, SMNULL); }
|
|
#line 10888 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 779:
|
|
#line 5855 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB s;
|
|
PTR_LLND q, r, p;
|
|
int numdim;
|
|
if(type_options & PROCESSORS_BIT) { /* 27.06.18 || (type_options & TEMPLATE_BIT)){ */
|
|
if(! explicit_shape) {
|
|
err("Explicit shape specification is required", 50);
|
|
/*$$ = BFNULL;*/
|
|
}
|
|
}
|
|
|
|
/* else {
|
|
if($6)
|
|
err("Shape specification is not permitted", 263);
|
|
} */
|
|
|
|
if(type_options & DIMENSION_BIT)
|
|
{ p = attr_dims; numdim = attr_ndim;}
|
|
else
|
|
{ p = LLNULL; numdim = 0; }
|
|
if((yyvsp[0].ll_node)) /*dimension information after the object name*/
|
|
{ p = (yyvsp[0].ll_node); numdim = ndim;} /*overrides the DIMENSION attribute */
|
|
s = make_array((yyvsp[-1].hash_entry), TYNULL, p, numdim, LOCAL);
|
|
|
|
if((type_options & COMMON_BIT) && !(type_options & TEMPLATE_BIT))
|
|
{
|
|
err("Illegal combination of attributes", 63);
|
|
type_options = type_options & (~COMMON_BIT);
|
|
}
|
|
if((type_options & PROCESSORS_BIT) &&((type_options & ALIGN_BIT) ||(type_options & DISTRIBUTE_BIT) ||(type_options & TEMPLATE_BIT) || (type_options & DYNAMIC_BIT) ||(type_options & SHADOW_BIT) ))
|
|
err("Illegal combination of attributes", 63);
|
|
else if((type_options & PROCESSORS_BIT) && ((s->attr & ALIGN_BIT) ||(s->attr & DISTRIBUTE_BIT) ||(s->attr & TEMPLATE_BIT) || (s->attr & DYNAMIC_BIT) ||(s->attr & SHADOW_BIT)) )
|
|
{ errstr("Inconsistent declaration of %s", s->ident, 16);
|
|
type_options = type_options & (~PROCESSORS_BIT);
|
|
}
|
|
else if ((s->attr & PROCESSORS_BIT) && ((type_options & ALIGN_BIT) ||(type_options & DISTRIBUTE_BIT) ||(type_options & TEMPLATE_BIT) || (type_options & DYNAMIC_BIT) ||(type_options & SHADOW_BIT)))
|
|
errstr("Inconsistent declaration of %s", s->ident, 16);
|
|
else if ((s->attr & INHERIT_BIT) && ((type_options & ALIGN_BIT) ||(type_options & DISTRIBUTE_BIT)))
|
|
errstr("Inconsistent declaration of %s", s->ident, 16);
|
|
if(( s->attr & DISTRIBUTE_BIT) && (type_options & DISTRIBUTE_BIT))
|
|
errstr( "Multiple declaration of identifier %s ", s->ident, 73);
|
|
if(( s->attr & ALIGN_BIT) && (type_options & ALIGN_BIT))
|
|
errstr( "Multiple declaration of identifier %s ", s->ident, 73);
|
|
if(( s->attr & SHADOW_BIT) && (type_options & SHADOW_BIT))
|
|
errstr( "Multiple declaration of identifier %s ", s->ident, 73);
|
|
if(( s->attr & TEMPLATE_BIT) && (type_options & TEMPLATE_BIT))
|
|
errstr( "Multiple declaration of identifier %s ", s->ident, 73);
|
|
if(( s->attr & PROCESSORS_BIT) && (type_options & PROCESSORS_BIT))
|
|
errstr( "Multiple declaration of identifier %s ", s->ident, 73);
|
|
s->attr = s->attr | type_options;
|
|
if((yyvsp[0].ll_node)) s->attr = s->attr | DIMENSION_BIT;
|
|
if((s->attr & DISTRIBUTE_BIT) && (s->attr & ALIGN_BIT))
|
|
errstr("%s has the DISTRIBUTE and ALIGN attribute",s->ident, 64);
|
|
q = make_llnd(fi,ARRAY_REF, (yyvsp[0].ll_node), LLNULL, s);
|
|
if(p) s->type->entry.ar_decl.ranges = p;
|
|
r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
|
|
(yyval.bf_node) = get_bfnd(fi,DVM_VAR_DECL, SMNULL, r, LLNULL,(yyvsp[-5].ll_node));
|
|
}
|
|
#line 10950 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 780:
|
|
#line 5913 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB s;
|
|
PTR_LLND q, r, p;
|
|
int numdim;
|
|
if(type_options & PROCESSORS_BIT) { /*23.10.18 || (type_options & TEMPLATE_BIT)){ */
|
|
if(! explicit_shape) {
|
|
err("Explicit shape specification is required", 50);
|
|
/*$$ = BFNULL;*/
|
|
}
|
|
}
|
|
/* else {
|
|
if($4)
|
|
err("Shape specification is not permitted", 263);
|
|
} */
|
|
if(type_options & DIMENSION_BIT)
|
|
{ p = attr_dims; numdim = attr_ndim;}
|
|
else
|
|
{ p = LLNULL; numdim = 0; }
|
|
if((yyvsp[0].ll_node)) /*dimension information after the object name*/
|
|
{ p = (yyvsp[0].ll_node); numdim = ndim;}/*overrides the DIMENSION attribute */
|
|
s = make_array((yyvsp[-1].hash_entry), TYNULL, p, numdim, LOCAL);
|
|
|
|
if((type_options & COMMON_BIT) && !(type_options & TEMPLATE_BIT))
|
|
{
|
|
err("Illegal combination of attributes", 63);
|
|
type_options = type_options & (~COMMON_BIT);
|
|
}
|
|
if((type_options & PROCESSORS_BIT) &&((type_options & ALIGN_BIT) ||(type_options & DISTRIBUTE_BIT) ||(type_options & TEMPLATE_BIT) || (type_options & DYNAMIC_BIT) ||(type_options & SHADOW_BIT) ))
|
|
err("Illegal combination of attributes", 63);
|
|
else if((type_options & PROCESSORS_BIT) && ((s->attr & ALIGN_BIT) ||(s->attr & DISTRIBUTE_BIT) ||(s->attr & TEMPLATE_BIT) || (s->attr & DYNAMIC_BIT) ||(s->attr & SHADOW_BIT)) )
|
|
{ errstr("Inconsistent declaration of identifier %s", s->ident, 16);
|
|
type_options = type_options & (~PROCESSORS_BIT);
|
|
}
|
|
else if ((s->attr & PROCESSORS_BIT) && ((type_options & ALIGN_BIT) ||(type_options & DISTRIBUTE_BIT) ||(type_options & TEMPLATE_BIT) || (type_options & DYNAMIC_BIT) ||(type_options & SHADOW_BIT)))
|
|
errstr("Inconsistent declaration of identifier %s", s->ident,16);
|
|
else if ((s->attr & INHERIT_BIT) && ((type_options & ALIGN_BIT) ||(type_options & DISTRIBUTE_BIT)))
|
|
errstr("Inconsistent declaration of identifier %s", s->ident, 16);
|
|
if(( s->attr & DISTRIBUTE_BIT) && (type_options & DISTRIBUTE_BIT))
|
|
errstr( "Multiple declaration of identifier %s ", s->ident, 73);
|
|
if(( s->attr & ALIGN_BIT) && (type_options & ALIGN_BIT))
|
|
errstr( "Multiple declaration of identifier %s ", s->ident, 73);
|
|
if(( s->attr & SHADOW_BIT) && (type_options & SHADOW_BIT))
|
|
errstr( "Multiple declaration of identifier %s ", s->ident, 73);
|
|
if(( s->attr & TEMPLATE_BIT) && (type_options & TEMPLATE_BIT))
|
|
errstr( "Multiple declaration of identifier %s ", s->ident, 73);
|
|
if(( s->attr & PROCESSORS_BIT) && (type_options & PROCESSORS_BIT))
|
|
errstr( "Multiple declaration of identifier %s ", s->ident, 73);
|
|
s->attr = s->attr | type_options;
|
|
if((yyvsp[0].ll_node)) s->attr = s->attr | DIMENSION_BIT;
|
|
if((s->attr & DISTRIBUTE_BIT) && (s->attr & ALIGN_BIT))
|
|
errstr("%s has the DISTRIBUTE and ALIGN attribute",s->ident, 64);
|
|
q = make_llnd(fi,ARRAY_REF, (yyvsp[0].ll_node), LLNULL, s);
|
|
if(p) s->type->entry.ar_decl.ranges = p;
|
|
r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
|
|
add_to_lowLevelList(r, (yyvsp[-3].bf_node)->entry.Template.ll_ptr1);
|
|
}
|
|
#line 11010 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 781:
|
|
#line 5977 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); type_options = type_opt; }
|
|
#line 11016 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 782:
|
|
#line 5979 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-3].ll_node),(yyvsp[0].ll_node),EXPR_LIST); type_options = type_options | type_opt;}
|
|
#line 11022 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 783:
|
|
#line 5982 "gram1.y" /* yacc.c:1646 */
|
|
{ type_opt = TEMPLATE_BIT;
|
|
(yyval.ll_node) = make_llnd(fi,TEMPLATE_OP,LLNULL,LLNULL,SMNULL);
|
|
}
|
|
#line 11030 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 784:
|
|
#line 5986 "gram1.y" /* yacc.c:1646 */
|
|
{ type_opt = PROCESSORS_BIT;
|
|
(yyval.ll_node) = make_llnd(fi,PROCESSORS_OP,LLNULL,LLNULL,SMNULL);
|
|
}
|
|
#line 11038 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 785:
|
|
#line 5990 "gram1.y" /* yacc.c:1646 */
|
|
{ type_opt = PROCESSORS_BIT;
|
|
(yyval.ll_node) = make_llnd(fi,PROCESSORS_OP,LLNULL,LLNULL,SMNULL);
|
|
}
|
|
#line 11046 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 786:
|
|
#line 5994 "gram1.y" /* yacc.c:1646 */
|
|
{ type_opt = DYNAMIC_BIT;
|
|
(yyval.ll_node) = make_llnd(fi,DYNAMIC_OP,LLNULL,LLNULL,SMNULL);
|
|
}
|
|
#line 11054 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 787:
|
|
#line 6011 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
if(! explicit_shape) {
|
|
err("Explicit shape specification is required", 50);
|
|
}
|
|
if(! (yyvsp[-1].ll_node)) {
|
|
err("No shape specification", 65);
|
|
}
|
|
type_opt = DIMENSION_BIT;
|
|
attr_ndim = ndim; attr_dims = (yyvsp[-1].ll_node);
|
|
(yyval.ll_node) = make_llnd(fi,DIMENSION_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);
|
|
}
|
|
#line 11070 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 788:
|
|
#line 6023 "gram1.y" /* yacc.c:1646 */
|
|
{ type_opt = SHADOW_BIT;
|
|
(yyval.ll_node) = make_llnd(fi,SHADOW_OP,(yyvsp[0].ll_node),LLNULL,SMNULL);
|
|
}
|
|
#line 11078 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 789:
|
|
#line 6027 "gram1.y" /* yacc.c:1646 */
|
|
{ type_opt = ALIGN_BIT;
|
|
(yyval.ll_node) = make_llnd(fi,ALIGN_OP,(yyvsp[-4].ll_node),(yyvsp[0].ll_node),SMNULL);
|
|
}
|
|
#line 11086 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 790:
|
|
#line 6031 "gram1.y" /* yacc.c:1646 */
|
|
{ type_opt = ALIGN_BIT;
|
|
(yyval.ll_node) = make_llnd(fi,ALIGN_OP,LLNULL,SMNULL,SMNULL);
|
|
}
|
|
#line 11094 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 791:
|
|
#line 6041 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
type_opt = DISTRIBUTE_BIT;
|
|
(yyval.ll_node) = make_llnd(fi,DISTRIBUTE_OP,(yyvsp[-2].ll_node),(yyvsp[0].ll_node),SMNULL);
|
|
}
|
|
#line 11103 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 792:
|
|
#line 6046 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
type_opt = DISTRIBUTE_BIT;
|
|
(yyval.ll_node) = make_llnd(fi,DISTRIBUTE_OP,LLNULL,LLNULL,SMNULL);
|
|
}
|
|
#line 11112 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 793:
|
|
#line 6051 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
type_opt = COMMON_BIT;
|
|
(yyval.ll_node) = make_llnd(fi,COMMON_OP, LLNULL, LLNULL, SMNULL);
|
|
}
|
|
#line 11121 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 794:
|
|
#line 6058 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
PTR_LLND l;
|
|
l = make_llnd(fi, TYPE_OP, LLNULL, LLNULL, SMNULL);
|
|
l->type = (yyvsp[-10].data_type);
|
|
(yyval.bf_node) = get_bfnd(fi,DVM_POINTER_DIR, SMNULL, (yyvsp[0].ll_node),(yyvsp[-4].ll_node), l);
|
|
}
|
|
#line 11132 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 795:
|
|
#line 6066 "gram1.y" /* yacc.c:1646 */
|
|
{ndim = 0;}
|
|
#line 11138 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 796:
|
|
#line 6067 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND q;
|
|
if(ndim == maxdim)
|
|
err("Too many dimensions", 43);
|
|
else if(ndim < maxdim)
|
|
q = make_llnd(fi,DDOT,LLNULL,LLNULL,SMNULL);
|
|
++ndim;
|
|
(yyval.ll_node) = set_ll_list(q, LLNULL, EXPR_LIST);
|
|
/*$$ = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);*/
|
|
/*$$->type = global_default;*/
|
|
}
|
|
#line 11153 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 797:
|
|
#line 6078 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND q;
|
|
if(ndim == maxdim)
|
|
err("Too many dimensions", 43);
|
|
else if(ndim < maxdim)
|
|
q = make_llnd(fi,DDOT,LLNULL,LLNULL,SMNULL);
|
|
++ndim;
|
|
(yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), q, EXPR_LIST);
|
|
}
|
|
#line 11166 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 798:
|
|
#line 6089 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 11172 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 799:
|
|
#line 6091 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 11178 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 800:
|
|
#line 6095 "gram1.y" /* yacc.c:1646 */
|
|
{PTR_SYMB s;
|
|
/* s = make_scalar($1,TYNULL,LOCAL);*/
|
|
s = make_array((yyvsp[0].hash_entry),TYNULL,LLNULL,0,LOCAL);
|
|
s->attr = s->attr | DVM_POINTER_BIT;
|
|
if((s->attr & PROCESSORS_BIT) || (s->attr & TASK_BIT) || (s->attr & INHERIT_BIT))
|
|
errstr( "Inconsistent declaration of identifier %s", s->ident, 16);
|
|
(yyval.ll_node) = make_llnd(fi,VAR_REF,LLNULL,LLNULL,s);
|
|
}
|
|
#line 11191 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 801:
|
|
#line 6106 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_HEAP_DIR, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL);}
|
|
#line 11197 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 802:
|
|
#line 6110 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 11203 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 803:
|
|
#line 6112 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 11209 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 804:
|
|
#line 6116 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB s;
|
|
s = make_array((yyvsp[0].hash_entry), TYNULL, LLNULL, 0, LOCAL);
|
|
s->attr = s->attr | HEAP_BIT;
|
|
if((s->attr & PROCESSORS_BIT) ||(s->attr & TASK_BIT) || (s->attr & TEMPLATE_BIT) || (s->attr & ALIGN_BIT) || (s->attr & DISTRIBUTE_BIT) || (s->attr & INHERIT_BIT) || (s->attr & DYNAMIC_BIT) || (s->attr & SHADOW_BIT) || (s->attr & DVM_POINTER_BIT))
|
|
errstr("Inconsistent declaration of identifier %s", s->ident, 16);
|
|
|
|
(yyval.ll_node) = make_llnd(fi,ARRAY_REF, LLNULL, LLNULL, s);
|
|
}
|
|
#line 11222 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 805:
|
|
#line 6127 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_CONSISTENT_DIR, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL);}
|
|
#line 11228 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 806:
|
|
#line 6131 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 11234 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 807:
|
|
#line 6133 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 11240 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 808:
|
|
#line 6137 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB s;
|
|
s = make_array((yyvsp[0].hash_entry), TYNULL, LLNULL, 0, LOCAL);
|
|
s->attr = s->attr | CONSISTENT_BIT;
|
|
if((s->attr & PROCESSORS_BIT) ||(s->attr & TASK_BIT) || (s->attr & TEMPLATE_BIT) || (s->attr & ALIGN_BIT) || (s->attr & DISTRIBUTE_BIT) || (s->attr & INHERIT_BIT) || (s->attr & DYNAMIC_BIT) || (s->attr & SHADOW_BIT) || (s->attr & DVM_POINTER_BIT))
|
|
errstr("Inconsistent declaration of identifier %s", s->ident, 16);
|
|
|
|
(yyval.ll_node) = make_llnd(fi,ARRAY_REF, LLNULL, LLNULL, s);
|
|
}
|
|
#line 11253 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 809:
|
|
#line 6149 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_ASYNCID_DIR, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL);}
|
|
#line 11259 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 810:
|
|
#line 6151 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND p;
|
|
p = make_llnd(fi,COMM_LIST, LLNULL, LLNULL, SMNULL);
|
|
(yyval.bf_node) = get_bfnd(fi,DVM_ASYNCID_DIR, SMNULL, (yyvsp[0].ll_node), p, LLNULL);
|
|
}
|
|
#line 11268 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 811:
|
|
#line 6158 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 11274 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 812:
|
|
#line 6160 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 11280 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 813:
|
|
#line 6164 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB s;
|
|
if((yyvsp[0].ll_node)){
|
|
s = make_array((yyvsp[-1].hash_entry), global_default, (yyvsp[0].ll_node), ndim, LOCAL);
|
|
s->variant = ASYNC_ID;
|
|
s->attr = s->attr | DIMENSION_BIT;
|
|
s->type->entry.ar_decl.ranges = (yyvsp[0].ll_node);
|
|
(yyval.ll_node) = make_llnd(fi,ARRAY_REF, (yyvsp[0].ll_node), LLNULL, s);
|
|
} else {
|
|
s = make_local_entity((yyvsp[-1].hash_entry), ASYNC_ID, global_default, LOCAL);
|
|
(yyval.ll_node) = make_llnd(fi,VAR_REF, LLNULL, LLNULL, s);
|
|
}
|
|
}
|
|
#line 11297 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 814:
|
|
#line 6180 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_NEW_VALUE_DIR,SMNULL, LLNULL, LLNULL,LLNULL);}
|
|
#line 11303 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 815:
|
|
#line 6190 "gram1.y" /* yacc.c:1646 */
|
|
{ if((yyvsp[-1].ll_node) && (yyvsp[-1].ll_node)->entry.Template.symbol->attr & TASK_BIT)
|
|
(yyval.bf_node) = get_bfnd(fi,DVM_PARALLEL_TASK_DIR,SMNULL,(yyvsp[-1].ll_node),(yyvsp[0].ll_node),(yyvsp[-3].ll_node));
|
|
else
|
|
(yyval.bf_node) = get_bfnd(fi,DVM_PARALLEL_ON_DIR,SMNULL,(yyvsp[-1].ll_node),(yyvsp[0].ll_node),(yyvsp[-3].ll_node));
|
|
}
|
|
#line 11313 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 816:
|
|
#line 6199 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 11319 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 817:
|
|
#line 6201 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 11325 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 818:
|
|
#line 6205 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 11331 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 819:
|
|
#line 6208 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL; opt_kwd_ = NO;}
|
|
#line 11337 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 820:
|
|
#line 6213 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
if((yyvsp[-3].ll_node)->type->variant != T_ARRAY)
|
|
errstr("'%s' isn't array", (yyvsp[-3].ll_node)->entry.Template.symbol->ident, 66);
|
|
(yyvsp[-3].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);
|
|
(yyval.ll_node) = (yyvsp[-3].ll_node);
|
|
(yyval.ll_node)->type = (yyvsp[-3].ll_node)->type->entry.ar_decl.base_type;
|
|
}
|
|
#line 11349 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 821:
|
|
#line 6223 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 11355 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 822:
|
|
#line 6225 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 11361 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 823:
|
|
#line 6229 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 11367 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 824:
|
|
#line 6231 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
|
|
(yyval.ll_node)->entry.string_val = (char *) "*";
|
|
(yyval.ll_node)->type = global_string;
|
|
}
|
|
#line 11377 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 825:
|
|
#line 6239 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL;}
|
|
#line 11383 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 826:
|
|
#line 6241 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 11389 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 827:
|
|
#line 6245 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 11395 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 828:
|
|
#line 6247 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 11401 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 840:
|
|
#line 6265 "gram1.y" /* yacc.c:1646 */
|
|
{ if((yyvsp[-3].symbol)->attr & INDIRECT_BIT)
|
|
errstr("'%s' is not remote group name", (yyvsp[-3].symbol)->ident, 68);
|
|
(yyval.ll_node) = make_llnd(fi,REMOTE_ACCESS_OP,(yyvsp[-1].ll_node),LLNULL,(yyvsp[-3].symbol));
|
|
}
|
|
#line 11410 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 841:
|
|
#line 6270 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,REMOTE_ACCESS_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 11416 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 842:
|
|
#line 6274 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,CONSISTENT_OP,(yyvsp[-1].ll_node),LLNULL,(yyvsp[-3].symbol));
|
|
}
|
|
#line 11424 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 843:
|
|
#line 6278 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,CONSISTENT_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 11430 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 844:
|
|
#line 6282 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
if(((yyval.symbol)=(yyvsp[0].hash_entry)->id_attr) == SMNULL){
|
|
errstr("'%s' is not declared as group", (yyvsp[0].hash_entry)->ident, 74);
|
|
(yyval.symbol) = make_local_entity((yyvsp[0].hash_entry),CONSISTENT_GROUP_NAME,global_default,LOCAL);
|
|
} else {
|
|
if((yyval.symbol)->variant != CONSISTENT_GROUP_NAME)
|
|
errstr("'%s' is not declared as group", (yyvsp[0].hash_entry)->ident, 74);
|
|
}
|
|
}
|
|
#line 11444 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 845:
|
|
#line 6295 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.ll_node) = make_llnd(fi,NEW_SPEC_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 11450 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 846:
|
|
#line 6299 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.ll_node) = make_llnd(fi,NEW_SPEC_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 11456 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 847:
|
|
#line 6303 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,ACC_PRIVATE_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 11462 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 848:
|
|
#line 6307 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,ACC_CUDA_BLOCK_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 11468 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 849:
|
|
#line 6310 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST);}
|
|
#line 11474 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 850:
|
|
#line 6312 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST);}
|
|
#line 11480 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 851:
|
|
#line 6314 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.ll_node) = set_ll_list((yyvsp[-4].ll_node),(yyvsp[-2].ll_node),EXPR_LIST); (yyval.ll_node) = set_ll_list((yyval.ll_node),(yyvsp[0].ll_node),EXPR_LIST);}
|
|
#line 11486 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 852:
|
|
#line 6318 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST);}
|
|
#line 11492 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 853:
|
|
#line 6320 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST);}
|
|
#line 11498 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 854:
|
|
#line 6324 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,ACC_TIE_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 11504 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 855:
|
|
#line 6328 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST);}
|
|
#line 11510 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 856:
|
|
#line 6330 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST);}
|
|
#line 11516 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 857:
|
|
#line 6334 "gram1.y" /* yacc.c:1646 */
|
|
{ if(!((yyvsp[-3].symbol)->attr & INDIRECT_BIT))
|
|
errstr("'%s' is not indirect group name", (yyvsp[-3].symbol)->ident, 313);
|
|
(yyval.ll_node) = make_llnd(fi,INDIRECT_ACCESS_OP,(yyvsp[-1].ll_node),LLNULL,(yyvsp[-3].symbol));
|
|
}
|
|
#line 11525 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 858:
|
|
#line 6339 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,INDIRECT_ACCESS_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 11531 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 859:
|
|
#line 6343 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.ll_node) = make_llnd(fi,STAGE_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 11537 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 860:
|
|
#line 6347 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.ll_node) = make_llnd(fi,ACROSS_OP,(yyvsp[0].ll_node),LLNULL,SMNULL);}
|
|
#line 11543 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 861:
|
|
#line 6349 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.ll_node) = make_llnd(fi,ACROSS_OP,(yyvsp[-1].ll_node),(yyvsp[0].ll_node),SMNULL);}
|
|
#line 11549 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 862:
|
|
#line 6353 "gram1.y" /* yacc.c:1646 */
|
|
{ if((yyvsp[-2].ll_node))
|
|
(yyval.ll_node) = make_llnd(fi,DDOT,(yyvsp[-2].ll_node),(yyvsp[-1].ll_node),SMNULL);
|
|
else
|
|
(yyval.ll_node) = (yyvsp[-1].ll_node);
|
|
}
|
|
#line 11559 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 863:
|
|
#line 6361 "gram1.y" /* yacc.c:1646 */
|
|
{ opt_in_out = YES; }
|
|
#line 11565 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 864:
|
|
#line 6365 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
|
|
(yyval.ll_node)->entry.string_val = (char *) "in";
|
|
(yyval.ll_node)->type = global_string;
|
|
}
|
|
#line 11575 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 865:
|
|
#line 6371 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
|
|
(yyval.ll_node)->entry.string_val = (char *) "out";
|
|
(yyval.ll_node)->type = global_string;
|
|
}
|
|
#line 11585 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 866:
|
|
#line 6377 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL; opt_in_out = NO;}
|
|
#line 11591 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 867:
|
|
#line 6381 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST);}
|
|
#line 11597 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 868:
|
|
#line 6383 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST);}
|
|
#line 11603 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 869:
|
|
#line 6387 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 11609 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 870:
|
|
#line 6389 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[-3].ll_node);
|
|
(yyval.ll_node)-> entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);
|
|
}
|
|
#line 11617 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 871:
|
|
#line 6393 "gram1.y" /* yacc.c:1646 */
|
|
{ /* PTR_LLND p;
|
|
p = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
|
|
p->entry.string_val = (char *) "corner";
|
|
p->type = global_string;
|
|
*/
|
|
(yyvsp[-6].ll_node)-> entry.Template.ll_ptr1 = (yyvsp[-4].ll_node);
|
|
(yyval.ll_node) = make_llnd(fi,ARRAY_OP,(yyvsp[-6].ll_node),(yyvsp[-1].ll_node),SMNULL);
|
|
}
|
|
#line 11630 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 872:
|
|
#line 6405 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST);}
|
|
#line 11636 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 873:
|
|
#line 6407 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST);}
|
|
#line 11642 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 874:
|
|
#line 6411 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,DDOT, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), SMNULL);}
|
|
#line 11648 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 875:
|
|
#line 6415 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST);}
|
|
#line 11654 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 876:
|
|
#line 6417 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST);}
|
|
#line 11660 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 877:
|
|
#line 6421 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,DDOT,(yyvsp[-4].ll_node),make_llnd(fi,DDOT,(yyvsp[-2].ll_node),(yyvsp[0].ll_node),SMNULL),SMNULL); }
|
|
#line 11666 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 878:
|
|
#line 6423 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,DDOT,(yyvsp[-2].ll_node),make_llnd(fi,DDOT,(yyvsp[0].ll_node),LLNULL,SMNULL),SMNULL); }
|
|
#line 11672 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 879:
|
|
#line 6425 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,DDOT,(yyvsp[-2].ll_node),make_llnd(fi,DDOT,LLNULL,(yyvsp[0].ll_node),SMNULL),SMNULL); }
|
|
#line 11678 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 880:
|
|
#line 6427 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,DDOT,(yyvsp[0].ll_node),LLNULL,SMNULL); }
|
|
#line 11684 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 881:
|
|
#line 6429 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,DDOT,LLNULL,make_llnd(fi,DDOT,(yyvsp[-2].ll_node),(yyvsp[0].ll_node),SMNULL),SMNULL); }
|
|
#line 11690 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 882:
|
|
#line 6431 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,DDOT,LLNULL,make_llnd(fi,DDOT,(yyvsp[0].ll_node),LLNULL,SMNULL),SMNULL); }
|
|
#line 11696 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 883:
|
|
#line 6433 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,DDOT,LLNULL,make_llnd(fi,DDOT,LLNULL,(yyvsp[0].ll_node),SMNULL),SMNULL); }
|
|
#line 11702 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 884:
|
|
#line 6437 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 11708 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 885:
|
|
#line 6441 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 11714 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 886:
|
|
#line 6445 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 11720 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 887:
|
|
#line 6449 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[-1].ll_node);}
|
|
#line 11726 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 888:
|
|
#line 6453 "gram1.y" /* yacc.c:1646 */
|
|
{PTR_LLND q;
|
|
/* q = set_ll_list($9,$6,EXPR_LIST); */
|
|
q = set_ll_list((yyvsp[-4].ll_node),LLNULL,EXPR_LIST); /*podd 11.10.01*/
|
|
q = add_to_lowLevelList((yyvsp[-1].ll_node),q); /*podd 11.10.01*/
|
|
(yyval.ll_node) = make_llnd(fi,REDUCTION_OP,q,LLNULL,SMNULL);
|
|
}
|
|
#line 11737 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 889:
|
|
#line 6460 "gram1.y" /* yacc.c:1646 */
|
|
{PTR_LLND q;
|
|
q = set_ll_list((yyvsp[-2].ll_node),LLNULL,EXPR_LIST);
|
|
(yyval.ll_node) = make_llnd(fi,REDUCTION_OP,q,LLNULL,SMNULL);
|
|
}
|
|
#line 11746 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 890:
|
|
#line 6466 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,REDUCTION_OP,(yyvsp[-1].ll_node),LLNULL,(yyvsp[-4].symbol)); }
|
|
#line 11752 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 891:
|
|
#line 6470 "gram1.y" /* yacc.c:1646 */
|
|
{ opt_kwd_r = YES; }
|
|
#line 11758 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 892:
|
|
#line 6473 "gram1.y" /* yacc.c:1646 */
|
|
{ opt_kwd_r = NO; }
|
|
#line 11764 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 893:
|
|
#line 6477 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
if(((yyval.symbol)=(yyvsp[0].hash_entry)->id_attr) == SMNULL) {
|
|
errstr("'%s' is not declared as reduction group", (yyvsp[0].hash_entry)->ident, 69);
|
|
(yyval.symbol) = make_local_entity((yyvsp[0].hash_entry),REDUCTION_GROUP_NAME,global_default,LOCAL);
|
|
} else {
|
|
if((yyval.symbol)->variant != REDUCTION_GROUP_NAME)
|
|
errstr("'%s' is not declared as reduction group", (yyvsp[0].hash_entry)->ident, 69);
|
|
}
|
|
}
|
|
#line 11778 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 894:
|
|
#line 6490 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST);}
|
|
#line 11784 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 895:
|
|
#line 6492 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.ll_node) = set_ll_list((yyvsp[-3].ll_node),(yyvsp[0].ll_node),EXPR_LIST);}
|
|
#line 11790 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 896:
|
|
#line 6496 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.ll_node) = make_llnd(fi,ARRAY_OP,(yyvsp[-3].ll_node),(yyvsp[-1].ll_node),SMNULL);}
|
|
#line 11796 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 897:
|
|
#line 6498 "gram1.y" /* yacc.c:1646 */
|
|
{(yyvsp[-3].ll_node) = set_ll_list((yyvsp[-3].ll_node),(yyvsp[-1].ll_node),EXPR_LIST);
|
|
(yyval.ll_node) = make_llnd(fi,ARRAY_OP,(yyvsp[-5].ll_node),(yyvsp[-3].ll_node),SMNULL);}
|
|
#line 11803 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 898:
|
|
#line 6503 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
|
|
(yyval.ll_node)->entry.string_val = (char *) "sum";
|
|
(yyval.ll_node)->type = global_string;
|
|
}
|
|
#line 11813 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 899:
|
|
#line 6509 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
|
|
(yyval.ll_node)->entry.string_val = (char *) "product";
|
|
(yyval.ll_node)->type = global_string;
|
|
}
|
|
#line 11823 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 900:
|
|
#line 6515 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
|
|
(yyval.ll_node)->entry.string_val = (char *) "min";
|
|
(yyval.ll_node)->type = global_string;
|
|
}
|
|
#line 11833 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 901:
|
|
#line 6521 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
|
|
(yyval.ll_node)->entry.string_val = (char *) "max";
|
|
(yyval.ll_node)->type = global_string;
|
|
}
|
|
#line 11843 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 902:
|
|
#line 6527 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
|
|
(yyval.ll_node)->entry.string_val = (char *) "or";
|
|
(yyval.ll_node)->type = global_string;
|
|
}
|
|
#line 11853 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 903:
|
|
#line 6533 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
|
|
(yyval.ll_node)->entry.string_val = (char *) "and";
|
|
(yyval.ll_node)->type = global_string;
|
|
}
|
|
#line 11863 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 904:
|
|
#line 6539 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
|
|
(yyval.ll_node)->entry.string_val = (char *) "eqv";
|
|
(yyval.ll_node)->type = global_string;
|
|
}
|
|
#line 11873 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 905:
|
|
#line 6545 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
|
|
(yyval.ll_node)->entry.string_val = (char *) "neqv";
|
|
(yyval.ll_node)->type = global_string;
|
|
}
|
|
#line 11883 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 906:
|
|
#line 6551 "gram1.y" /* yacc.c:1646 */
|
|
{ err("Illegal reduction operation name", 70);
|
|
errcnt--;
|
|
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
|
|
(yyval.ll_node)->entry.string_val = (char *) "unknown";
|
|
(yyval.ll_node)->type = global_string;
|
|
}
|
|
#line 11894 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 907:
|
|
#line 6560 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
|
|
(yyval.ll_node)->entry.string_val = (char *) "maxloc";
|
|
(yyval.ll_node)->type = global_string;
|
|
}
|
|
#line 11904 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 908:
|
|
#line 6566 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
|
|
(yyval.ll_node)->entry.string_val = (char *) "minloc";
|
|
(yyval.ll_node)->type = global_string;
|
|
}
|
|
#line 11914 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 909:
|
|
#line 6583 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SHADOW_RENEW_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 11920 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 910:
|
|
#line 6591 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SHADOW_START_OP,LLNULL,LLNULL,(yyvsp[0].symbol));}
|
|
#line 11926 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 911:
|
|
#line 6599 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SHADOW_WAIT_OP,LLNULL,LLNULL,(yyvsp[0].symbol));}
|
|
#line 11932 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 912:
|
|
#line 6601 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SHADOW_COMP_OP,LLNULL,LLNULL,SMNULL);}
|
|
#line 11938 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 913:
|
|
#line 6603 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyvsp[-4].ll_node)-> entry.Template.ll_ptr1 = (yyvsp[-2].ll_node); (yyval.ll_node) = make_llnd(fi,SHADOW_COMP_OP,(yyvsp[-4].ll_node),LLNULL,SMNULL);}
|
|
#line 11944 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 914:
|
|
#line 6607 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.symbol) = make_local_entity((yyvsp[0].hash_entry), SHADOW_GROUP_NAME,global_default,LOCAL);}
|
|
#line 11950 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 915:
|
|
#line 6611 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST);}
|
|
#line 11956 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 916:
|
|
#line 6613 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST);}
|
|
#line 11962 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 917:
|
|
#line 6617 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 11968 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 918:
|
|
#line 6619 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND p;
|
|
p = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
|
|
p->entry.string_val = (char *) "corner";
|
|
p->type = global_string;
|
|
(yyval.ll_node) = make_llnd(fi,ARRAY_OP,(yyvsp[-4].ll_node),p,SMNULL);
|
|
}
|
|
#line 11979 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 919:
|
|
#line 6627 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[-4].ll_node);
|
|
(yyval.ll_node)-> entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);
|
|
}
|
|
#line 11987 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 920:
|
|
#line 6631 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND p;
|
|
p = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
|
|
p->entry.string_val = (char *) "corner";
|
|
p->type = global_string;
|
|
(yyvsp[-8].ll_node)-> entry.Template.ll_ptr1 = (yyvsp[-5].ll_node);
|
|
(yyval.ll_node) = make_llnd(fi,ARRAY_OP,(yyvsp[-8].ll_node),p,SMNULL);
|
|
}
|
|
#line 11999 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 921:
|
|
#line 6642 "gram1.y" /* yacc.c:1646 */
|
|
{ optcorner = YES; }
|
|
#line 12005 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 922:
|
|
#line 6646 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB s;
|
|
s = (yyvsp[0].ll_node)->entry.Template.symbol;
|
|
if(s->attr & PROCESSORS_BIT)
|
|
errstr( "Illegal use of PROCESSORS name %s ", s->ident, 53);
|
|
else if(s->attr & TASK_BIT)
|
|
errstr( "Illegal use of task array name %s ", s->ident, 71);
|
|
else
|
|
if(s->type->variant != T_ARRAY)
|
|
errstr("'%s' isn't array", s->ident, 66);
|
|
else
|
|
if((!(s->attr & DISTRIBUTE_BIT)) && (!(s->attr & ALIGN_BIT)))
|
|
; /*errstr("hpf.gram: %s is not distributed array", s->ident);*/
|
|
|
|
(yyval.ll_node) = (yyvsp[0].ll_node);
|
|
}
|
|
#line 12025 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 923:
|
|
#line 6664 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 12031 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 924:
|
|
#line 6666 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 12037 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 925:
|
|
#line 6670 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_SHADOW_START_DIR,(yyvsp[0].symbol),LLNULL,LLNULL,LLNULL);}
|
|
#line 12043 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 926:
|
|
#line 6672 "gram1.y" /* yacc.c:1646 */
|
|
{errstr("Missing DVM directive prefix", 49);}
|
|
#line 12049 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 927:
|
|
#line 6676 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_SHADOW_WAIT_DIR,(yyvsp[0].symbol),LLNULL,LLNULL,LLNULL);}
|
|
#line 12055 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 928:
|
|
#line 6678 "gram1.y" /* yacc.c:1646 */
|
|
{errstr("Missing DVM directive prefix", 49);}
|
|
#line 12061 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 929:
|
|
#line 6682 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_SHADOW_GROUP_DIR,(yyvsp[-3].symbol),(yyvsp[-1].ll_node),LLNULL,LLNULL);}
|
|
#line 12067 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 930:
|
|
#line 6686 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_REDUCTION_START_DIR,(yyvsp[0].symbol),LLNULL,LLNULL,LLNULL);}
|
|
#line 12073 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 931:
|
|
#line 6690 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_REDUCTION_WAIT_DIR,(yyvsp[0].symbol),LLNULL,LLNULL,LLNULL);}
|
|
#line 12079 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 932:
|
|
#line 6699 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_CONSISTENT_START_DIR,(yyvsp[0].symbol),LLNULL,LLNULL,LLNULL);}
|
|
#line 12085 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 933:
|
|
#line 6703 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_CONSISTENT_WAIT_DIR,(yyvsp[0].symbol),LLNULL,LLNULL,LLNULL);}
|
|
#line 12091 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 934:
|
|
#line 6707 "gram1.y" /* yacc.c:1646 */
|
|
{ if(((yyvsp[-3].symbol)->attr & INDIRECT_BIT))
|
|
errstr("'%s' is not remote group name", (yyvsp[-3].symbol)->ident, 68);
|
|
(yyval.bf_node) = get_bfnd(fi,DVM_REMOTE_ACCESS_DIR,(yyvsp[-3].symbol),(yyvsp[-1].ll_node),LLNULL,LLNULL);
|
|
}
|
|
#line 12100 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 935:
|
|
#line 6712 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_REMOTE_ACCESS_DIR,SMNULL,(yyvsp[-1].ll_node),LLNULL,LLNULL);}
|
|
#line 12106 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 936:
|
|
#line 6716 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
if(((yyval.symbol)=(yyvsp[0].hash_entry)->id_attr) == SMNULL){
|
|
errstr("'%s' is not declared as group", (yyvsp[0].hash_entry)->ident, 74);
|
|
(yyval.symbol) = make_local_entity((yyvsp[0].hash_entry),REF_GROUP_NAME,global_default,LOCAL);
|
|
} else {
|
|
if((yyval.symbol)->variant != REF_GROUP_NAME)
|
|
errstr("'%s' is not declared as group", (yyvsp[0].hash_entry)->ident, 74);
|
|
}
|
|
}
|
|
#line 12120 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 937:
|
|
#line 6728 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 12126 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 938:
|
|
#line 6730 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 12132 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 939:
|
|
#line 6734 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = (yyvsp[-3].ll_node);
|
|
(yyval.ll_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);
|
|
}
|
|
#line 12141 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 940:
|
|
#line 6739 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 12147 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 941:
|
|
#line 6743 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 12153 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 942:
|
|
#line 6745 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 12159 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 943:
|
|
#line 6749 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 12165 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 944:
|
|
#line 6751 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,DDOT, LLNULL, LLNULL, SMNULL);}
|
|
#line 12171 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 945:
|
|
#line 6755 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND q;
|
|
q = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
|
|
(yyval.bf_node) = get_bfnd(fi,DVM_TASK_DIR,SMNULL,q,LLNULL,LLNULL);
|
|
}
|
|
#line 12180 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 946:
|
|
#line 6760 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND q;
|
|
q = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
|
|
add_to_lowLevelList(q, (yyvsp[-2].bf_node)->entry.Template.ll_ptr1);
|
|
}
|
|
#line 12189 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 947:
|
|
#line 6767 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
PTR_SYMB s;
|
|
s = make_array((yyvsp[-1].hash_entry), global_int, (yyvsp[0].ll_node), ndim, LOCAL);
|
|
if((yyvsp[0].ll_node)){
|
|
s->attr = s->attr | DIMENSION_BIT;
|
|
s->type->entry.ar_decl.ranges = (yyvsp[0].ll_node);
|
|
}
|
|
else
|
|
err("No dimensions in TASK directive", 75);
|
|
if(ndim > 1)
|
|
errstr("Illegal rank of '%s'", s->ident, 76);
|
|
if(s->attr & TASK_BIT)
|
|
errstr( "Multiple declaration of identifier %s ", s->ident, 73);
|
|
if((s->attr & ALIGN_BIT) ||(s->attr & DISTRIBUTE_BIT) ||(s->attr & TEMPLATE_BIT) || (s->attr & DYNAMIC_BIT) ||(s->attr & SHADOW_BIT) || (s->attr & PROCESSORS_BIT) || (s->attr & DVM_POINTER_BIT) || (s->attr & INHERIT_BIT))
|
|
errstr("Inconsistent declaration of identifier %s", s->ident, 16);
|
|
else
|
|
s->attr = s->attr | TASK_BIT;
|
|
|
|
(yyval.ll_node) = make_llnd(fi,ARRAY_REF, (yyvsp[0].ll_node), LLNULL, s);
|
|
}
|
|
#line 12214 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 948:
|
|
#line 6790 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.bf_node) = get_bfnd(fi,DVM_TASK_REGION_DIR,(yyvsp[0].symbol),LLNULL,LLNULL,LLNULL);}
|
|
#line 12220 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 949:
|
|
#line 6792 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.bf_node) = get_bfnd(fi,DVM_TASK_REGION_DIR,(yyvsp[-1].symbol),(yyvsp[0].ll_node),LLNULL,LLNULL);}
|
|
#line 12226 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 950:
|
|
#line 6794 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.bf_node) = get_bfnd(fi,DVM_TASK_REGION_DIR,(yyvsp[-1].symbol),LLNULL,(yyvsp[0].ll_node),LLNULL);}
|
|
#line 12232 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 951:
|
|
#line 6796 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.bf_node) = get_bfnd(fi,DVM_TASK_REGION_DIR,(yyvsp[-2].symbol),(yyvsp[-1].ll_node),(yyvsp[0].ll_node),LLNULL);}
|
|
#line 12238 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 952:
|
|
#line 6798 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.bf_node) = get_bfnd(fi,DVM_TASK_REGION_DIR,(yyvsp[-2].symbol),(yyvsp[0].ll_node),(yyvsp[-1].ll_node),LLNULL);}
|
|
#line 12244 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 953:
|
|
#line 6802 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB s;
|
|
if((s=(yyvsp[0].hash_entry)->id_attr) == SMNULL)
|
|
s = make_array((yyvsp[0].hash_entry), TYNULL, LLNULL, 0, LOCAL);
|
|
|
|
if(!(s->attr & TASK_BIT))
|
|
errstr("'%s' is not task array", s->ident, 77);
|
|
(yyval.symbol) = s;
|
|
}
|
|
#line 12257 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 954:
|
|
#line 6813 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_END_TASK_REGION_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
|
|
#line 12263 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 955:
|
|
#line 6817 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_SYMB s;
|
|
PTR_LLND q;
|
|
/*
|
|
s = make_array($1, TYNULL, LLNULL, 0, LOCAL);
|
|
if((parstate == INEXEC) && !(s->attr & TASK_BIT))
|
|
errstr("'%s' is not task array", s->ident, 77);
|
|
q = set_ll_list($3,LLNULL,EXPR_LIST);
|
|
$$ = make_llnd(fi,ARRAY_REF, q, LLNULL, s);
|
|
*/
|
|
|
|
s = (yyvsp[-3].symbol);
|
|
q = set_ll_list((yyvsp[-1].ll_node),LLNULL,EXPR_LIST);
|
|
(yyval.ll_node) = make_llnd(fi,ARRAY_REF, q, LLNULL, s);
|
|
}
|
|
#line 12282 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 956:
|
|
#line 6832 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND q;
|
|
q = set_ll_list((yyvsp[-1].ll_node),LLNULL,EXPR_LIST);
|
|
(yyval.ll_node) = make_llnd(fi,ARRAY_REF, q, LLNULL, (yyvsp[-3].symbol));
|
|
}
|
|
#line 12291 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 957:
|
|
#line 6839 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = get_bfnd(fi,DVM_ON_DIR,SMNULL,(yyvsp[-1].ll_node),(yyvsp[0].ll_node),LLNULL);
|
|
}
|
|
#line 12299 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 958:
|
|
#line 6845 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.ll_node) = LLNULL;}
|
|
#line 12305 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 959:
|
|
#line 6847 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 12311 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 960:
|
|
#line 6851 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.bf_node) = get_bfnd(fi,DVM_END_ON_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
|
|
#line 12317 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 961:
|
|
#line 6855 "gram1.y" /* yacc.c:1646 */
|
|
{ PTR_LLND q;
|
|
/* if(!($6->attr & PROCESSORS_BIT))
|
|
errstr("'%s' is not processor array", $6->ident, 67);
|
|
*/
|
|
q = make_llnd(fi,ARRAY_REF, (yyvsp[0].ll_node), LLNULL, (yyvsp[-1].symbol));
|
|
(yyval.bf_node) = get_bfnd(fi,DVM_MAP_DIR,SMNULL,(yyvsp[-4].ll_node),q,LLNULL);
|
|
}
|
|
#line 12329 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 962:
|
|
#line 6863 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_MAP_DIR,SMNULL,(yyvsp[-3].ll_node),LLNULL,(yyvsp[0].ll_node)); }
|
|
#line 12335 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 963:
|
|
#line 6867 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_PREFETCH_DIR,(yyvsp[0].symbol),LLNULL,LLNULL,LLNULL);}
|
|
#line 12341 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 964:
|
|
#line 6871 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_RESET_DIR,(yyvsp[0].symbol),LLNULL,LLNULL,LLNULL);}
|
|
#line 12347 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 965:
|
|
#line 6879 "gram1.y" /* yacc.c:1646 */
|
|
{ if(!((yyvsp[-3].symbol)->attr & INDIRECT_BIT))
|
|
errstr("'%s' is not indirect group name", (yyvsp[-3].symbol)->ident, 313);
|
|
(yyval.bf_node) = get_bfnd(fi,DVM_INDIRECT_ACCESS_DIR,(yyvsp[-3].symbol),(yyvsp[-1].ll_node),LLNULL,LLNULL);
|
|
}
|
|
#line 12356 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 966:
|
|
#line 6884 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_INDIRECT_ACCESS_DIR,SMNULL,(yyvsp[-1].ll_node),LLNULL,LLNULL);}
|
|
#line 12362 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 967:
|
|
#line 6898 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 12368 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 968:
|
|
#line 6900 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 12374 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 969:
|
|
#line 6904 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 12380 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 970:
|
|
#line 6906 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[-3].ll_node); (yyval.ll_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);}
|
|
#line 12386 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 971:
|
|
#line 6915 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,HPF_INDEPENDENT_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
|
|
#line 12392 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 972:
|
|
#line 6917 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,HPF_INDEPENDENT_DIR,SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL);}
|
|
#line 12398 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 973:
|
|
#line 6919 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,HPF_INDEPENDENT_DIR,SMNULL, LLNULL, (yyvsp[0].ll_node), LLNULL);}
|
|
#line 12404 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 974:
|
|
#line 6921 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,HPF_INDEPENDENT_DIR,SMNULL, (yyvsp[-1].ll_node), (yyvsp[0].ll_node),LLNULL);}
|
|
#line 12410 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 975:
|
|
#line 6957 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.ll_node) = make_llnd(fi,REDUCTION_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 12416 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 976:
|
|
#line 6961 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_ASYNCHRONOUS_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL);}
|
|
#line 12422 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 977:
|
|
#line 6965 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_ENDASYNCHRONOUS_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
|
|
#line 12428 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 978:
|
|
#line 6969 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_ASYNCWAIT_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL);}
|
|
#line 12434 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 979:
|
|
#line 6973 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
if(((yyval.symbol)=(yyvsp[0].hash_entry)->id_attr) == SMNULL) {
|
|
errstr("'%s' is not declared as ASYNCID", (yyvsp[0].hash_entry)->ident, 115);
|
|
(yyval.symbol) = make_local_entity((yyvsp[0].hash_entry),ASYNC_ID,global_default,LOCAL);
|
|
} else {
|
|
if((yyval.symbol)->variant != ASYNC_ID)
|
|
errstr("'%s' is not declared as ASYNCID", (yyvsp[0].hash_entry)->ident, 115);
|
|
}
|
|
}
|
|
#line 12448 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 980:
|
|
#line 6985 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,VAR_REF, LLNULL, LLNULL, (yyvsp[0].symbol));}
|
|
#line 12454 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 981:
|
|
#line 6987 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,ARRAY_REF, (yyvsp[-1].ll_node), LLNULL, (yyvsp[-3].symbol));}
|
|
#line 12460 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 982:
|
|
#line 6991 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_F90_DIR,SMNULL,(yyvsp[-2].ll_node),(yyvsp[0].ll_node),LLNULL);}
|
|
#line 12466 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 983:
|
|
#line 6994 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_DEBUG_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL);}
|
|
#line 12472 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 984:
|
|
#line 6996 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_DEBUG_DIR,SMNULL,(yyvsp[-3].ll_node),(yyvsp[-1].ll_node),LLNULL);}
|
|
#line 12478 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 985:
|
|
#line 7000 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST);
|
|
endioctl();
|
|
}
|
|
#line 12487 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 986:
|
|
#line 7005 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = set_ll_list((yyvsp[-3].ll_node), (yyvsp[0].ll_node), EXPR_LIST);
|
|
endioctl();
|
|
}
|
|
#line 12496 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 987:
|
|
#line 7012 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi, KEYWORD_ARG, (yyvsp[-1].ll_node), (yyvsp[0].ll_node), SMNULL); }
|
|
#line 12502 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 988:
|
|
#line 7015 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,INT_VAL, LLNULL, LLNULL, SMNULL);
|
|
(yyval.ll_node)->entry.ival = atoi(yytext);
|
|
(yyval.ll_node)->type = global_int;
|
|
}
|
|
#line 12512 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 989:
|
|
#line 7023 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_ENDDEBUG_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL);}
|
|
#line 12518 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 990:
|
|
#line 7027 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_INTERVAL_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL);}
|
|
#line 12524 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 991:
|
|
#line 7031 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL;}
|
|
#line 12530 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 992:
|
|
#line 7034 "gram1.y" /* yacc.c:1646 */
|
|
{ if((yyvsp[0].ll_node)->type->variant != T_INT)
|
|
err("Illegal interval number", 78);
|
|
(yyval.ll_node) = (yyvsp[0].ll_node);
|
|
}
|
|
#line 12539 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 993:
|
|
#line 7042 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_EXIT_INTERVAL_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL);}
|
|
#line 12545 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 994:
|
|
#line 7046 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_ENDINTERVAL_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
|
|
#line 12551 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 995:
|
|
#line 7050 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_TRACEON_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
|
|
#line 12557 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 996:
|
|
#line 7054 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_TRACEOFF_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
|
|
#line 12563 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 997:
|
|
#line 7058 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_BARRIER_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
|
|
#line 12569 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 998:
|
|
#line 7062 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_CHECK_DIR,SMNULL,(yyvsp[0].ll_node),(yyvsp[-4].ll_node),LLNULL); }
|
|
#line 12575 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 999:
|
|
#line 7066 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_IO_MODE_DIR,SMNULL,(yyvsp[-1].ll_node),LLNULL,LLNULL);}
|
|
#line 12581 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1000:
|
|
#line 7069 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 12587 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1001:
|
|
#line 7071 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 12593 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1002:
|
|
#line 7075 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,ACC_ASYNC_OP,LLNULL,LLNULL,SMNULL);}
|
|
#line 12599 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1003:
|
|
#line 7077 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,ACC_LOCAL_OP, LLNULL,LLNULL,SMNULL);}
|
|
#line 12605 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1004:
|
|
#line 7079 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,PARALLEL_OP, LLNULL,LLNULL,SMNULL);}
|
|
#line 12611 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1005:
|
|
#line 7083 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_SHADOW_ADD_DIR,SMNULL,(yyvsp[-5].ll_node),(yyvsp[-3].ll_node),(yyvsp[0].ll_node)); }
|
|
#line 12617 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1006:
|
|
#line 7087 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
if((yyvsp[-3].ll_node)->type->variant != T_ARRAY)
|
|
errstr("'%s' isn't array", (yyvsp[-3].ll_node)->entry.Template.symbol->ident, 66);
|
|
if(!((yyvsp[-3].ll_node)->entry.Template.symbol->attr & TEMPLATE_BIT))
|
|
errstr("'%s' isn't TEMPLATE", (yyvsp[-3].ll_node)->entry.Template.symbol->ident, 628);
|
|
(yyvsp[-3].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);
|
|
(yyval.ll_node) = (yyvsp[-3].ll_node);
|
|
/*$$->type = $1->type->entry.ar_decl.base_type;*/
|
|
}
|
|
#line 12631 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1007:
|
|
#line 7099 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 12637 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1008:
|
|
#line 7101 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 12643 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1009:
|
|
#line 7105 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 12649 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1010:
|
|
#line 7107 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 12655 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1011:
|
|
#line 7111 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 12661 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1012:
|
|
#line 7113 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL; opt_kwd_ = NO;}
|
|
#line 12667 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1013:
|
|
#line 7117 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_LOCALIZE_DIR,SMNULL,(yyvsp[-3].ll_node),(yyvsp[-1].ll_node),LLNULL); }
|
|
#line 12673 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1014:
|
|
#line 7121 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
if((yyvsp[0].ll_node)->type->variant != T_ARRAY)
|
|
errstr("'%s' isn't array", (yyvsp[0].ll_node)->entry.Template.symbol->ident, 66);
|
|
(yyval.ll_node) = (yyvsp[0].ll_node);
|
|
}
|
|
#line 12683 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1015:
|
|
#line 7127 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
if((yyvsp[-3].ll_node)->type->variant != T_ARRAY)
|
|
errstr("'%s' isn't array", (yyvsp[-3].ll_node)->entry.Template.symbol->ident, 66);
|
|
|
|
(yyvsp[-3].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);
|
|
(yyval.ll_node) = (yyvsp[-3].ll_node);
|
|
(yyval.ll_node)->type = (yyvsp[-3].ll_node)->type->entry.ar_decl.base_type;
|
|
}
|
|
#line 12696 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1016:
|
|
#line 7139 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 12702 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1017:
|
|
#line 7141 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 12708 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1018:
|
|
#line 7145 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 12714 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1019:
|
|
#line 7147 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,DDOT, LLNULL, LLNULL, SMNULL);}
|
|
#line 12720 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1020:
|
|
#line 7151 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
|
|
(yyval.ll_node)->entry.string_val = (char *) "*";
|
|
(yyval.ll_node)->type = global_string;
|
|
}
|
|
#line 12730 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1021:
|
|
#line 7159 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
PTR_LLND q;
|
|
if((yyvsp[0].ll_node))
|
|
q = make_llnd(fi,ARRAY_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), SMNULL);
|
|
else
|
|
q = (yyvsp[-2].ll_node);
|
|
(yyval.bf_node) = get_bfnd(fi,DVM_CP_CREATE_DIR,SMNULL,(yyvsp[-13].ll_node),(yyvsp[-8].ll_node),q);
|
|
}
|
|
#line 12743 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1022:
|
|
#line 7170 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL; }
|
|
#line 12749 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1023:
|
|
#line 7172 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi, PARALLEL_OP, LLNULL, LLNULL, SMNULL); }
|
|
#line 12755 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1024:
|
|
#line 7174 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,ACC_LOCAL_OP, LLNULL, LLNULL, SMNULL); }
|
|
#line 12761 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1025:
|
|
#line 7178 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_CP_LOAD_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL); }
|
|
#line 12767 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1026:
|
|
#line 7182 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_CP_SAVE_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL); }
|
|
#line 12773 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1027:
|
|
#line 7184 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
PTR_LLND q;
|
|
q = make_llnd(fi,ACC_ASYNC_OP,LLNULL,LLNULL,SMNULL);
|
|
(yyval.bf_node) = get_bfnd(fi,DVM_CP_SAVE_DIR,SMNULL,(yyvsp[-3].ll_node),q,LLNULL);
|
|
}
|
|
#line 12783 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1028:
|
|
#line 7192 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_CP_WAIT_DIR,SMNULL,(yyvsp[-6].ll_node),(yyvsp[-1].ll_node),LLNULL); }
|
|
#line 12789 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1029:
|
|
#line 7196 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_TEMPLATE_CREATE_DIR,SMNULL,(yyvsp[-1].ll_node),LLNULL,LLNULL); }
|
|
#line 12795 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1030:
|
|
#line 7199 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); }
|
|
#line 12801 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1031:
|
|
#line 7201 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); }
|
|
#line 12807 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1032:
|
|
#line 7205 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,DVM_TEMPLATE_DELETE_DIR,SMNULL,(yyvsp[-1].ll_node),LLNULL,LLNULL); }
|
|
#line 12813 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1060:
|
|
#line 7239 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = get_bfnd(fi,OMP_ONETHREAD_DIR,SMNULL,LLNULL,LLNULL,LLNULL);
|
|
}
|
|
#line 12821 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1061:
|
|
#line 7245 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_endparallel();
|
|
}
|
|
#line 12829 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1062:
|
|
#line 7251 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_parallel();
|
|
(yyval.bf_node)->entry.Template.ll_ptr1 = (yyvsp[0].ll_node);
|
|
opt_kwd_ = NO;
|
|
}
|
|
#line 12839 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1063:
|
|
#line 7257 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_parallel();
|
|
opt_kwd_ = NO;
|
|
}
|
|
#line 12848 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1064:
|
|
#line 7263 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node),LLNULL,EXPR_LIST);
|
|
}
|
|
#line 12856 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1065:
|
|
#line 7267 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = set_ll_list((yyvsp[-4].ll_node),(yyvsp[-1].ll_node),EXPR_LIST);
|
|
}
|
|
#line 12864 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1075:
|
|
#line 7284 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = (yyvsp[-1].ll_node);
|
|
}
|
|
#line 12872 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1076:
|
|
#line 7289 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,OMP_PRIVATE,(yyvsp[0].ll_node),LLNULL,SMNULL);
|
|
}
|
|
#line 12880 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1077:
|
|
#line 7294 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,OMP_FIRSTPRIVATE,(yyvsp[0].ll_node),LLNULL,SMNULL);
|
|
}
|
|
#line 12888 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1078:
|
|
#line 7300 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,OMP_LASTPRIVATE,(yyvsp[0].ll_node),LLNULL,SMNULL);
|
|
}
|
|
#line 12896 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1079:
|
|
#line 7306 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,OMP_COPYIN,(yyvsp[0].ll_node),LLNULL,SMNULL);
|
|
}
|
|
#line 12904 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1080:
|
|
#line 7312 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,OMP_SHARED,(yyvsp[0].ll_node),LLNULL,SMNULL);
|
|
}
|
|
#line 12912 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1081:
|
|
#line 7317 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,OMP_DEFAULT,(yyvsp[-1].ll_node),LLNULL,SMNULL);
|
|
}
|
|
#line 12920 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1082:
|
|
#line 7323 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
|
|
(yyval.ll_node)->entry.string_val = (char *) "private";
|
|
(yyval.ll_node)->type = global_string;
|
|
}
|
|
#line 12930 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1083:
|
|
#line 7329 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
|
|
(yyval.ll_node)->entry.string_val = (char *) "shared";
|
|
(yyval.ll_node)->type = global_string;
|
|
}
|
|
#line 12940 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1084:
|
|
#line 7335 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
|
|
(yyval.ll_node)->entry.string_val = (char *) "none";
|
|
(yyval.ll_node)->type = global_string;
|
|
}
|
|
#line 12950 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1085:
|
|
#line 7342 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,OMP_IF,(yyvsp[-1].ll_node),LLNULL,SMNULL);
|
|
}
|
|
#line 12958 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1086:
|
|
#line 7348 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,OMP_NUM_THREADS,(yyvsp[-1].ll_node),LLNULL,SMNULL);
|
|
}
|
|
#line 12966 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1087:
|
|
#line 7354 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
PTR_LLND q;
|
|
q = set_ll_list((yyvsp[-1].ll_node),LLNULL,EXPR_LIST);
|
|
(yyval.ll_node) = make_llnd(fi,OMP_REDUCTION,q,LLNULL,SMNULL);
|
|
}
|
|
#line 12976 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1088:
|
|
#line 7361 "gram1.y" /* yacc.c:1646 */
|
|
{(yyval.ll_node) = make_llnd(fi,DDOT,(yyvsp[-2].ll_node),(yyvsp[0].ll_node),SMNULL);}
|
|
#line 12982 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1090:
|
|
#line 7367 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
|
|
(yyval.ll_node)->entry.string_val = (char *) "+";
|
|
(yyval.ll_node)->type = global_string;
|
|
}
|
|
#line 12992 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1091:
|
|
#line 7373 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
|
|
(yyval.ll_node)->entry.string_val = (char *) "-";
|
|
(yyval.ll_node)->type = global_string;
|
|
}
|
|
#line 13002 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1092:
|
|
#line 7380 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
|
|
(yyval.ll_node)->entry.string_val = (char *) "*";
|
|
(yyval.ll_node)->type = global_string;
|
|
}
|
|
#line 13012 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1093:
|
|
#line 7386 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
|
|
(yyval.ll_node)->entry.string_val = (char *) "/";
|
|
(yyval.ll_node)->type = global_string;
|
|
}
|
|
#line 13022 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1094:
|
|
#line 7392 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
|
|
(yyval.ll_node)->entry.string_val = (char *) "min";
|
|
(yyval.ll_node)->type = global_string;
|
|
}
|
|
#line 13032 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1095:
|
|
#line 7398 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
|
|
(yyval.ll_node)->entry.string_val = (char *) "max";
|
|
(yyval.ll_node)->type = global_string;
|
|
}
|
|
#line 13042 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1096:
|
|
#line 7404 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
|
|
(yyval.ll_node)->entry.string_val = (char *) ".or.";
|
|
(yyval.ll_node)->type = global_string;
|
|
}
|
|
#line 13052 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1097:
|
|
#line 7410 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
|
|
(yyval.ll_node)->entry.string_val = (char *) ".and.";
|
|
(yyval.ll_node)->type = global_string;
|
|
}
|
|
#line 13062 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1098:
|
|
#line 7416 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
|
|
(yyval.ll_node)->entry.string_val = (char *) ".eqv.";
|
|
(yyval.ll_node)->type = global_string;
|
|
}
|
|
#line 13072 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1099:
|
|
#line 7422 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
|
|
(yyval.ll_node)->entry.string_val = (char *) ".neqv.";
|
|
(yyval.ll_node)->type = global_string;
|
|
}
|
|
#line 13082 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1100:
|
|
#line 7428 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
|
|
(yyval.ll_node)->entry.string_val = (char *) "iand";
|
|
(yyval.ll_node)->type = global_string;
|
|
}
|
|
#line 13092 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1101:
|
|
#line 7434 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
|
|
(yyval.ll_node)->entry.string_val = (char *) "ieor";
|
|
(yyval.ll_node)->type = global_string;
|
|
}
|
|
#line 13102 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1102:
|
|
#line 7440 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
|
|
(yyval.ll_node)->entry.string_val = (char *) "ior";
|
|
(yyval.ll_node)->type = global_string;
|
|
}
|
|
#line 13112 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1103:
|
|
#line 7446 "gram1.y" /* yacc.c:1646 */
|
|
{ err("Illegal reduction operation name", 70);
|
|
errcnt--;
|
|
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
|
|
(yyval.ll_node)->entry.string_val = (char *) "unknown";
|
|
(yyval.ll_node)->type = global_string;
|
|
}
|
|
#line 13123 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1104:
|
|
#line 7456 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_sections((yyvsp[0].ll_node));
|
|
opt_kwd_ = NO;
|
|
}
|
|
#line 13132 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1105:
|
|
#line 7461 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_sections(LLNULL);
|
|
opt_kwd_ = NO;
|
|
}
|
|
#line 13141 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1106:
|
|
#line 7467 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node),LLNULL,EXPR_LIST);
|
|
}
|
|
#line 13149 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1107:
|
|
#line 7471 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = set_ll_list((yyvsp[-4].ll_node),(yyvsp[-1].ll_node),EXPR_LIST);
|
|
}
|
|
#line 13157 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1112:
|
|
#line 7483 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
PTR_LLND q;
|
|
(yyval.bf_node) = make_endsections();
|
|
q = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST);
|
|
(yyval.bf_node)->entry.Template.ll_ptr1 = q;
|
|
opt_kwd_ = NO;
|
|
}
|
|
#line 13169 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1113:
|
|
#line 7491 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_endsections();
|
|
opt_kwd_ = NO;
|
|
}
|
|
#line 13178 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1114:
|
|
#line 7497 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_ompsection();
|
|
}
|
|
#line 13186 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1115:
|
|
#line 7503 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = get_bfnd(fi,OMP_DO_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL);
|
|
opt_kwd_ = NO;
|
|
}
|
|
#line 13195 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1116:
|
|
#line 7508 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = get_bfnd(fi,OMP_DO_DIR,SMNULL,LLNULL,LLNULL,LLNULL);
|
|
opt_kwd_ = NO;
|
|
}
|
|
#line 13204 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1117:
|
|
#line 7514 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
PTR_LLND q;
|
|
q = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST);
|
|
(yyval.bf_node) = get_bfnd(fi,OMP_END_DO_DIR,SMNULL,q,LLNULL,LLNULL);
|
|
opt_kwd_ = NO;
|
|
}
|
|
#line 13215 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1118:
|
|
#line 7521 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = get_bfnd(fi,OMP_END_DO_DIR,SMNULL,LLNULL,LLNULL,LLNULL);
|
|
opt_kwd_ = NO;
|
|
}
|
|
#line 13224 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1119:
|
|
#line 7527 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node),LLNULL,EXPR_LIST);
|
|
}
|
|
#line 13232 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1120:
|
|
#line 7531 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = set_ll_list((yyvsp[-4].ll_node),(yyvsp[-1].ll_node),EXPR_LIST);
|
|
}
|
|
#line 13240 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1127:
|
|
#line 7545 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
/*$$ = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
|
|
$$->entry.string_val = (char *) "ORDERED";
|
|
$$->type = global_string;*/
|
|
(yyval.ll_node) = make_llnd(fi,OMP_ORDERED,LLNULL,LLNULL,SMNULL);
|
|
}
|
|
#line 13251 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1128:
|
|
#line 7554 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,OMP_SCHEDULE,(yyvsp[-3].ll_node),(yyvsp[-1].ll_node),SMNULL);
|
|
}
|
|
#line 13259 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1129:
|
|
#line 7558 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,OMP_SCHEDULE,(yyvsp[-1].ll_node),LLNULL,SMNULL);
|
|
}
|
|
#line 13267 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1130:
|
|
#line 7564 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
|
|
(yyval.ll_node)->entry.string_val = (char *) "STATIC";
|
|
(yyval.ll_node)->type = global_string;
|
|
|
|
}
|
|
#line 13278 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1131:
|
|
#line 7571 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
|
|
(yyval.ll_node)->entry.string_val = (char *) "DYNAMIC";
|
|
(yyval.ll_node)->type = global_string;
|
|
|
|
}
|
|
#line 13289 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1132:
|
|
#line 7578 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
|
|
(yyval.ll_node)->entry.string_val = (char *) "GUIDED";
|
|
(yyval.ll_node)->type = global_string;
|
|
|
|
}
|
|
#line 13300 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1133:
|
|
#line 7585 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
|
|
(yyval.ll_node)->entry.string_val = (char *) "RUNTIME";
|
|
(yyval.ll_node)->type = global_string;
|
|
|
|
}
|
|
#line 13311 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1134:
|
|
#line 7594 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_single();
|
|
(yyval.bf_node)->entry.Template.ll_ptr1 = (yyvsp[0].ll_node);
|
|
opt_kwd_ = NO;
|
|
}
|
|
#line 13321 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1135:
|
|
#line 7600 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_single();
|
|
opt_kwd_ = NO;
|
|
}
|
|
#line 13330 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1136:
|
|
#line 7606 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node),LLNULL,EXPR_LIST);
|
|
}
|
|
#line 13338 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1137:
|
|
#line 7610 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = set_ll_list((yyvsp[-4].ll_node),(yyvsp[-1].ll_node),EXPR_LIST);
|
|
}
|
|
#line 13346 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1140:
|
|
#line 7620 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_endsingle();
|
|
(yyval.bf_node)->entry.Template.ll_ptr1 = (yyvsp[0].ll_node);
|
|
opt_kwd_ = NO;
|
|
}
|
|
#line 13356 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1141:
|
|
#line 7626 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_endsingle();
|
|
opt_kwd_ = NO;
|
|
}
|
|
#line 13365 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1142:
|
|
#line 7632 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node),LLNULL,EXPR_LIST);
|
|
}
|
|
#line 13373 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1143:
|
|
#line 7636 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = set_ll_list((yyvsp[-4].ll_node),(yyvsp[-1].ll_node),EXPR_LIST);
|
|
}
|
|
#line 13381 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1146:
|
|
#line 7647 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,OMP_COPYPRIVATE,(yyvsp[0].ll_node),LLNULL,SMNULL);
|
|
}
|
|
#line 13389 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1147:
|
|
#line 7653 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = make_llnd(fi,OMP_NOWAIT,LLNULL,LLNULL,SMNULL);
|
|
}
|
|
#line 13397 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1148:
|
|
#line 7659 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_workshare();
|
|
}
|
|
#line 13405 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1149:
|
|
#line 7664 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
PTR_LLND q;
|
|
(yyval.bf_node) = make_endworkshare();
|
|
q = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST);
|
|
(yyval.bf_node)->entry.Template.ll_ptr1 = q;
|
|
opt_kwd_ = NO;
|
|
}
|
|
#line 13417 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1150:
|
|
#line 7672 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_endworkshare();
|
|
opt_kwd_ = NO;
|
|
}
|
|
#line 13426 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1151:
|
|
#line 7678 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = get_bfnd(fi,OMP_PARALLEL_DO_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL);
|
|
opt_kwd_ = NO;
|
|
}
|
|
#line 13435 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1152:
|
|
#line 7683 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = get_bfnd(fi,OMP_PARALLEL_DO_DIR,SMNULL,LLNULL,LLNULL,LLNULL);
|
|
opt_kwd_ = NO;
|
|
}
|
|
#line 13444 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1153:
|
|
#line 7690 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node),LLNULL,EXPR_LIST);
|
|
}
|
|
#line 13452 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1154:
|
|
#line 7694 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = set_ll_list((yyvsp[-4].ll_node),(yyvsp[-1].ll_node),EXPR_LIST);
|
|
}
|
|
#line 13460 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1166:
|
|
#line 7714 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = get_bfnd(fi,OMP_END_PARALLEL_DO_DIR,SMNULL,LLNULL,LLNULL,LLNULL);
|
|
}
|
|
#line 13468 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1167:
|
|
#line 7719 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_parallelsections((yyvsp[0].ll_node));
|
|
opt_kwd_ = NO;
|
|
}
|
|
#line 13477 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1168:
|
|
#line 7724 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_parallelsections(LLNULL);
|
|
opt_kwd_ = NO;
|
|
}
|
|
#line 13486 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1169:
|
|
#line 7731 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_endparallelsections();
|
|
}
|
|
#line 13494 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1170:
|
|
#line 7736 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_parallelworkshare();
|
|
(yyval.bf_node)->entry.Template.ll_ptr1 = (yyvsp[0].ll_node);
|
|
opt_kwd_ = NO;
|
|
}
|
|
#line 13504 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1171:
|
|
#line 7742 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_parallelworkshare();
|
|
opt_kwd_ = NO;
|
|
}
|
|
#line 13513 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1172:
|
|
#line 7748 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_endparallelworkshare();
|
|
}
|
|
#line 13521 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1173:
|
|
#line 7753 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = get_bfnd(fi,OMP_THREADPRIVATE_DIR, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL);
|
|
}
|
|
#line 13529 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1174:
|
|
#line 7758 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_master();
|
|
}
|
|
#line 13537 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1175:
|
|
#line 7763 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_endmaster();
|
|
}
|
|
#line 13545 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1176:
|
|
#line 7767 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_ordered();
|
|
}
|
|
#line 13553 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1177:
|
|
#line 7772 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_endordered();
|
|
}
|
|
#line 13561 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1178:
|
|
#line 7777 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = get_bfnd(fi,OMP_BARRIER_DIR,SMNULL,LLNULL,LLNULL,LLNULL);
|
|
}
|
|
#line 13569 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1179:
|
|
#line 7781 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = get_bfnd(fi,OMP_ATOMIC_DIR,SMNULL,LLNULL,LLNULL,LLNULL);
|
|
}
|
|
#line 13577 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1180:
|
|
#line 7786 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = get_bfnd(fi,OMP_FLUSH_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL);
|
|
}
|
|
#line 13585 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1181:
|
|
#line 7790 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = get_bfnd(fi,OMP_FLUSH_DIR,SMNULL,LLNULL,LLNULL,LLNULL);
|
|
}
|
|
#line 13593 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1182:
|
|
#line 7796 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_critical();
|
|
(yyval.bf_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);
|
|
}
|
|
#line 13602 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1183:
|
|
#line 7801 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_critical();
|
|
}
|
|
#line 13610 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1184:
|
|
#line 7807 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_endcritical();
|
|
(yyval.bf_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);
|
|
}
|
|
#line 13619 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1185:
|
|
#line 7812 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = make_endcritical();
|
|
}
|
|
#line 13627 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1186:
|
|
#line 7818 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
PTR_SYMB s;
|
|
PTR_LLND l;
|
|
s = make_common((yyvsp[-3].hash_entry));
|
|
l = make_llnd(fi,VAR_REF, LLNULL, LLNULL, s);
|
|
(yyval.ll_node) = make_llnd(fi,OMP_THREADPRIVATE, l, LLNULL, SMNULL);
|
|
}
|
|
#line 13639 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1187:
|
|
#line 7828 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST);
|
|
}
|
|
#line 13647 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1188:
|
|
#line 7832 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST);
|
|
}
|
|
#line 13655 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1189:
|
|
#line 7836 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST);
|
|
}
|
|
#line 13663 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1190:
|
|
#line 7840 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST);
|
|
}
|
|
#line 13671 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1191:
|
|
#line 7845 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
operator_slash = 1;
|
|
}
|
|
#line 13679 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1192:
|
|
#line 7848 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
operator_slash = 0;
|
|
}
|
|
#line 13687 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1201:
|
|
#line 7864 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,ACC_REGION_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL);}
|
|
#line 13693 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1202:
|
|
#line 7868 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,ACC_CHECKSECTION_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
|
|
#line 13699 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1203:
|
|
#line 7872 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,ACC_GET_ACTUAL_DIR,SMNULL,(yyvsp[-1].ll_node),LLNULL,LLNULL);}
|
|
#line 13705 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1204:
|
|
#line 7874 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,ACC_GET_ACTUAL_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
|
|
#line 13711 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1205:
|
|
#line 7876 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,ACC_GET_ACTUAL_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
|
|
#line 13717 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1206:
|
|
#line 7880 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,ACC_ACTUAL_DIR,SMNULL,(yyvsp[-1].ll_node),LLNULL,LLNULL);}
|
|
#line 13723 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1207:
|
|
#line 7882 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,ACC_ACTUAL_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
|
|
#line 13729 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1208:
|
|
#line 7884 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,ACC_ACTUAL_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
|
|
#line 13735 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1209:
|
|
#line 7888 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL;}
|
|
#line 13741 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1210:
|
|
#line 7890 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
|
|
#line 13747 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1211:
|
|
#line 7894 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 13753 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1212:
|
|
#line 7896 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 13759 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1213:
|
|
#line 7900 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 13765 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1214:
|
|
#line 7903 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 13771 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1215:
|
|
#line 7906 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 13777 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1216:
|
|
#line 7911 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,ACC_INOUT_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 13783 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1217:
|
|
#line 7913 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,ACC_IN_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 13789 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1218:
|
|
#line 7915 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,ACC_OUT_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 13795 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1219:
|
|
#line 7917 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,ACC_LOCAL_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 13801 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1220:
|
|
#line 7919 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,ACC_INLOCAL_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 13807 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1221:
|
|
#line 7923 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,ACC_TARGETS_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 13813 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1222:
|
|
#line 7927 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,ACC_ASYNC_OP,LLNULL,LLNULL,SMNULL);}
|
|
#line 13819 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1223:
|
|
#line 7932 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 13825 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1224:
|
|
#line 7936 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 13831 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1225:
|
|
#line 7938 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 13837 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1226:
|
|
#line 7942 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,ACC_HOST_OP, LLNULL,LLNULL,SMNULL);}
|
|
#line 13843 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1227:
|
|
#line 7944 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,ACC_CUDA_OP, LLNULL,LLNULL,SMNULL);}
|
|
#line 13849 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1228:
|
|
#line 7948 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,ACC_END_REGION_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
|
|
#line 13855 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1229:
|
|
#line 7952 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,ACC_END_CHECKSECTION_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
|
|
#line 13861 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1230:
|
|
#line 7956 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.bf_node) = get_bfnd(fi,ACC_DECLARE_DIR, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL);
|
|
}
|
|
#line 13869 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1231:
|
|
#line 7961 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL); }
|
|
#line 13875 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1232:
|
|
#line 7963 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); }
|
|
#line 13881 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1233:
|
|
#line 7967 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
PTR_SYMB s;
|
|
s = make_scalar((yyvsp[0].hash_entry),TYNULL,LOCAL);
|
|
if((s->attr & PROCESSORS_BIT) ||(s->attr & TASK_BIT) || (s->attr & TEMPLATE_BIT) || (s->attr & ALIGN_BIT) || (s->attr & DISTRIBUTE_BIT) || (s->attr & DYNAMIC_BIT) || (s->attr & HEAP_BIT)|| (s->attr & DVM_POINTER_BIT) || (s->attr & INHERIT_BIT) ||(s->attr & SHADOW_BIT))
|
|
errstr("Inconsistent declaration of identifier %s", s->ident, 16);
|
|
(yyval.ll_node) = make_llnd(fi,VAR_REF, LLNULL, LLNULL, s);
|
|
}
|
|
#line 13893 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1234:
|
|
#line 7977 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,ACC_ROUTINE_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL);}
|
|
#line 13899 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1235:
|
|
#line 7981 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL;}
|
|
#line 13905 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1236:
|
|
#line 7983 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 13911 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1237:
|
|
#line 7987 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 13917 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1238:
|
|
#line 7989 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 13923 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1239:
|
|
#line 7993 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,ACC_PRIVATE_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 13929 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1240:
|
|
#line 7995 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
|
|
#line 13935 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1247:
|
|
#line 8006 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,SPF_ANALYSIS_DIR,SMNULL,(yyvsp[-1].ll_node),LLNULL,LLNULL);}
|
|
#line 13941 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1248:
|
|
#line 8010 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,SPF_PARALLEL_DIR,SMNULL,(yyvsp[-1].ll_node),LLNULL,LLNULL);}
|
|
#line 13947 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1249:
|
|
#line 8014 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,SPF_TRANSFORM_DIR,SMNULL,(yyvsp[-1].ll_node),LLNULL,LLNULL);}
|
|
#line 13953 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1250:
|
|
#line 8018 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,SPF_PARALLEL_REG_DIR,(yyvsp[0].symbol),LLNULL,LLNULL,LLNULL);}
|
|
#line 13959 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1251:
|
|
#line 8020 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,SPF_PARALLEL_REG_DIR,(yyvsp[-7].symbol),(yyvsp[-2].ll_node),(yyvsp[0].ll_node),LLNULL);}
|
|
#line 13965 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1252:
|
|
#line 8022 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,SPF_PARALLEL_REG_DIR,(yyvsp[-7].symbol),(yyvsp[0].ll_node),(yyvsp[-2].ll_node),LLNULL);}
|
|
#line 13971 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1253:
|
|
#line 8026 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 13977 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1254:
|
|
#line 8028 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 13983 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1255:
|
|
#line 8032 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SPF_CODE_COVERAGE_OP,LLNULL,LLNULL,SMNULL);}
|
|
#line 13989 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1256:
|
|
#line 8036 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL;}
|
|
#line 13995 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1257:
|
|
#line 8038 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[-1].ll_node);}
|
|
#line 14001 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1258:
|
|
#line 8042 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = LLNULL;}
|
|
#line 14007 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1259:
|
|
#line 8044 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = (yyvsp[-1].ll_node);}
|
|
#line 14013 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1260:
|
|
#line 8048 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,SPF_END_PARALLEL_REG_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
|
|
#line 14019 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1261:
|
|
#line 8052 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 14025 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1262:
|
|
#line 8054 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 14031 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1268:
|
|
#line 8065 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,REDUCTION_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL); }
|
|
#line 14037 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1269:
|
|
#line 8069 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,ACC_PRIVATE_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 14043 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1270:
|
|
#line 8073 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SPF_PROCESS_PRIVATE_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 14049 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1271:
|
|
#line 8077 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SPF_COVER_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 14055 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1272:
|
|
#line 8081 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SPF_PARAMETER_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 14061 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1273:
|
|
#line 8084 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); }
|
|
#line 14067 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1274:
|
|
#line 8086 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); }
|
|
#line 14073 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1275:
|
|
#line 8090 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi, ASSGN_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), SMNULL); }
|
|
#line 14079 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1276:
|
|
#line 8094 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 14085 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1277:
|
|
#line 8096 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 14091 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1281:
|
|
#line 8105 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SHADOW_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 14097 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1282:
|
|
#line 8109 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,ACROSS_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 14103 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1283:
|
|
#line 8113 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,REMOTE_ACCESS_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 14109 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1284:
|
|
#line 8117 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 14115 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1285:
|
|
#line 8119 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 14121 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1286:
|
|
#line 8123 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SPF_NOINLINE_OP,LLNULL,LLNULL,SMNULL);}
|
|
#line 14127 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1287:
|
|
#line 8125 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SPF_FISSION_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 14133 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1288:
|
|
#line 8127 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SPF_EXPAND_OP,LLNULL,LLNULL,SMNULL);}
|
|
#line 14139 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1289:
|
|
#line 8129 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SPF_EXPAND_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 14145 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1290:
|
|
#line 8132 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SPF_SHRINK_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 14151 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1291:
|
|
#line 8134 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SPF_UNROLL_OP,LLNULL,LLNULL,SMNULL);}
|
|
#line 14157 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1292:
|
|
#line 8136 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SPF_UNROLL_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 14163 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1293:
|
|
#line 8138 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SPF_MERGE_OP,LLNULL,LLNULL,SMNULL);}
|
|
#line 14169 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1294:
|
|
#line 8142 "gram1.y" /* yacc.c:1646 */
|
|
{
|
|
(yyval.ll_node) = set_ll_list((yyvsp[-4].ll_node), (yyvsp[-2].ll_node), EXPR_LIST);
|
|
(yyval.ll_node) = set_ll_list((yyval.ll_node), (yyvsp[0].ll_node), EXPR_LIST);
|
|
}
|
|
#line 14178 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1295:
|
|
#line 8149 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.symbol) = make_parallel_region((yyvsp[0].hash_entry));}
|
|
#line 14184 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1296:
|
|
#line 8153 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); }
|
|
#line 14190 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1297:
|
|
#line 8155 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); }
|
|
#line 14196 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1298:
|
|
#line 8159 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.bf_node) = get_bfnd(fi,SPF_CHECKPOINT_DIR,SMNULL,(yyvsp[-1].ll_node),LLNULL,LLNULL);}
|
|
#line 14202 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1299:
|
|
#line 8163 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 14208 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1300:
|
|
#line 8165 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 14214 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1301:
|
|
#line 8169 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SPF_TYPE_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 14220 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1302:
|
|
#line 8171 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SPF_VARLIST_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 14226 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1303:
|
|
#line 8173 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SPF_EXCEPT_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 14232 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1304:
|
|
#line 8175 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SPF_FILES_COUNT_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
|
|
#line 14238 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1305:
|
|
#line 8177 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SPF_INTERVAL_OP,(yyvsp[-3].ll_node),(yyvsp[-1].ll_node),SMNULL);}
|
|
#line 14244 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1306:
|
|
#line 8181 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
|
|
#line 14250 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1307:
|
|
#line 8183 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
|
|
#line 14256 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1308:
|
|
#line 8187 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,ACC_ASYNC_OP, LLNULL,LLNULL,SMNULL);}
|
|
#line 14262 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1309:
|
|
#line 8189 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SPF_FLEXIBLE_OP, LLNULL,LLNULL,SMNULL);}
|
|
#line 14268 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1310:
|
|
#line 8193 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SPF_TIME_OP, LLNULL,LLNULL,SMNULL);}
|
|
#line 14274 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1311:
|
|
#line 8195 "gram1.y" /* yacc.c:1646 */
|
|
{ (yyval.ll_node) = make_llnd(fi,SPF_ITER_OP, LLNULL,LLNULL,SMNULL);}
|
|
#line 14280 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
case 1312:
|
|
#line 8199 "gram1.y" /* yacc.c:1646 */
|
|
{ if(position==IN_OUTSIDE)
|
|
err("Misplaced SPF-directive",103);
|
|
}
|
|
#line 14288 "gram1.tab.c" /* yacc.c:1646 */
|
|
break;
|
|
|
|
|
|
#line 14292 "gram1.tab.c" /* yacc.c:1646 */
|
|
default: break;
|
|
}
|
|
/* User semantic actions sometimes alter yychar, and that requires
|
|
that yytoken be updated with the new translation. We take the
|
|
approach of translating immediately before every use of yytoken.
|
|
One alternative is translating here after every semantic action,
|
|
but that translation would be missed if the semantic action invokes
|
|
YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
|
|
if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
|
|
incorrect destructor might then be invoked immediately. In the
|
|
case of YYERROR or YYBACKUP, subsequent parser actions might lead
|
|
to an incorrect destructor call or verbose syntax error message
|
|
before the lookahead is translated. */
|
|
YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
|
|
|
|
YYPOPSTACK (yylen);
|
|
yylen = 0;
|
|
YY_STACK_PRINT (yyss, yyssp);
|
|
|
|
*++yyvsp = yyval;
|
|
|
|
/* Now 'shift' the result of the reduction. Determine what state
|
|
that goes to, based on the state we popped back to and the rule
|
|
number reduced by. */
|
|
|
|
yyn = yyr1[yyn];
|
|
|
|
yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
|
|
if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
|
|
yystate = yytable[yystate];
|
|
else
|
|
yystate = yydefgoto[yyn - YYNTOKENS];
|
|
|
|
goto yynewstate;
|
|
|
|
|
|
/*--------------------------------------.
|
|
| yyerrlab -- here on detecting error. |
|
|
`--------------------------------------*/
|
|
yyerrlab:
|
|
/* Make sure we have latest lookahead translation. See comments at
|
|
user semantic actions for why this is necessary. */
|
|
yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
|
|
|
|
/* If not already recovering from an error, report this error. */
|
|
if (!yyerrstatus)
|
|
{
|
|
++yynerrs;
|
|
#if ! YYERROR_VERBOSE
|
|
yyerror (YY_("syntax error"));
|
|
#else
|
|
# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
|
|
yyssp, yytoken)
|
|
{
|
|
char const *yymsgp = YY_("syntax error");
|
|
int yysyntax_error_status;
|
|
yysyntax_error_status = YYSYNTAX_ERROR;
|
|
if (yysyntax_error_status == 0)
|
|
yymsgp = yymsg;
|
|
else if (yysyntax_error_status == 1)
|
|
{
|
|
if (yymsg != yymsgbuf)
|
|
YYSTACK_FREE (yymsg);
|
|
yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
|
|
if (!yymsg)
|
|
{
|
|
yymsg = yymsgbuf;
|
|
yymsg_alloc = sizeof yymsgbuf;
|
|
yysyntax_error_status = 2;
|
|
}
|
|
else
|
|
{
|
|
yysyntax_error_status = YYSYNTAX_ERROR;
|
|
yymsgp = yymsg;
|
|
}
|
|
}
|
|
yyerror (yymsgp);
|
|
if (yysyntax_error_status == 2)
|
|
goto yyexhaustedlab;
|
|
}
|
|
# undef YYSYNTAX_ERROR
|
|
#endif
|
|
}
|
|
|
|
|
|
|
|
if (yyerrstatus == 3)
|
|
{
|
|
/* If just tried and failed to reuse lookahead token after an
|
|
error, discard it. */
|
|
|
|
if (yychar <= YYEOF)
|
|
{
|
|
/* Return failure if at end of input. */
|
|
if (yychar == YYEOF)
|
|
YYABORT;
|
|
}
|
|
else
|
|
{
|
|
yydestruct ("Error: discarding",
|
|
yytoken, &yylval);
|
|
yychar = YYEMPTY;
|
|
}
|
|
}
|
|
|
|
/* Else will try to reuse lookahead token after shifting the error
|
|
token. */
|
|
goto yyerrlab1;
|
|
|
|
|
|
/*---------------------------------------------------.
|
|
| yyerrorlab -- error raised explicitly by YYERROR. |
|
|
`---------------------------------------------------*/
|
|
yyerrorlab:
|
|
|
|
/* Pacify compilers like GCC when the user code never invokes
|
|
YYERROR and the label yyerrorlab therefore never appears in user
|
|
code. */
|
|
if (/*CONSTCOND*/ 0)
|
|
goto yyerrorlab;
|
|
|
|
/* Do not reclaim the symbols of the rule whose action triggered
|
|
this YYERROR. */
|
|
YYPOPSTACK (yylen);
|
|
yylen = 0;
|
|
YY_STACK_PRINT (yyss, yyssp);
|
|
yystate = *yyssp;
|
|
goto yyerrlab1;
|
|
|
|
|
|
/*-------------------------------------------------------------.
|
|
| yyerrlab1 -- common code for both syntax error and YYERROR. |
|
|
`-------------------------------------------------------------*/
|
|
yyerrlab1:
|
|
yyerrstatus = 3; /* Each real token shifted decrements this. */
|
|
|
|
for (;;)
|
|
{
|
|
yyn = yypact[yystate];
|
|
if (!yypact_value_is_default (yyn))
|
|
{
|
|
yyn += YYTERROR;
|
|
if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
|
|
{
|
|
yyn = yytable[yyn];
|
|
if (0 < yyn)
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Pop the current state because it cannot handle the error token. */
|
|
if (yyssp == yyss)
|
|
YYABORT;
|
|
|
|
|
|
yydestruct ("Error: popping",
|
|
yystos[yystate], yyvsp);
|
|
YYPOPSTACK (1);
|
|
yystate = *yyssp;
|
|
YY_STACK_PRINT (yyss, yyssp);
|
|
}
|
|
|
|
YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
|
|
*++yyvsp = yylval;
|
|
YY_IGNORE_MAYBE_UNINITIALIZED_END
|
|
|
|
|
|
/* Shift the error token. */
|
|
YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
|
|
|
|
yystate = yyn;
|
|
goto yynewstate;
|
|
|
|
|
|
/*-------------------------------------.
|
|
| yyacceptlab -- YYACCEPT comes here. |
|
|
`-------------------------------------*/
|
|
yyacceptlab:
|
|
yyresult = 0;
|
|
goto yyreturn;
|
|
|
|
/*-----------------------------------.
|
|
| yyabortlab -- YYABORT comes here. |
|
|
`-----------------------------------*/
|
|
yyabortlab:
|
|
yyresult = 1;
|
|
goto yyreturn;
|
|
|
|
#if !defined yyoverflow || YYERROR_VERBOSE
|
|
/*-------------------------------------------------.
|
|
| yyexhaustedlab -- memory exhaustion comes here. |
|
|
`-------------------------------------------------*/
|
|
yyexhaustedlab:
|
|
yyerror (YY_("memory exhausted"));
|
|
yyresult = 2;
|
|
/* Fall through. */
|
|
#endif
|
|
|
|
yyreturn:
|
|
if (yychar != YYEMPTY)
|
|
{
|
|
/* Make sure we have latest lookahead translation. See comments at
|
|
user semantic actions for why this is necessary. */
|
|
yytoken = YYTRANSLATE (yychar);
|
|
yydestruct ("Cleanup: discarding lookahead",
|
|
yytoken, &yylval);
|
|
}
|
|
/* Do not reclaim the symbols of the rule whose action triggered
|
|
this YYABORT or YYACCEPT. */
|
|
YYPOPSTACK (yylen);
|
|
YY_STACK_PRINT (yyss, yyssp);
|
|
while (yyssp != yyss)
|
|
{
|
|
yydestruct ("Cleanup: popping",
|
|
yystos[*yyssp], yyvsp);
|
|
YYPOPSTACK (1);
|
|
}
|
|
#ifndef yyoverflow
|
|
if (yyss != yyssa)
|
|
YYSTACK_FREE (yyss);
|
|
#endif
|
|
#if YYERROR_VERBOSE
|
|
if (yymsg != yymsgbuf)
|
|
YYSTACK_FREE (yymsg);
|
|
#endif
|
|
return yyresult;
|
|
}
|