Alexander_KS/SAPFOR
4
2
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
ab294fbeb268e10801f95dc1ca695d414eb97aa4
SAPFOR/dvm/fdvm/trunk/parser/gram1.tab.c
ALEXks ab294fbeb2 fdvm updated
2025-03-06 20:07:20 +03:00

14475 lines
561 KiB
C
Raw Blame History

/* A Bison parser, made by GNU Bison 3.0.4. */
/* Bison implementation for Yacc-like parsers in C
Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
/* As a special exception, you may create a larger work that contains
part or all of the Bison parser skeleton and distribute that work
under terms of your choice, so long as that work isn't itself a
parser generator using the skeleton or a modified version thereof
as a parser skeleton. Alternatively, if you modify or redistribute
the parser skeleton itself, you may (at your option) remove this
special exception, which will cause the skeleton and the resulting
Bison output files to be licensed under the GNU General Public
License without this special exception.
This special exception was added by the Free Software Foundation in
version 2.2 of Bison. */
/* C LALR(1) parser skeleton written by Richard Stallman, by
simplifying the original so-called "semantic" parser. */
/* All symbols defined below should begin with yy or YY, to avoid
infringing on user name space. This should be done even for local
variables, as they might otherwise be expanded by user macros.
There are some unavoidable exceptions within include files to
define necessary library symbols; they are noted "INFRINGES ON
USER NAME SPACE" below. */
/* Identify Bison output. */
#define YYBISON 1
/* Bison version. */
#define YYBISON_VERSION "3.0.4"
/* Skeleton name. */
#define YYSKELETON_NAME "yacc.c"
/* Pure parsers. */
#define YYPURE 0
/* Push parsers. */
#define YYPUSH 0
/* Pull parsers. */
#define YYPULL 1
/* Copy the first part of user declarations. */
#line 359 "gram1.y" /* yacc.c:339 */
#include <string.h>
#include "inc.h"
#include "extern.h"
#include "defines.h"
#include "fdvm.h"
#include "fm.h"
/* We may use builtin alloca */
#include "compatible.h"
#ifdef _NEEDALLOCAH_
# include <alloca.h>
#endif
#define EXTEND_NODE 2 /* move the definition to h/ files. */
extern PTR_BFND global_bfnd, pred_bfnd;
extern PTR_SYMB star_symb;
extern PTR_SYMB global_list;
extern PTR_TYPE global_bool;
extern PTR_TYPE global_int;
extern PTR_TYPE global_float;
extern PTR_TYPE global_double;
extern PTR_TYPE global_char;
extern PTR_TYPE global_string;
extern PTR_TYPE global_string_2;
extern PTR_TYPE global_complex;
extern PTR_TYPE global_dcomplex;
extern PTR_TYPE global_gate;
extern PTR_TYPE global_event;
extern PTR_TYPE global_sequence;
extern PTR_TYPE global_default;
extern PTR_LABEL thislabel;
extern PTR_CMNT comments, cur_comment;
extern PTR_BFND last_bfnd;
extern PTR_TYPE impltype[];
extern int nioctl;
extern int maxdim;
extern long yystno; /* statement label */
extern char stmtbuf[]; /* input buffer */
extern char *commentbuf; /* comments buffer from scanner */
extern PTR_BLOB head_blob;
extern PTR_BLOB cur_blob;
extern PTR_TYPE vartype; /* variable type */
extern int end_group;
extern char saveall;
extern int privateall;
extern int needkwd;
extern int implkwd;
extern int opt_kwd_hedr;
/* added for FORTRAN 90 */
extern PTR_LLND first_unresolved_call;
extern PTR_LLND last_unresolved_call;
extern int data_stat;
extern char yyquote;
extern int warn_all;
extern int statement_kind; /* kind of statement: 1 - HPF-DVM-directive, 0 - Fortran statement*/
int extend_flag = 0;
static int do_name_err;
static int ndim; /* number of dimension */
/*!!! hpf */
static int explicit_shape; /* 1 if shape specification is explicit */
/* static int varleng;*/ /* variable size */
static int lastwasbranch = NO; /* set if last stmt was a branch stmt */
static int thiswasbranch = NO; /* set if this stmt is a branch stmt */
static PTR_SYMB type_var = SMNULL;
static PTR_LLND stat_alloc = LLNULL; /* set if ALLOCATE/DEALLOCATE stmt has STAT-clause*/
/* static int subscripts_status = 0; */
static int type_options,type_opt; /* The various options used to declare a name -
RECURSIVE, POINTER, OPTIONAL etc. */
static PTR_BFND module_scope;
static int position = IN_OUTSIDE;
static int attr_ndim; /* number of dimensions in DIMENSION (array_spec)
attribute declaration */
static PTR_LLND attr_dims; /* low level representation of array_spec in
DIMENSION (array_spec) attribute declarartion. */
static int in_vec = NO; /* set if processing array constructor */
#line 147 "gram1.tab.c" /* yacc.c:339 */
# ifndef YY_NULLPTR
# if defined __cplusplus && 201103L <= __cplusplus
# define YY_NULLPTR nullptr
# else
# define YY_NULLPTR 0
# endif
# endif
/* Enabling verbose error messages. */
#ifdef YYERROR_VERBOSE
# undef YYERROR_VERBOSE
# define YYERROR_VERBOSE 1
#else
# define YYERROR_VERBOSE 0
#endif
/* In a future release of Bison, this section will be replaced
by #include "gram1.tab.h". */
#ifndef YY_YY_GRAM1_TAB_H_INCLUDED
# define YY_YY_GRAM1_TAB_H_INCLUDED
/* Debug traces. */
#ifndef YYDEBUG
# define YYDEBUG 0
#endif
#if YYDEBUG
extern int yydebug;
#endif
/* Token type. */
#ifndef YYTOKENTYPE
# define YYTOKENTYPE
enum yytokentype
{
PERCENT = 1,
AMPERSAND = 2,
ASTER = 3,
CLUSTER = 4,
COLON = 5,
COMMA = 6,
DASTER = 7,
DEFINED_OPERATOR = 8,
DOT = 9,
DQUOTE = 10,
GLOBAL_A = 11,
LEFTAB = 12,
LEFTPAR = 13,
MINUS = 14,
PLUS = 15,
POINT_TO = 16,
QUOTE = 17,
RIGHTAB = 18,
RIGHTPAR = 19,
AND = 20,
DSLASH = 21,
EQV = 22,
EQ = 23,
EQUAL = 24,
FFALSE = 25,
GE = 26,
GT = 27,
LE = 28,
LT = 29,
NE = 30,
NEQV = 31,
NOT = 32,
OR = 33,
TTRUE = 34,
SLASH = 35,
XOR = 36,
REFERENCE = 37,
AT = 38,
ACROSS = 39,
ALIGN_WITH = 40,
ALIGN = 41,
ALLOCATABLE = 42,
ALLOCATE = 43,
ARITHIF = 44,
ASSIGNMENT = 45,
ASSIGN = 46,
ASSIGNGOTO = 47,
ASYNCHRONOUS = 48,
ASYNCID = 49,
ASYNCWAIT = 50,
BACKSPACE = 51,
BAD_CCONST = 52,
BAD_SYMBOL = 53,
BARRIER = 54,
BLOCKDATA = 55,
BLOCK = 56,
BOZ_CONSTANT = 57,
BYTE = 58,
CALL = 59,
CASE = 60,
CHARACTER = 61,
CHAR_CONSTANT = 62,
CHECK = 63,
CLOSE = 64,
COMMON = 65,
COMPLEX = 66,
COMPGOTO = 67,
CONSISTENT_GROUP = 68,
CONSISTENT_SPEC = 69,
CONSISTENT_START = 70,
CONSISTENT_WAIT = 71,
CONSISTENT = 72,
CONSTRUCT_ID = 73,
CONTAINS = 74,
CONTINUE = 75,
CORNER = 76,
CYCLE = 77,
DATA = 78,
DEALLOCATE = 79,
HPF_TEMPLATE = 80,
DEBUG = 81,
DEFAULT_CASE = 82,
DEFINE = 83,
DERIVED = 84,
DIMENSION = 85,
DISTRIBUTE = 86,
DOWHILE = 87,
DOUBLEPRECISION = 88,
DOUBLECOMPLEX = 89,
DP_CONSTANT = 90,
DVM_POINTER = 91,
DYNAMIC = 92,
ELEMENTAL = 93,
ELSE = 94,
ELSEIF = 95,
ELSEWHERE = 96,
ENDASYNCHRONOUS = 97,
ENDDEBUG = 98,
ENDINTERVAL = 99,
ENDUNIT = 100,
ENDDO = 101,
ENDFILE = 102,
ENDFORALL = 103,
ENDIF = 104,
ENDINTERFACE = 105,
ENDMODULE = 106,
ENDON = 107,
ENDSELECT = 108,
ENDTASK_REGION = 109,
ENDTYPE = 110,
ENDWHERE = 111,
ENTRY = 112,
EXIT = 113,
EOLN = 114,
EQUIVALENCE = 115,
ERROR = 116,
EXTERNAL = 117,
F90 = 118,
FIND = 119,
FORALL = 120,
FORMAT = 121,
FUNCTION = 122,
GATE = 123,
GEN_BLOCK = 124,
HEAP = 125,
HIGH = 126,
IDENTIFIER = 127,
IMPLICIT = 128,
IMPLICITNONE = 129,
INCLUDE_TO = 130,
INCLUDE = 131,
INDEPENDENT = 132,
INDIRECT_ACCESS = 133,
INDIRECT_GROUP = 134,
INDIRECT = 135,
INHERIT = 136,
INQUIRE = 137,
INTERFACEASSIGNMENT = 138,
INTERFACEOPERATOR = 139,
INTERFACE = 140,
INTRINSIC = 141,
INTEGER = 142,
INTENT = 143,
INTERVAL = 144,
INOUT = 145,
IN = 146,
INT_CONSTANT = 147,
LABEL = 148,
LABEL_DECLARE = 149,
LET = 150,
LOCALIZE = 151,
LOGICAL = 152,
LOGICALIF = 153,
LOOP = 154,
LOW = 155,
MAXLOC = 156,
MAX = 157,
MAP = 158,
MINLOC = 159,
MIN = 160,
MODULE_PROCEDURE = 161,
MODULE = 162,
MULT_BLOCK = 163,
NAMEEQ = 164,
NAMELIST = 165,
NEW_VALUE = 166,
NEW = 167,
NULLIFY = 168,
OCTAL_CONSTANT = 169,
ONLY = 170,
ON = 171,
ON_DIR = 172,
ONTO = 173,
OPEN = 174,
OPERATOR = 175,
OPTIONAL = 176,
OTHERWISE = 177,
OUT = 178,
OWN = 179,
PARALLEL = 180,
PARAMETER = 181,
PAUSE = 182,
PLAINDO = 183,
PLAINGOTO = 184,
POINTER = 185,
POINTERLET = 186,
PREFETCH = 187,
PRINT = 188,
PRIVATE = 189,
PRODUCT = 190,
PROGRAM = 191,
PUBLIC = 192,
PURE = 193,
RANGE = 194,
READ = 195,
REALIGN_WITH = 196,
REALIGN = 197,
REAL = 198,
REAL_CONSTANT = 199,
RECURSIVE = 200,
REDISTRIBUTE_NEW = 201,
REDISTRIBUTE = 202,
REDUCTION_GROUP = 203,
REDUCTION_START = 204,
REDUCTION_WAIT = 205,
REDUCTION = 206,
REMOTE_ACCESS_SPEC = 207,
REMOTE_ACCESS = 208,
REMOTE_GROUP = 209,
RESET = 210,
RESULT = 211,
RETURN = 212,
REWIND = 213,
SAVE = 214,
SECTION = 215,
SELECT = 216,
SEQUENCE = 217,
SHADOW_ADD = 218,
SHADOW_COMPUTE = 219,
SHADOW_GROUP = 220,
SHADOW_RENEW = 221,
SHADOW_START_SPEC = 222,
SHADOW_START = 223,
SHADOW_WAIT_SPEC = 224,
SHADOW_WAIT = 225,
SHADOW = 226,
STAGE = 227,
STATIC = 228,
STAT = 229,
STOP = 230,
SUBROUTINE = 231,
SUM = 232,
SYNC = 233,
TARGET = 234,
TASK = 235,
TASK_REGION = 236,
THEN = 237,
TO = 238,
TRACEON = 239,
TRACEOFF = 240,
TRUNC = 241,
TYPE = 242,
TYPE_DECL = 243,
UNDER = 244,
UNKNOWN = 245,
USE = 246,
VIRTUAL = 247,
VARIABLE = 248,
WAIT = 249,
WHERE = 250,
WHERE_ASSIGN = 251,
WHILE = 252,
WITH = 253,
WRITE = 254,
COMMENT = 255,
WGT_BLOCK = 256,
HPF_PROCESSORS = 257,
IOSTAT = 258,
ERR = 259,
END = 260,
OMPDVM_ATOMIC = 261,
OMPDVM_BARRIER = 262,
OMPDVM_COPYIN = 263,
OMPDVM_COPYPRIVATE = 264,
OMPDVM_CRITICAL = 265,
OMPDVM_ONETHREAD = 266,
OMPDVM_DO = 267,
OMPDVM_DYNAMIC = 268,
OMPDVM_ENDCRITICAL = 269,
OMPDVM_ENDDO = 270,
OMPDVM_ENDMASTER = 271,
OMPDVM_ENDORDERED = 272,
OMPDVM_ENDPARALLEL = 273,
OMPDVM_ENDPARALLELDO = 274,
OMPDVM_ENDPARALLELSECTIONS = 275,
OMPDVM_ENDPARALLELWORKSHARE = 276,
OMPDVM_ENDSECTIONS = 277,
OMPDVM_ENDSINGLE = 278,
OMPDVM_ENDWORKSHARE = 279,
OMPDVM_FIRSTPRIVATE = 280,
OMPDVM_FLUSH = 281,
OMPDVM_GUIDED = 282,
OMPDVM_LASTPRIVATE = 283,
OMPDVM_MASTER = 284,
OMPDVM_NOWAIT = 285,
OMPDVM_NONE = 286,
OMPDVM_NUM_THREADS = 287,
OMPDVM_ORDERED = 288,
OMPDVM_PARALLEL = 289,
OMPDVM_PARALLELDO = 290,
OMPDVM_PARALLELSECTIONS = 291,
OMPDVM_PARALLELWORKSHARE = 292,
OMPDVM_RUNTIME = 293,
OMPDVM_SECTION = 294,
OMPDVM_SECTIONS = 295,
OMPDVM_SCHEDULE = 296,
OMPDVM_SHARED = 297,
OMPDVM_SINGLE = 298,
OMPDVM_THREADPRIVATE = 299,
OMPDVM_WORKSHARE = 300,
OMPDVM_NODES = 301,
OMPDVM_IF = 302,
IAND = 303,
IEOR = 304,
IOR = 305,
ACC_REGION = 306,
ACC_END_REGION = 307,
ACC_CHECKSECTION = 308,
ACC_END_CHECKSECTION = 309,
ACC_GET_ACTUAL = 310,
ACC_ACTUAL = 311,
ACC_TARGETS = 312,
ACC_ASYNC = 313,
ACC_HOST = 314,
ACC_CUDA = 315,
ACC_LOCAL = 316,
ACC_INLOCAL = 317,
ACC_CUDA_BLOCK = 318,
ACC_ROUTINE = 319,
ACC_TIE = 320,
ACC_DECLARE = 321,
BY = 322,
IO_MODE = 323,
CP_CREATE = 324,
CP_LOAD = 325,
CP_SAVE = 326,
CP_WAIT = 327,
FILES = 328,
VARLIST = 329,
STATUS = 330,
EXITINTERVAL = 331,
TEMPLATE_CREATE = 332,
TEMPLATE_DELETE = 333,
SPF_ANALYSIS = 334,
SPF_PARALLEL = 335,
SPF_TRANSFORM = 336,
SPF_NOINLINE = 337,
SPF_PARALLEL_REG = 338,
SPF_END_PARALLEL_REG = 339,
SPF_EXPAND = 340,
SPF_FISSION = 341,
SPF_SHRINK = 342,
SPF_CHECKPOINT = 343,
SPF_EXCEPT = 344,
SPF_FILES_COUNT = 345,
SPF_INTERVAL = 346,
SPF_TIME = 347,
SPF_ITER = 348,
SPF_FLEXIBLE = 349,
SPF_APPLY_REGION = 350,
SPF_APPLY_FRAGMENT = 351,
SPF_CODE_COVERAGE = 352,
SPF_UNROLL = 353,
SPF_MERGE = 354,
SPF_COVER = 355,
SPF_PROCESS_PRIVATE = 356,
SPF_WEIGHT = 357,
BINARY_OP = 360,
UNARY_OP = 361
};
#endif
/* Value type. */
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
union YYSTYPE
{
#line 440 "gram1.y" /* yacc.c:355 */
int token;
char charv;
char *charp;
PTR_BFND bf_node;
PTR_LLND ll_node;
PTR_SYMB symbol;
PTR_TYPE data_type;
PTR_HASH hash_entry;
PTR_LABEL label;
#line 561 "gram1.tab.c" /* yacc.c:355 */
};
typedef union YYSTYPE YYSTYPE;
# define YYSTYPE_IS_TRIVIAL 1
# define YYSTYPE_IS_DECLARED 1
#endif
extern YYSTYPE yylval;
int yyparse (void);
#endif /* !YY_YY_GRAM1_TAB_H_INCLUDED */
/* Copy the second part of user declarations. */
#line 650 "gram1.y" /* yacc.c:358 */
void add_scope_level();
void delete_beyond_scope_level();
PTR_HASH look_up_sym();
PTR_HASH just_look_up_sym();
PTR_HASH just_look_up_sym_in_scope();
PTR_HASH look_up_op();
PTR_SYMB make_constant();
PTR_SYMB make_scalar();
PTR_SYMB make_array();
PTR_SYMB make_pointer();
PTR_SYMB make_function();
PTR_SYMB make_external();
PTR_SYMB make_intrinsic();
PTR_SYMB make_procedure();
PTR_SYMB make_process();
PTR_SYMB make_program();
PTR_SYMB make_module();
PTR_SYMB make_common();
PTR_SYMB make_parallel_region();
PTR_SYMB make_derived_type();
PTR_SYMB make_local_entity();
PTR_SYMB make_global_entity();
PTR_TYPE make_type_node();
PTR_TYPE lookup_type(), make_type();
void process_type();
void process_interface();
void bind();
void late_bind_if_needed();
PTR_SYMB component();
PTR_SYMB lookup_type_symbol();
PTR_SYMB resolve_overloading();
PTR_BFND cur_scope();
PTR_BFND subroutine_call();
PTR_BFND process_call();
PTR_LLND deal_with_options();
PTR_LLND intrinsic_op_node();
PTR_LLND defined_op_node();
int is_substring_ref();
int is_array_section_ref();
PTR_LLND dim_expr();
PTR_BFND exit_stat();
PTR_BFND make_do();
PTR_BFND make_pardo();
PTR_BFND make_enddoall();
PTR_TYPE install_array();
PTR_SYMB install_entry();
void install_param_list();
PTR_LLND construct_entry_list();
void copy_sym_data();
PTR_LLND check_and_install();
PTR_HASH look_up();
PTR_BFND get_bfnd();
PTR_BLOB make_blob();
PTR_LABEL make_label();
PTR_LABEL make_label_node();
int is_interface_stat();
PTR_LLND make_llnd ();
PTR_LLND make_llnd_label ();
PTR_TYPE make_sa_type();
PTR_SYMB procedure_call();
PTR_BFND proc_list();
PTR_SYMB set_id_list();
PTR_LLND set_ll_list();
PTR_LLND add_to_lowLevelList(), add_to_lowList();
PTR_BFND set_stat_list() ;
PTR_BLOB follow_blob();
PTR_SYMB proc_decl_init();
PTR_CMNT make_comment();
PTR_HASH correct_symtab();
char *copyn();
char *convic();
char *StringConcatenation();
int atoi();
PTR_BFND make_logif();
PTR_BFND make_if();
PTR_BFND make_forall();
void startproc();
void match_parameters();
void make_else();
void make_elseif();
void make_endif();
void make_elsewhere();
void make_elsewhere_mask();
void make_endwhere();
void make_endforall();
void make_endselect();
void make_extend();
void make_endextend();
void make_section();
void make_section_extend();
void doinclude();
void endproc();
void err();
void execerr();
void flline();
void warn();
void warn1();
void newprog();
void set_type();
void dclerr();
void enddcl();
void install_const();
void setimpl();
void copy_module_scope();
void delete_symbol();
void replace_symbol_in_expr();
long convci();
void set_expr_type();
void errstr();
void yyerror();
void set_blobs();
void make_loop();
void startioctl();
void endioctl();
void redefine_func_arg_type();
int isResultVar();
int yylex();
/* used by FORTRAN M */
PTR_BFND make_processdo();
PTR_BFND make_processes();
PTR_BFND make_endprocesses();
PTR_BFND make_endparallel();/*OMP*/
PTR_BFND make_parallel();/*OMP*/
PTR_BFND make_endsingle();/*OMP*/
PTR_BFND make_single();/*OMP*/
PTR_BFND make_endmaster();/*OMP*/
PTR_BFND make_master();/*OMP*/
PTR_BFND make_endordered();/*OMP*/
PTR_BFND make_ordered();/*OMP*/
PTR_BFND make_endcritical();/*OMP*/
PTR_BFND make_critical();/*OMP*/
PTR_BFND make_endsections();/*OMP*/
PTR_BFND make_sections();/*OMP*/
PTR_BFND make_ompsection();/*OMP*/
PTR_BFND make_endparallelsections();/*OMP*/
PTR_BFND make_parallelsections();/*OMP*/
PTR_BFND make_endworkshare();/*OMP*/
PTR_BFND make_workshare();/*OMP*/
PTR_BFND make_endparallelworkshare();/*OMP*/
PTR_BFND make_parallelworkshare();/*OMP*/
#line 723 "gram1.tab.c" /* yacc.c:358 */
#ifdef short
# undef short
#endif
#ifdef YYTYPE_UINT8
typedef YYTYPE_UINT8 yytype_uint8;
#else
typedef unsigned char yytype_uint8;
#endif
#ifdef YYTYPE_INT8
typedef YYTYPE_INT8 yytype_int8;
#else
typedef signed char yytype_int8;
#endif
#ifdef YYTYPE_UINT16
typedef YYTYPE_UINT16 yytype_uint16;
#else
typedef unsigned short int yytype_uint16;
#endif
#ifdef YYTYPE_INT16
typedef YYTYPE_INT16 yytype_int16;
#else
typedef short int yytype_int16;
#endif
#ifndef YYSIZE_T
# ifdef __SIZE_TYPE__
# define YYSIZE_T __SIZE_TYPE__
# elif defined size_t
# define YYSIZE_T size_t
# elif ! defined YYSIZE_T
# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
# define YYSIZE_T size_t
# else
# define YYSIZE_T unsigned int
# endif
#endif
#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
#ifndef YY_
# if defined YYENABLE_NLS && YYENABLE_NLS
# if ENABLE_NLS
# include <libintl.h> /* INFRINGES ON USER NAME SPACE */
# define YY_(Msgid) dgettext ("bison-runtime", Msgid)
# endif
# endif
# ifndef YY_
# define YY_(Msgid) Msgid
# endif
#endif
#ifndef YY_ATTRIBUTE
# if (defined __GNUC__ \
&& (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \
|| defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
# define YY_ATTRIBUTE(Spec) __attribute__(Spec)
# else
# define YY_ATTRIBUTE(Spec) /* empty */
# endif
#endif
#ifndef YY_ATTRIBUTE_PURE
# define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__))
#endif
#ifndef YY_ATTRIBUTE_UNUSED
# define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
#endif
#if !defined _Noreturn \
&& (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
# if defined _MSC_VER && 1200 <= _MSC_VER
# define _Noreturn __declspec (noreturn)
# else
# define _Noreturn YY_ATTRIBUTE ((__noreturn__))
# endif
#endif
/* Suppress unused-variable warnings by "using" E. */
#if ! defined lint || defined __GNUC__
# define YYUSE(E) ((void) (E))
#else
# define YYUSE(E) /* empty */
#endif
#if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
/* Suppress an incorrect diagnostic about yylval being uninitialized. */
# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
_Pragma ("GCC diagnostic push") \
_Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
_Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
# define YY_IGNORE_MAYBE_UNINITIALIZED_END \
_Pragma ("GCC diagnostic pop")
#else
# define YY_INITIAL_VALUE(Value) Value
#endif
#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
# define YY_IGNORE_MAYBE_UNINITIALIZED_END
#endif
#ifndef YY_INITIAL_VALUE
# define YY_INITIAL_VALUE(Value) /* Nothing. */
#endif
#if ! defined yyoverflow || YYERROR_VERBOSE
/* The parser invokes alloca or malloc; define the necessary symbols. */
# ifdef YYSTACK_USE_ALLOCA
# if YYSTACK_USE_ALLOCA
# ifdef __GNUC__
# define YYSTACK_ALLOC __builtin_alloca
# elif defined __BUILTIN_VA_ARG_INCR
# include <alloca.h> /* INFRINGES ON USER NAME SPACE */
# elif defined _AIX
# define YYSTACK_ALLOC __alloca
# elif defined _MSC_VER
# include <malloc.h> /* INFRINGES ON USER NAME SPACE */
# define alloca _alloca
# else
# define YYSTACK_ALLOC alloca
# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
/* Use EXIT_SUCCESS as a witness for stdlib.h. */
# ifndef EXIT_SUCCESS
# define EXIT_SUCCESS 0
# endif
# endif
# endif
# endif
# endif
# ifdef YYSTACK_ALLOC
/* Pacify GCC's 'empty if-body' warning. */
# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
# ifndef YYSTACK_ALLOC_MAXIMUM
/* The OS might guarantee only one guard page at the bottom of the stack,
and a page size can be as small as 4096 bytes. So we cannot safely
invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
to allow for a few compiler-allocated temporary stack slots. */
# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
# endif
# else
# define YYSTACK_ALLOC YYMALLOC
# define YYSTACK_FREE YYFREE
# ifndef YYSTACK_ALLOC_MAXIMUM
# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
# endif
# if (defined __cplusplus && ! defined EXIT_SUCCESS \
&& ! ((defined YYMALLOC || defined malloc) \
&& (defined YYFREE || defined free)))
# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
# ifndef EXIT_SUCCESS
# define EXIT_SUCCESS 0
# endif
# endif
# ifndef YYMALLOC
# define YYMALLOC malloc
# if ! defined malloc && ! defined EXIT_SUCCESS
void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
# endif
# endif
# ifndef YYFREE
# define YYFREE free
# if ! defined free && ! defined EXIT_SUCCESS
void free (void *); /* INFRINGES ON USER NAME SPACE */
# endif
# endif
# endif
#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
#if (! defined yyoverflow \
&& (! defined __cplusplus \
|| (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
/* A type that is properly aligned for any stack member. */
union yyalloc
{
yytype_int16 yyss_alloc;
YYSTYPE yyvs_alloc;
};
/* The size of the maximum gap between one aligned stack and the next. */
# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
/* The size of an array large to enough to hold all stacks, each with
N elements. */
# define YYSTACK_BYTES(N) \
((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
+ YYSTACK_GAP_MAXIMUM)
# define YYCOPY_NEEDED 1
/* Relocate STACK from its old location to the new one. The
local variables YYSIZE and YYSTACKSIZE give the old and new number of
elements in the stack, and YYPTR gives the new location of the
stack. Advance YYPTR to a properly aligned location for the next
stack. */
# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
do \
{ \
YYSIZE_T yynewbytes; \
YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
Stack = &yyptr->Stack_alloc; \
yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
yyptr += yynewbytes / sizeof (*yyptr); \
} \
while (0)
#endif
#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
/* Copy COUNT objects from SRC to DST. The source and destination do
not overlap. */
# ifndef YYCOPY
# if defined __GNUC__ && 1 < __GNUC__
# define YYCOPY(Dst, Src, Count) \
__builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
# else
# define YYCOPY(Dst, Src, Count) \
do \
{ \
YYSIZE_T yyi; \
for (yyi = 0; yyi < (Count); yyi++) \
(Dst)[yyi] = (Src)[yyi]; \
} \
while (0)
# endif
# endif
#endif /* !YYCOPY_NEEDED */
/* YYFINAL -- State number of the termination state. */
#define YYFINAL 2
/* YYLAST -- Last index in YYTABLE. */
#define YYLAST 5655
/* YYNTOKENS -- Number of terminals. */
#define YYNTOKENS 362
/* YYNNTS -- Number of nonterminals. */
#define YYNNTS 547
/* YYNRULES -- Number of rules. */
#define YYNRULES 1313
/* YYNSTATES -- Number of states. */
#define YYNSTATES 2617
/* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
by yylex, with out-of-bounds checking. */
#define YYUNDEFTOK 2
#define YYMAXUTOK 361
#define YYTRANSLATE(YYX) \
((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
as returned by yylex, without out-of-bounds checking. */
static const yytype_uint16 yytranslate[] =
{
0, 3, 4, 5, 6, 7, 8, 9, 10, 11,
12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
62, 63, 64, 65, 66, 67, 68, 69, 70, 71,
72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
82, 83, 84, 85, 86, 87, 88, 89, 90, 91,
92, 93, 94, 95, 96, 97, 98, 99, 100, 101,
102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
112, 113, 114, 115, 116, 117, 118, 119, 120, 121,
122, 123, 124, 125, 126, 127, 128, 129, 130, 131,
132, 133, 134, 135, 136, 137, 138, 139, 140, 141,
142, 143, 144, 145, 146, 147, 148, 149, 150, 151,
152, 153, 154, 155, 156, 157, 158, 159, 160, 161,
162, 163, 164, 165, 166, 167, 168, 169, 170, 171,
172, 173, 174, 175, 176, 177, 178, 179, 180, 181,
182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
192, 193, 194, 195, 196, 197, 198, 199, 200, 201,
202, 203, 204, 205, 206, 207, 208, 209, 210, 211,
212, 213, 214, 215, 216, 217, 218, 219, 220, 221,
222, 223, 224, 225, 226, 227, 228, 229, 230, 231,
232, 233, 234, 235, 236, 237, 238, 239, 240, 241,
242, 243, 244, 245, 246, 247, 248, 249, 250, 251,
252, 253, 254, 255, 256, 257, 258, 259, 260, 261,
262, 263, 264, 265, 266, 267, 268, 269, 270, 271,
272, 273, 274, 275, 276, 277, 278, 279, 280, 281,
282, 283, 284, 285, 286, 287, 288, 289, 290, 291,
292, 293, 294, 295, 296, 297, 298, 299, 300, 301,
302, 303, 304, 305, 306, 307, 308, 309, 310, 311,
312, 313, 314, 315, 316, 317, 318, 319, 320, 321,
322, 323, 324, 325, 326, 327, 328, 329, 330, 331,
332, 333, 334, 335, 336, 337, 338, 339, 340, 341,
342, 343, 344, 345, 346, 347, 348, 349, 350, 351,
352, 353, 354, 355, 356, 357, 358, 359, 1, 2,
360, 361
};
#if YYDEBUG
/* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
static const yytype_uint16 yyrline[] =
{
0, 797, 797, 798, 802, 804, 818, 849, 858, 864,
884, 893, 909, 921, 931, 938, 944, 949, 954, 978,
1005, 1019, 1021, 1023, 1027, 1044, 1058, 1082, 1098, 1112,
1130, 1132, 1139, 1143, 1144, 1151, 1152, 1160, 1161, 1163,
1167, 1168, 1172, 1176, 1182, 1192, 1196, 1201, 1208, 1209,
1210, 1211, 1212, 1213, 1214, 1215, 1216, 1217, 1218, 1219,
1220, 1221, 1222, 1227, 1232, 1239, 1241, 1242, 1243, 1244,
1245, 1246, 1247, 1248, 1249, 1250, 1251, 1252, 1255, 1259,
1267, 1275, 1284, 1292, 1296, 1298, 1302, 1304, 1306, 1308,
1310, 1312, 1314, 1316, 1318, 1320, 1322, 1324, 1326, 1328,
1330, 1332, 1334, 1336, 1341, 1350, 1360, 1368, 1378, 1399,
1419, 1420, 1422, 1426, 1428, 1432, 1436, 1438, 1442, 1448,
1452, 1454, 1458, 1462, 1466, 1470, 1474, 1480, 1484, 1488,
1494, 1499, 1506, 1517, 1530, 1541, 1554, 1564, 1577, 1582,
1589, 1592, 1597, 1602, 1609, 1612, 1622, 1636, 1639, 1658,
1685, 1687, 1699, 1707, 1708, 1709, 1710, 1711, 1712, 1713,
1718, 1719, 1723, 1725, 1732, 1737, 1738, 1740, 1742, 1755,
1761, 1767, 1776, 1785, 1798, 1799, 1802, 1806, 1821, 1836,
1854, 1875, 1895, 1917, 1934, 1952, 1959, 1966, 1973, 1986,
1993, 2000, 2011, 2015, 2017, 2022, 2040, 2051, 2063, 2075,
2089, 2095, 2102, 2108, 2114, 2122, 2129, 2145, 2148, 2157,
2159, 2163, 2167, 2187, 2191, 2193, 2197, 2198, 2201, 2203,
2205, 2207, 2209, 2212, 2215, 2219, 2225, 2229, 2233, 2235,
2240, 2241, 2245, 2249, 2251, 2255, 2257, 2259, 2264, 2268,
2270, 2272, 2275, 2277, 2278, 2279, 2280, 2281, 2282, 2283,
2284, 2287, 2288, 2294, 2297, 2298, 2300, 2304, 2305, 2308,
2309, 2311, 2315, 2316, 2317, 2318, 2320, 2323, 2324, 2333,
2335, 2342, 2349, 2356, 2365, 2367, 2369, 2373, 2375, 2379,
2388, 2395, 2402, 2404, 2408, 2412, 2418, 2420, 2425, 2429,
2433, 2440, 2447, 2457, 2459, 2463, 2475, 2478, 2487, 2500,
2506, 2512, 2518, 2526, 2536, 2538, 2542, 2544, 2577, 2579,
2583, 2622, 2623, 2627, 2627, 2632, 2636, 2644, 2653, 2662,
2672, 2678, 2681, 2683, 2687, 2695, 2710, 2717, 2719, 2723,
2739, 2739, 2743, 2745, 2757, 2759, 2763, 2769, 2781, 2793,
2810, 2839, 2840, 2848, 2849, 2853, 2855, 2857, 2868, 2872,
2878, 2880, 2884, 2886, 2888, 2892, 2894, 2898, 2900, 2902,
2904, 2906, 2908, 2910, 2912, 2914, 2916, 2918, 2920, 2922,
2924, 2926, 2928, 2930, 2932, 2934, 2936, 2938, 2940, 2942,
2946, 2947, 2958, 3032, 3044, 3046, 3050, 3181, 3231, 3275,
3317, 3375, 3377, 3379, 3418, 3461, 3472, 3473, 3477, 3482,
3483, 3487, 3489, 3495, 3497, 3503, 3516, 3522, 3529, 3535,
3543, 3551, 3567, 3577, 3590, 3597, 3599, 3622, 3624, 3626,
3628, 3630, 3632, 3634, 3636, 3640, 3640, 3640, 3654, 3656,
3679, 3681, 3683, 3699, 3701, 3703, 3717, 3720, 3722, 3730,
3732, 3734, 3736, 3790, 3810, 3825, 3834, 3837, 3887, 3893,
3898, 3916, 3918, 3920, 3922, 3924, 3927, 3933, 3935, 3937,
3940, 3942, 3944, 3971, 3980, 3989, 3990, 3992, 3997, 4004,
4012, 4014, 4018, 4021, 4023, 4027, 4033, 4035, 4037, 4039,
4043, 4045, 4054, 4055, 4062, 4063, 4067, 4071, 4092, 4095,
4099, 4101, 4108, 4113, 4114, 4125, 4137, 4160, 4185, 4186,
4193, 4195, 4197, 4199, 4201, 4205, 4282, 4294, 4301, 4303,
4304, 4306, 4315, 4322, 4329, 4337, 4342, 4347, 4350, 4353,
4356, 4359, 4362, 4366, 4384, 4389, 4408, 4427, 4431, 4432,
4435, 4439, 4444, 4451, 4453, 4455, 4459, 4460, 4471, 4486,
4490, 4497, 4500, 4510, 4523, 4536, 4539, 4541, 4544, 4547,
4551, 4560, 4563, 4567, 4569, 4575, 4579, 4581, 4583, 4590,
4594, 4596, 4600, 4602, 4606, 4625, 4641, 4650, 4659, 4661,
4665, 4691, 4706, 4721, 4738, 4746, 4755, 4763, 4768, 4773,
4795, 4811, 4813, 4817, 4819, 4826, 4828, 4830, 4834, 4836,
4838, 4840, 4842, 4844, 4848, 4851, 4854, 4860, 4866, 4875,
4879, 4886, 4888, 4892, 4894, 4896, 4901, 4906, 4911, 4916,
4925, 4930, 4936, 4937, 4952, 4953, 4954, 4955, 4956, 4957,
4958, 4959, 4960, 4961, 4962, 4963, 4964, 4965, 4966, 4967,
4968, 4969, 4970, 4973, 4974, 4975, 4976, 4977, 4978, 4979,
4980, 4981, 4982, 4983, 4984, 4985, 4986, 4987, 4988, 4989,
4990, 4991, 4992, 4993, 4994, 4995, 4996, 4997, 4998, 4999,
5000, 5001, 5002, 5003, 5004, 5005, 5006, 5007, 5008, 5009,
5010, 5011, 5012, 5013, 5014, 5015, 5016, 5020, 5022, 5033,
5054, 5058, 5060, 5064, 5077, 5081, 5083, 5087, 5098, 5109,
5113, 5115, 5119, 5121, 5123, 5138, 5150, 5170, 5190, 5212,
5218, 5227, 5235, 5241, 5249, 5256, 5262, 5271, 5275, 5281,
5289, 5303, 5317, 5322, 5338, 5353, 5381, 5383, 5387, 5389,
5393, 5422, 5445, 5466, 5467, 5471, 5492, 5494, 5498, 5506,
5510, 5515, 5517, 5519, 5521, 5527, 5529, 5533, 5543, 5547,
5549, 5554, 5556, 5560, 5564, 5570, 5580, 5582, 5586, 5588,
5590, 5597, 5615, 5616, 5620, 5622, 5626, 5633, 5643, 5672,
5687, 5694, 5712, 5714, 5718, 5732, 5758, 5771, 5787, 5789,
5792, 5794, 5800, 5804, 5832, 5834, 5838, 5846, 5852, 5855,
5913, 5977, 5979, 5982, 5986, 5990, 5994, 6011, 6023, 6027,
6031, 6041, 6046, 6051, 6058, 6067, 6067, 6078, 6089, 6091,
6095, 6106, 6110, 6112, 6116, 6127, 6131, 6133, 6137, 6149,
6151, 6158, 6160, 6164, 6180, 6188, 6199, 6201, 6205, 6208,
6213, 6223, 6225, 6229, 6231, 6240, 6241, 6245, 6247, 6252,
6253, 6254, 6255, 6256, 6257, 6258, 6259, 6260, 6261, 6262,
6265, 6270, 6274, 6278, 6282, 6295, 6299, 6303, 6307, 6310,
6312, 6314, 6318, 6320, 6324, 6328, 6330, 6334, 6339, 6343,
6347, 6349, 6353, 6362, 6365, 6371, 6378, 6381, 6383, 6387,
6389, 6393, 6405, 6407, 6411, 6415, 6417, 6421, 6423, 6425,
6427, 6429, 6431, 6433, 6437, 6441, 6445, 6449, 6453, 6460,
6466, 6471, 6474, 6477, 6490, 6492, 6496, 6498, 6503, 6509,
6515, 6521, 6527, 6533, 6539, 6545, 6551, 6560, 6566, 6583,
6585, 6593, 6601, 6603, 6607, 6611, 6613, 6617, 6619, 6627,
6631, 6643, 6646, 6664, 6666, 6670, 6672, 6676, 6678, 6682,
6686, 6690, 6699, 6703, 6707, 6712, 6716, 6728, 6730, 6734,
6739, 6743, 6745, 6749, 6751, 6755, 6760, 6767, 6790, 6792,
6794, 6796, 6798, 6802, 6813, 6817, 6832, 6839, 6846, 6847,
6851, 6855, 6863, 6867, 6871, 6879, 6884, 6898, 6900, 6904,
6906, 6915, 6917, 6919, 6921, 6957, 6961, 6965, 6969, 6973,
6985, 6987, 6991, 6994, 6996, 7000, 7005, 7012, 7015, 7023,
7027, 7032, 7034, 7041, 7046, 7050, 7054, 7058, 7062, 7066,
7069, 7071, 7075, 7077, 7079, 7083, 7087, 7099, 7101, 7105,
7107, 7111, 7114, 7117, 7121, 7127, 7139, 7141, 7145, 7147,
7151, 7159, 7171, 7172, 7174, 7178, 7182, 7184, 7192, 7196,
7199, 7201, 7205, 7209, 7211, 7212, 7213, 7214, 7215, 7216,
7217, 7218, 7219, 7220, 7221, 7222, 7223, 7224, 7225, 7226,
7227, 7228, 7229, 7230, 7231, 7232, 7233, 7234, 7235, 7236,
7239, 7245, 7251, 7257, 7263, 7267, 7273, 7274, 7275, 7276,
7277, 7278, 7279, 7280, 7281, 7284, 7289, 7294, 7300, 7306,
7312, 7317, 7323, 7329, 7335, 7342, 7348, 7354, 7361, 7365,
7367, 7373, 7380, 7386, 7392, 7398, 7404, 7410, 7416, 7422,
7428, 7434, 7440, 7446, 7456, 7461, 7467, 7471, 7477, 7478,
7479, 7480, 7483, 7491, 7497, 7503, 7508, 7514, 7521, 7527,
7531, 7537, 7538, 7539, 7540, 7541, 7542, 7545, 7554, 7558,
7564, 7571, 7578, 7585, 7594, 7600, 7606, 7610, 7616, 7617,
7620, 7626, 7632, 7636, 7643, 7644, 7647, 7653, 7659, 7664,
7672, 7678, 7683, 7690, 7694, 7700, 7701, 7702, 7703, 7704,
7705, 7706, 7707, 7708, 7709, 7710, 7714, 7719, 7724, 7731,
7736, 7742, 7748, 7753, 7758, 7763, 7767, 7772, 7777, 7781,
7786, 7790, 7796, 7801, 7807, 7812, 7818, 7828, 7832, 7836,
7840, 7846, 7849, 7853, 7854, 7856, 7857, 7858, 7859, 7860,
7861, 7864, 7868, 7872, 7874, 7876, 7880, 7882, 7884, 7888,
7890, 7894, 7896, 7900, 7903, 7906, 7911, 7913, 7915, 7917,
7919, 7923, 7927, 7932, 7936, 7938, 7942, 7944, 7948, 7952,
7956, 7961, 7963, 7967, 7977, 7982, 7983, 7987, 7989, 7993,
7995, 7998, 7999, 8000, 8001, 8002, 8003, 8006, 8010, 8014,
8018, 8020, 8022, 8026, 8028, 8032, 8034, 8045, 8046, 8051,
8052, 8056, 8060, 8062, 8066, 8067, 8068, 8069, 8070, 8073,
8077, 8081, 8085, 8089, 8092, 8094, 8098, 8102, 8104, 8108,
8109, 8110, 8113, 8117, 8121, 8125, 8127, 8131, 8133, 8135,
8137, 8140, 8142, 8144, 8146, 8150, 8157, 8161, 8163, 8167,
8171, 8173, 8177, 8179, 8181, 8183, 8185, 8189, 8191, 8195,
8197, 8201, 8203, 8208
};
#endif
#if YYDEBUG || YYERROR_VERBOSE || 0
/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
First, the terminals, then, starting at YYNTOKENS, nonterminals. */
static const char *const yytname[] =
{
"$end", "error", "$undefined", "PERCENT", "AMPERSAND", "ASTER",
"CLUSTER", "COLON", "COMMA", "DASTER", "DEFINED_OPERATOR", "DOT",
"DQUOTE", "GLOBAL_A", "LEFTAB", "LEFTPAR", "MINUS", "PLUS", "POINT_TO",
"QUOTE", "RIGHTAB", "RIGHTPAR", "AND", "DSLASH", "EQV", "EQ", "EQUAL",
"FFALSE", "GE", "GT", "LE", "LT", "NE", "NEQV", "NOT", "OR", "TTRUE",
"SLASH", "XOR", "REFERENCE", "AT", "ACROSS", "ALIGN_WITH", "ALIGN",
"ALLOCATABLE", "ALLOCATE", "ARITHIF", "ASSIGNMENT", "ASSIGN",
"ASSIGNGOTO", "ASYNCHRONOUS", "ASYNCID", "ASYNCWAIT", "BACKSPACE",
"BAD_CCONST", "BAD_SYMBOL", "BARRIER", "BLOCKDATA", "BLOCK",
"BOZ_CONSTANT", "BYTE", "CALL", "CASE", "CHARACTER", "CHAR_CONSTANT",
"CHECK", "CLOSE", "COMMON", "COMPLEX", "COMPGOTO", "CONSISTENT_GROUP",
"CONSISTENT_SPEC", "CONSISTENT_START", "CONSISTENT_WAIT", "CONSISTENT",
"CONSTRUCT_ID", "CONTAINS", "CONTINUE", "CORNER", "CYCLE", "DATA",
"DEALLOCATE", "HPF_TEMPLATE", "DEBUG", "DEFAULT_CASE", "DEFINE",
"DERIVED", "DIMENSION", "DISTRIBUTE", "DOWHILE", "DOUBLEPRECISION",
"DOUBLECOMPLEX", "DP_CONSTANT", "DVM_POINTER", "DYNAMIC", "ELEMENTAL",
"ELSE", "ELSEIF", "ELSEWHERE", "ENDASYNCHRONOUS", "ENDDEBUG",
"ENDINTERVAL", "ENDUNIT", "ENDDO", "ENDFILE", "ENDFORALL", "ENDIF",
"ENDINTERFACE", "ENDMODULE", "ENDON", "ENDSELECT", "ENDTASK_REGION",
"ENDTYPE", "ENDWHERE", "ENTRY", "EXIT", "EOLN", "EQUIVALENCE", "ERROR",
"EXTERNAL", "F90", "FIND", "FORALL", "FORMAT", "FUNCTION", "GATE",
"GEN_BLOCK", "HEAP", "HIGH", "IDENTIFIER", "IMPLICIT", "IMPLICITNONE",
"INCLUDE_TO", "INCLUDE", "INDEPENDENT", "INDIRECT_ACCESS",
"INDIRECT_GROUP", "INDIRECT", "INHERIT", "INQUIRE",
"INTERFACEASSIGNMENT", "INTERFACEOPERATOR", "INTERFACE", "INTRINSIC",
"INTEGER", "INTENT", "INTERVAL", "INOUT", "IN", "INT_CONSTANT", "LABEL",
"LABEL_DECLARE", "LET", "LOCALIZE", "LOGICAL", "LOGICALIF", "LOOP",
"LOW", "MAXLOC", "MAX", "MAP", "MINLOC", "MIN", "MODULE_PROCEDURE",
"MODULE", "MULT_BLOCK", "NAMEEQ", "NAMELIST", "NEW_VALUE", "NEW",
"NULLIFY", "OCTAL_CONSTANT", "ONLY", "ON", "ON_DIR", "ONTO", "OPEN",
"OPERATOR", "OPTIONAL", "OTHERWISE", "OUT", "OWN", "PARALLEL",
"PARAMETER", "PAUSE", "PLAINDO", "PLAINGOTO", "POINTER", "POINTERLET",
"PREFETCH", "PRINT", "PRIVATE", "PRODUCT", "PROGRAM", "PUBLIC", "PURE",
"RANGE", "READ", "REALIGN_WITH", "REALIGN", "REAL", "REAL_CONSTANT",
"RECURSIVE", "REDISTRIBUTE_NEW", "REDISTRIBUTE", "REDUCTION_GROUP",
"REDUCTION_START", "REDUCTION_WAIT", "REDUCTION", "REMOTE_ACCESS_SPEC",
"REMOTE_ACCESS", "REMOTE_GROUP", "RESET", "RESULT", "RETURN", "REWIND",
"SAVE", "SECTION", "SELECT", "SEQUENCE", "SHADOW_ADD", "SHADOW_COMPUTE",
"SHADOW_GROUP", "SHADOW_RENEW", "SHADOW_START_SPEC", "SHADOW_START",
"SHADOW_WAIT_SPEC", "SHADOW_WAIT", "SHADOW", "STAGE", "STATIC", "STAT",
"STOP", "SUBROUTINE", "SUM", "SYNC", "TARGET", "TASK", "TASK_REGION",
"THEN", "TO", "TRACEON", "TRACEOFF", "TRUNC", "TYPE", "TYPE_DECL",
"UNDER", "UNKNOWN", "USE", "VIRTUAL", "VARIABLE", "WAIT", "WHERE",
"WHERE_ASSIGN", "WHILE", "WITH", "WRITE", "COMMENT", "WGT_BLOCK",
"HPF_PROCESSORS", "IOSTAT", "ERR", "END", "OMPDVM_ATOMIC",
"OMPDVM_BARRIER", "OMPDVM_COPYIN", "OMPDVM_COPYPRIVATE",
"OMPDVM_CRITICAL", "OMPDVM_ONETHREAD", "OMPDVM_DO", "OMPDVM_DYNAMIC",
"OMPDVM_ENDCRITICAL", "OMPDVM_ENDDO", "OMPDVM_ENDMASTER",
"OMPDVM_ENDORDERED", "OMPDVM_ENDPARALLEL", "OMPDVM_ENDPARALLELDO",
"OMPDVM_ENDPARALLELSECTIONS", "OMPDVM_ENDPARALLELWORKSHARE",
"OMPDVM_ENDSECTIONS", "OMPDVM_ENDSINGLE", "OMPDVM_ENDWORKSHARE",
"OMPDVM_FIRSTPRIVATE", "OMPDVM_FLUSH", "OMPDVM_GUIDED",
"OMPDVM_LASTPRIVATE", "OMPDVM_MASTER", "OMPDVM_NOWAIT", "OMPDVM_NONE",
"OMPDVM_NUM_THREADS", "OMPDVM_ORDERED", "OMPDVM_PARALLEL",
"OMPDVM_PARALLELDO", "OMPDVM_PARALLELSECTIONS",
"OMPDVM_PARALLELWORKSHARE", "OMPDVM_RUNTIME", "OMPDVM_SECTION",
"OMPDVM_SECTIONS", "OMPDVM_SCHEDULE", "OMPDVM_SHARED", "OMPDVM_SINGLE",
"OMPDVM_THREADPRIVATE", "OMPDVM_WORKSHARE", "OMPDVM_NODES", "OMPDVM_IF",
"IAND", "IEOR", "IOR", "ACC_REGION", "ACC_END_REGION",
"ACC_CHECKSECTION", "ACC_END_CHECKSECTION", "ACC_GET_ACTUAL",
"ACC_ACTUAL", "ACC_TARGETS", "ACC_ASYNC", "ACC_HOST", "ACC_CUDA",
"ACC_LOCAL", "ACC_INLOCAL", "ACC_CUDA_BLOCK", "ACC_ROUTINE", "ACC_TIE",
"ACC_DECLARE", "BY", "IO_MODE", "CP_CREATE", "CP_LOAD", "CP_SAVE",
"CP_WAIT", "FILES", "VARLIST", "STATUS", "EXITINTERVAL",
"TEMPLATE_CREATE", "TEMPLATE_DELETE", "SPF_ANALYSIS", "SPF_PARALLEL",
"SPF_TRANSFORM", "SPF_NOINLINE", "SPF_PARALLEL_REG",
"SPF_END_PARALLEL_REG", "SPF_EXPAND", "SPF_FISSION", "SPF_SHRINK",
"SPF_CHECKPOINT", "SPF_EXCEPT", "SPF_FILES_COUNT", "SPF_INTERVAL",
"SPF_TIME", "SPF_ITER", "SPF_FLEXIBLE", "SPF_APPLY_REGION",
"SPF_APPLY_FRAGMENT", "SPF_CODE_COVERAGE", "SPF_UNROLL", "SPF_MERGE",
"SPF_COVER", "SPF_PROCESS_PRIVATE", "SPF_WEIGHT", "BINARY_OP",
"UNARY_OP", "$accept", "program", "stat", "thislabel", "entry",
"new_prog", "proc_attr", "procname", "funcname", "typedfunc",
"opt_result_clause", "name", "progname", "blokname", "arglist", "args",
"arg", "filename", "needkeyword", "keywordoff",
"keyword_if_colon_follow", "spec", "interface", "defined_op", "operator",
"intrinsic_op", "type_dcl", "end_type", "dcl", "options",
"attr_spec_list", "attr_spec", "intent_spec", "access_spec", "intent",
"optional", "static", "private", "private_attr", "sequence", "public",
"public_attr", "type", "opt_key_hedr", "attrib", "att_type", "typespec",
"typename", "lengspec", "proper_lengspec", "selector", "clause",
"end_ioctl", "initial_value", "dimension", "allocatable", "pointer",
"target", "common", "namelist", "namelist_group", "comblock", "var",
"external", "intrinsic", "equivalence", "equivset", "equivlist",
"equi_object", "data", "data1", "data_in", "in_data", "datapair",
"datalvals", "datarvals", "datalval", "data_null", "d_name", "dataname",
"datasubs", "datarange", "iconexprlist", "opticonexpr", "dataimplieddo",
"dlist", "dataelt", "datarval", "datavalue", "BOZ_const", "int_const",
"unsignedint", "real_const", "unsignedreal", "complex_const_data",
"complex_part", "iconexpr", "iconterm", "iconfactor", "iconprimary",
"savelist", "saveitem", "use_name_list", "use_key_word",
"no_use_key_word", "use_name", "paramlist", "paramitem",
"module_proc_stmt", "proc_name_list", "use_stat", "module_name",
"only_list", "only_name", "rename_list", "rename_name", "dims",
"dimlist", "$@1", "dim", "ubound", "labellist", "label", "implicit",
"implist", "impitem", "imptype", "$@2", "type_implicit", "letgroups",
"letgroup", "letter", "inside", "in_dcl", "opt_double_colon",
"funarglist", "funarg", "funargs", "subscript_list", "expr", "uexpr",
"addop", "ident", "lhs", "array_ele_substring_func_ref",
"structure_component", "array_element", "asubstring", "opt_substring",
"substring", "opt_expr", "simple_const", "numeric_bool_const",
"integer_constant", "string_constant", "complex_const", "kind",
"triplet", "vec", "$@3", "$@4", "allocate_object", "allocation_list",
"allocate_object_list", "stat_spec", "pointer_name_list", "exec",
"do_while", "opt_while", "plain_do", "case", "case_selector",
"case_value_range", "case_value_range_list", "opt_construct_name",
"opt_unit_name", "construct_name", "construct_name_colon", "logif",
"forall", "forall_list", "forall_expr", "opt_forall_cond", "do_var",
"dospec", "dotarget", "whereable", "iffable", "let", "goto", "opt_comma",
"call", "callarglist", "callarg", "stop", "end_spec", "intonlyon",
"intonlyoff", "io", "iofmove", "fmkwd", "iofctl", "ctlkwd", "inquire",
"infmt", "ioctl", "ctllist", "ioclause", "nameeq", "read", "write",
"print", "inlist", "inelt", "outlist", "out2", "other", "in_ioctl",
"start_ioctl", "fexpr", "unpar_fexpr", "cmnt", "dvm_specification",
"dvm_exec", "dvm_template", "template_obj", "dvm_dynamic",
"dyn_array_name_list", "dyn_array_name", "dvm_inherit",
"dummy_array_name_list", "dummy_array_name", "dvm_shadow",
"shadow_attr_stuff", "sh_width_list", "sh_width", "sh_array_name",
"dvm_processors", "dvm_indirect_group", "indirect_group_name",
"dvm_remote_group", "remote_group_name", "dvm_reduction_group",
"reduction_group_name", "dvm_consistent_group", "consistent_group_name",
"opt_onto", "dvm_distribute", "dvm_redistribute", "dist_name_list",
"distributee", "dist_name", "pointer_ar_elem", "processors_name",
"opt_dist_format_clause", "dist_format_clause", "dist_format_list",
"opt_key_word", "dist_format", "array_name", "derived_spec",
"derived_elem_list", "derived_elem", "target_spec", "derived_target",
"derived_subscript_list", "derived_subscript", "dummy_ident",
"opt_plus_shadow", "plus_shadow", "shadow_id", "shadow_width",
"dvm_align", "dvm_realign", "realignee_list", "alignee", "realignee",
"align_directive_stuff", "align_base", "align_subscript_list",
"align_subscript", "align_base_name", "dim_ident_list", "dim_ident",
"dvm_combined_dir", "dvm_attribute_list", "dvm_attribute", "dvm_pointer",
"dimension_list", "$@5", "pointer_var_list", "pointer_var", "dvm_heap",
"heap_array_name_list", "heap_array_name", "dvm_consistent",
"consistent_array_name_list", "consistent_array_name", "dvm_asyncid",
"async_id_list", "async_id", "dvm_new_value", "dvm_parallel_on",
"ident_list", "opt_on", "distribute_cycles", "par_subscript_list",
"par_subscript", "opt_spec", "spec_list", "par_spec",
"remote_access_spec", "consistent_spec", "consistent_group", "new_spec",
"private_spec", "cuda_block_spec", "sizelist", "variable_list",
"tie_spec", "tied_array_list", "indirect_access_spec", "stage_spec",
"across_spec", "in_out_across", "opt_keyword_in_out", "opt_in_out",
"dependent_array_list", "dependent_array", "dependence_list",
"dependence", "section_spec_list", "section_spec", "ar_section",
"low_section", "high_section", "section", "reduction_spec",
"opt_key_word_r", "no_opt_key_word_r", "reduction_group",
"reduction_list", "reduction", "reduction_op", "loc_op", "shadow_spec",
"shadow_group_name", "shadow_list", "shadow", "opt_corner",
"array_ident", "array_ident_list", "dvm_shadow_start", "dvm_shadow_wait",
"dvm_shadow_group", "dvm_reduction_start", "dvm_reduction_wait",
"dvm_consistent_start", "dvm_consistent_wait", "dvm_remote_access",
"group_name", "remote_data_list", "remote_data", "remote_index_list",
"remote_index", "dvm_task", "task_array", "dvm_task_region", "task_name",
"dvm_end_task_region", "task", "dvm_on", "opt_private_spec",
"dvm_end_on", "dvm_map", "dvm_prefetch", "dvm_reset",
"dvm_indirect_access", "indirect_list", "indirect_reference",
"hpf_independent", "hpf_reduction_spec", "dvm_asynchronous",
"dvm_endasynchronous", "dvm_asyncwait", "async_ident", "async",
"dvm_f90", "dvm_debug_dir", "debparamlist", "debparam",
"fragment_number", "dvm_enddebug_dir", "dvm_interval_dir",
"interval_number", "dvm_exit_interval_dir", "dvm_endinterval_dir",
"dvm_traceon_dir", "dvm_traceoff_dir", "dvm_barrier_dir", "dvm_check",
"dvm_io_mode_dir", "mode_list", "mode_spec", "dvm_shadow_add",
"template_ref", "shadow_axis_list", "shadow_axis", "opt_include_to",
"dvm_localize", "localize_target", "target_subscript_list",
"target_subscript", "aster_expr", "dvm_cp_create", "opt_mode",
"dvm_cp_load", "dvm_cp_save", "dvm_cp_wait", "dvm_template_create",
"template_list", "dvm_template_delete", "omp_specification_directive",
"omp_execution_directive", "ompdvm_onethread",
"omp_parallel_end_directive", "omp_parallel_begin_directive",
"parallel_clause_list", "parallel_clause", "omp_variable_list_in_par",
"ompprivate_clause", "ompfirstprivate_clause", "omplastprivate_clause",
"ompcopyin_clause", "ompshared_clause", "ompdefault_clause", "def_expr",
"ompif_clause", "ompnumthreads_clause", "ompreduction_clause",
"ompreduction", "ompreduction_vars", "ompreduction_op",
"omp_sections_begin_directive", "sections_clause_list",
"sections_clause", "omp_sections_end_directive", "omp_section_directive",
"omp_do_begin_directive", "omp_do_end_directive", "do_clause_list",
"do_clause", "ompordered_clause", "ompschedule_clause", "ompschedule_op",
"omp_single_begin_directive", "single_clause_list", "single_clause",
"omp_single_end_directive", "end_single_clause_list",
"end_single_clause", "ompcopyprivate_clause", "ompnowait_clause",
"omp_workshare_begin_directive", "omp_workshare_end_directive",
"omp_parallel_do_begin_directive", "paralleldo_clause_list",
"paralleldo_clause", "omp_parallel_do_end_directive",
"omp_parallel_sections_begin_directive",
"omp_parallel_sections_end_directive",
"omp_parallel_workshare_begin_directive",
"omp_parallel_workshare_end_directive", "omp_threadprivate_directive",
"omp_master_begin_directive", "omp_master_end_directive",
"omp_ordered_begin_directive", "omp_ordered_end_directive",
"omp_barrier_directive", "omp_atomic_directive", "omp_flush_directive",
"omp_critical_begin_directive", "omp_critical_end_directive",
"omp_common_var", "omp_variable_list", "op_slash_1", "op_slash_0",
"acc_specification", "acc_directive", "acc_region", "acc_checksection",
"acc_get_actual", "acc_actual", "opt_clause", "acc_clause_list",
"acc_clause", "data_clause", "targets_clause", "async_clause",
"acc_var_list", "computer_list", "computer", "acc_end_region",
"acc_end_checksection", "acc_declare", "acc_declare_list", "declare_var",
"acc_routine", "opt_routine_clauses", "routine_clause_list",
"routine_clause", "spf_directive", "spf_analysis", "spf_parallel",
"spf_transform", "spf_parallel_reg", "characteristic_list",
"characteristic", "opt_clause_apply_fragment", "opt_clause_apply_region",
"spf_end_parallel_reg", "analysis_spec_list", "analysis_spec",
"analysis_reduction_spec", "analysis_private_spec",
"analysis_process_private_spec", "analysis_cover_spec",
"analysis_parameter_spec", "spf_parameter_list", "spf_parameter",
"parallel_spec_list", "parallel_spec", "parallel_shadow_spec",
"parallel_across_spec", "parallel_remote_access_spec",
"transform_spec_list", "transform_spec", "unroll_list", "region_name",
"array_element_list", "spf_checkpoint", "checkpoint_spec_list",
"checkpoint_spec", "spf_type_list", "spf_type", "interval_spec",
"in_unit", YY_NULLPTR
};
#endif
# ifdef YYPRINT
/* YYTOKNUM[NUM] -- (External) token number corresponding to the
(internal) symbol number NUM (which must be that of a token). */
static const yytype_uint16 yytoknum[] =
{
0, 358, 359, 1, 2, 3, 4, 5, 6, 7,
8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
58, 59, 60, 61, 62, 63, 64, 65, 66, 67,
68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
78, 79, 80, 81, 82, 83, 84, 85, 86, 87,
88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
98, 99, 100, 101, 102, 103, 104, 105, 106, 107,
108, 109, 110, 111, 112, 113, 114, 115, 116, 117,
118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
128, 129, 130, 131, 132, 133, 134, 135, 136, 137,
138, 139, 140, 141, 142, 143, 144, 145, 146, 147,
148, 149, 150, 151, 152, 153, 154, 155, 156, 157,
158, 159, 160, 161, 162, 163, 164, 165, 166, 167,
168, 169, 170, 171, 172, 173, 174, 175, 176, 177,
178, 179, 180, 181, 182, 183, 184, 185, 186, 187,
188, 189, 190, 191, 192, 193, 194, 195, 196, 197,
198, 199, 200, 201, 202, 203, 204, 205, 206, 207,
208, 209, 210, 211, 212, 213, 214, 215, 216, 217,
218, 219, 220, 221, 222, 223, 224, 225, 226, 227,
228, 229, 230, 231, 232, 233, 234, 235, 236, 237,
238, 239, 240, 241, 242, 243, 244, 245, 246, 247,
248, 249, 250, 251, 252, 253, 254, 255, 256, 257,
258, 259, 260, 261, 262, 263, 264, 265, 266, 267,
268, 269, 270, 271, 272, 273, 274, 275, 276, 277,
278, 279, 280, 281, 282, 283, 284, 285, 286, 287,
288, 289, 290, 291, 292, 293, 294, 295, 296, 297,
298, 299, 300, 301, 302, 303, 304, 305, 306, 307,
308, 309, 310, 311, 312, 313, 314, 315, 316, 317,
318, 319, 320, 321, 322, 323, 324, 325, 326, 327,
328, 329, 330, 331, 332, 333, 334, 335, 336, 337,
338, 339, 340, 341, 342, 343, 344, 345, 346, 347,
348, 349, 350, 351, 352, 353, 354, 355, 356, 357,
360, 361
};
# endif
#define YYPACT_NINF -2103
#define yypact_value_is_default(Yystate) \
(!!((Yystate) == (-2103)))
#define YYTABLE_NINF -1192
#define yytable_value_is_error(Yytable_value) \
(!!((Yytable_value) == (-1192)))
/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
STATE-NUM. */
static const yytype_int16 yypact[] =
{
-2103, 120, -2103, -2103, -2103, -2103, -7, 5156, -2103, -2103,
-2103, 134, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, 889, -2103,
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
-2103, 118, -2103, -2103, 753, 162, -2103, -2103, -2103, 118,
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
-2103, -2103, 124, 124, -2103, -2103, -2103, -2103, -2103, 124,
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
238, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, 124, -2103,
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
-2103, 211, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
344, 417, -2103, -2103, -2103, -2103, -2103, 118, -2103, -2103,
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
-2103, -2103, -2103, -2103, -2103, -2103, 118, -2103, -2103, -2103,
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, 234,
1817, 445, 234, -2103, -2103, -2103, 504, 530, 594, 615,
-2103, -2103, -2103, 786, 621, 124, -2103, -2103, 725, 755,
774, 791, 630, 518, 837, 856, 862, -2103, 153, -2103,
-2103, -2103, 234, -2103, -2103, -2103, 570, 917, 2307, 2403,
-2103, -2103, 2952, -2103, 701, -2103, -2103, 1131, -2103, 870,
-2103, -2103, 1762, 870, 896, -2103, -2103, 925, -2103, -2103,
-2103, 941, 967, 979, 997, 1001, -2103, -2103, -2103, -2103,
1004, 972, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
-2103, -2103, -2103, -2103, -2103, -2103, -2103, 1006, -2103, -2103,
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
-2103, -2103, -2103, -2103, -2103, -2103, 152, 124, 1009, 1015,
1033, 903, 124, 124, 190, 124, -2103, 124, 124, 1056,
-2103, 525, 1068, 124, 124, 124, 124, -2103, -2103, 124,
-2103, 1090, 124, 964, 124, 1031, -2103, -2103, -2103, 124,
-2103, 1096, 124, -2103, 124, 1107, 175, -2103, 964, -2103,
124, 124, 124, 124, -2103, -2103, -2103, -2103, -2103, 124,
-2103, 124, 124, 445, 124, 1110, 1009, 124, 1114, -2103,
124, 124, -2103, -2103, -2103, 1124, 1119, 124, 124, -2103,
1122, 1128, 124, 1009, 1134, 2952, -2103, 1140, 1144, 124,
-2103, 1157, 124, 1102, -2103, 1175, 124, 1009, 1194, 1205,
-2103, 903, 1009, 124, 124, 2162, 79, 124, 84, -2103,
-2103, 202, -2103, 203, 124, 124, 124, 1231, 124, 124,
2952, 93, -2103, -2103, 1235, 124, 124, 124, 124, 124,
2647, 124, -2103, 1009, 124, 1009, 124, 124, -2103, -2103,
124, -2103, 1009, 124, 1241, 1243, -2103, 124, -2103, -2103,
1246, -2103, -2103, 1250, -2103, -2103, -2103, -2103, -2103, -2103,
-2103, -2103, -2103, -2103, 1253, -2103, -2103, -2103, -2103, -2103,
-2103, -2103, -2103, -2103, -2103, -2103, 124, -2103, -2103, 1269,
1289, 1223, 1009, 1313, 2952, 2952, 2952, 2952, 2952, 1315,
1321, 1348, 1370, 1382, 124, -2103, 1392, -2103, -2103, -2103,
-2103, 1195, 113, -2103, -2103, 124, 124, 124, 124, 1362,
-2103, -2103, 1290, 124, 124, -2103, 700, 124, 124, 124,
124, 124, 312, 124, 1102, 124, 124, 1110, -2103, -2103,
-2103, -2103, -2103, -2103, -2103, -2103, 1154, -2103, -2103, -2103,
-2103, -2103, -2103, 2952, 2952, 2952, -2103, 2952, -2103, -2103,
-2103, -2103, -2103, -2103, 2952, 2407, -2103, 80, 1414, -2103,
1408, -2103, 1182, 1189, 1426, -2103, -2103, 1428, 2952, -2103,
-2103, 2055, -2103, -2103, 1421, 1527, 1414, -2103, -2103, 1075,
3, -2103, 2055, -2103, -2103, -2103, 1468, 210, 72, 2960,
2960, 124, 124, 124, 124, 124, 124, 124, 1474, -2103,
124, -2103, -2103, -2103, 667, -2103, -2103, 1463, 124, -2103,
2952, -2103, 1242, 878, -2103, 1482, -2103, -2103, 1485, 1478,
-2103, -2103, -2103, -2103, -2103, 2662, 124, 1490, -2103, 124,
1485, 124, -2103, 903, -2103, -2103, -2103, -2103, -2103, -2103,
1498, -2103, -2103, -2103, -2103, -2103, 1485, -2103, -2103, 1500,
-2103, -2103, 771, 1177, 124, 792, 97, -2103, 1507, 1366,
2952, 1374, -2103, 1537, -2103, -2103, 2952, 2952, -2103, -2103,
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, 124,
-2103, 124, 1531, 243, 124, 445, -2103, -2103, 1543, -2103,
1548, -2103, 1550, 1139, -2103, 1562, -2103, 124, -2103, -2103,
-2103, 1563, -2103, 870, 1549, 3062, -2103, 124, -2103, 5617,
-2103, 124, 2952, -2103, 1564, -2103, 124, -2103, 124, 124,
124, 1414, 731, 124, 124, 124, 1374, -2103, 124, 648,
-2103, -2103, -2103, 1527, 1075, -2103, -2103, -2103, -2103, -2103,
-2103, 152, -2103, 1463, 1570, 1507, -2103, -2103, -2103, -2103,
-2103, -2103, 124, -2103, -2103, -2103, 5617, -2103, 525, 1520,
124, -2103, 1585, -2103, -2103, -2103, -2103, 1588, 3140, 798,
-2103, -2103, 211, 124, 445, -2103, 124, 1485, -2103, 1598,
1589, -2103, 124, -2103, 1606, 2952, 2952, -2103, 1485, 124,
272, 124, 1330, 1330, 364, 1330, -2103, 1603, 419, 487,
495, 524, 526, 532, -2103, 1485, 838, -2103, 1624, -2103,
198, 485, -2103, -2103, 1223, -2103, 124, -2103, 3203, 5617,
3237, 3329, 1626, 5617, 124, 124, -2103, -2103, -2103, -2103,
1627, -2103, 124, 124, -2103, -2103, -2103, -2103, 821, -2103,
-2103, 1423, 1485, -2103, -2103, -2103, -2103, 1297, 124, -2103,
-2103, -2103, -2103, -2103, -2103, -2103, 1485, -2103, -2103, -2103,
-2103, 1638, -2103, 1638, -2103, -2103, -2103, -2103, 578, -2103,
214, -2103, 1636, -2103, -2103, 3403, 1650, 1656, 1656, 1673,
-2103, 2952, 2952, 2952, 2952, 2952, 2952, 2952, 2952, 2952,
2952, 2952, 2952, 2952, 2952, 2952, 2952, 2952, 2952, 2952,
-2103, 1602, 1544, 1664, 390, 440, 2952, -2103, -2103, -2103,
832, 1228, -2103, -2103, -2103, -2103, 846, -2103, 1410, 1273,
2952, 1668, 1527, 1527, 1527, 1527, 1527, -2103, 1663, -2103,
210, 210, 1414, 1679, -2103, 2960, 5617, 125, 150, -2103,
1684, 1689, -2103, -2103, 1485, -2103, -2103, -2103, -2103, 1485,
-2103, 708, -2103, 152, -2103, -2103, -2103, 124, 3450, 124,
1697, 2952, 1651, -2103, -2103, 124, -2103, 2952, 3513, -2103,
855, -2103, -2103, 1662, -2103, -2103, 882, -2103, 124, -2103,
124, -2103, -2103, 1177, -2103, -2103, -2103, -2103, -2103, 3585,
1485, -2103, -2103, -2103, 1704, 1705, 1706, 1715, 1716, 1718,
-2103, 1366, -2103, 124, -2103, 3665, -2103, -2103, 124, 3750,
3781, -2103, 1725, 900, 1737, 1426, -2103, -2103, 124, -2103,
1739, -2103, 1724, -2103, 124, -2103, 1622, 748, -2103, -2103,
-26, -2103, -2103, 1745, -2103, 1738, 1749, 905, -2103, 124,
2960, 1744, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
-2103, 1751, -2103, -2103, 57, 1752, 1740, 3830, 2685, -70,
-2103, 1722, -2103, -2103, 920, -2103, -2103, -2103, -2103, -2103,
943, 1748, 944, -2103, -2103, -2103, 2952, -2103, 1792, -2103,
-2103, -2103, 961, -2103, 1759, -2103, 1366, 1755, 1768, 962,
-2103, -2103, -2103, 1772, -2103, 1766, 1770, 1761, 124, 2952,
2952, 2647, -2103, -2103, -2103, -2103, -2103, -2103, -2103, 1782,
1783, -2103, 623, -2103, -2103, 3866, 3982, -2103, 1771, -2103,
565, 1774, -2103, -2103, -2103, -2103, 568, -2103, -2103, -2103,
571, -2103, 573, 574, 576, -2103, 592, -2103, 593, -2103,
1785, 1787, 1795, 1796, -2103, 1799, 1802, -2103, -2103, -2103,
-2103, -2103, -2103, 1414, 1810, 1798, -2103, 1800, -49, -2103,
-2103, 1814, -2103, -15, 981, -2103, -2103, -2103, -2103, 2952,
372, 691, -2103, 989, 1013, 286, 1028, -2103, -2103, -2103,
-2103, -2103, -2103, 89, 1032, -2103, -2103, -2103, -2103, 726,
1054, -2103, -2103, 401, 1065, -2103, -2103, 445, 124, 191,
-2103, 1809, -2103, 1823, -2103, 1485, -2103, -2103, -2103, 1815,
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, 983, -2103,
-2103, -2103, 124, 1485, 138, 1494, -2103, -2103, 124, 124,
-2103, 1820, 214, -2103, 1819, -2103, 1776, 2952, 2960, -2103,
2952, 1656, 1656, 569, 569, 1673, 857, 1567, 2757, 5617,
2757, 2757, 2757, 2757, 2757, 1567, 1732, 1656, 1732, 3280,
1664, -2103, -2103, 1818, 1832, 2253, -2103, -2103, -2103, -2103,
-2103, 1834, -2103, -2103, 903, 5617, -2103, 2952, -2103, -2103,
-2103, -2103, 5617, 83, 5617, 1668, 1668, 1355, 1668, 654,
-2103, 1679, 1835, 210, 4229, 1836, 1837, 1838, 2960, 2960,
2960, -2103, -2103, 124, 1827, -2103, -2103, 1840, 1507, -2103,
211, -2103, -2103, -2103, -2103, 1595, -2103, 1069, 903, -2103,
903, 1085, 1845, 1086, -2103, 5617, 2952, 2662, -2103, 1100,
-2103, 903, 1638, -2103, 707, 710, -2103, 1112, 1692, 1123,
-2103, 1789, -2103, 97, -2103, 1844, 124, 124, 2952, 124,
-2103, -2103, 1485, -2103, -2103, -2103, 1621, 124, 2952, 124,
-2103, 124, -2103, 1414, 2952, 1841, 2685, -2103, -2103, -2103,
-2103, 1133, -2103, 1847, -2103, 1846, 1850, 1851, 1659, 2952,
124, 124, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
1009, 124, -2103, 2700, 2998, 1848, 124, 124, -2103, 124,
-2103, 1677, 124, -2103, 2952, 124, -2103, 1638, 5617, -2103,
1862, 544, 1862, -2103, 124, 1366, 1864, 2736, 124, 124,
-2103, 525, 2952, 863, 2952, 1152, -2103, 1858, 1153, 5617,
-2103, 37, -2103, -2103, -2103, -2103, -2103, 1009, 15, -2103,
124, -2103, 918, -2103, -2103, -116, -2103, 91, 635, -2103,
633, -2103, 323, -2103, 33, -2103, 124, 124, 124, -2103,
124, 124, 838, -2103, 124, -2103, -2103, 1859, -2103, 124,
-2103, -2103, -2103, -2103, -2103, 1546, 1561, 1565, 5617, -2103,
1664, 124, -2103, -2103, 1860, 1863, 1867, 1879, 1880, -2103,
-2103, 1881, 1883, 1887, -2103, -2103, -2103, 1888, 1889, 1894,
1895, -2103, -2103, -2103, 693, 1898, 1899, 1900, 1901, 1902,
-2103, -2103, -2103, -2103, -2103, 124, 826, -2103, -2103, 1904,
-2103, 1913, -2103, -2103, 1823, -2103, -2103, -2103, -2103, 5617,
1916, -2103, -2103, -2103, 115, 371, 371, 1682, 1683, -2103,
-2103, 1688, 1690, 1693, 580, 124, -2103, -2103, -2103, -2103,
1930, -2103, -2103, -2103, 1819, -2103, 1932, -2103, 164, 1927,
-2103, 1933, 4290, -2103, 1924, 1926, 1426, -2103, -2103, 3908,
-2103, 2952, 2952, 1228, -2103, 5617, 2055, 210, -2103, 183,
2960, 2960, 2960, 193, -2103, 228, -2103, 493, -2103, 1485,
124, -2103, -2103, 1949, 1168, -2103, 1951, -2103, 5617, -2103,
-2103, -2103, 2952, -2103, -2103, 2952, -2103, -2103, -2103, -2103,
5617, -2103, 1692, 2952, 1938, -2103, 1941, 1943, 4337, 1952,
-2103, 67, 124, -2103, 1191, -2103, -2103, 1942, 5617, -2103,
-2103, 3908, -2103, 1622, -2103, 1622, 124, 124, 124, 1197,
1207, -2103, 124, 1950, 1946, 2952, 4372, 2914, -2103, -2103,
-2103, 1485, 1414, -2103, 1955, -2103, 1801, 1964, 5617, -2103,
124, -2103, 1962, 1963, -2103, -2103, 1727, 1971, -2103, -2103,
1976, -2103, 5617, 1211, -2103, 1216, -2103, -2103, 4403, -2103,
-2103, 1219, -2103, -2103, 5617, 1965, 124, -2103, -2103, -2103,
1969, 1973, 1781, 1920, 124, 124, 1975, 1986, -2103, 448,
-2103, 1980, -2103, -2103, -2103, 1981, -2103, -2103, -2103, -2103,
-2103, -2103, -2103, 918, -2103, -2103, -2103, -2103, -116, 124,
-2103, -2103, 1249, 1983, -2103, 1984, -2103, 1985, -2103, -2103,
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, 635, -2103,
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
-2103, 633, -2103, -2103, -2103, -2103, -2103, 323, -2103, -2103,
-2103, 33, 1990, 1991, 1993, 738, 1258, -2103, 1994, 1997,
1414, 124, -2103, -2103, 1987, -2103, 1992, 1664, 2002, -2103,
124, 124, -2103, 1857, 124, -2103, 124, 124, 124, -2103,
124, 124, 124, 2952, -2103, 2014, 2015, -2103, 124, 124,
2952, -2103, -2103, 2012, 2952, 2952, -2103, -2103, 2013, -2103,
1023, 826, 1939, -2103, 1277, -2103, 5617, -2103, -2103, -2103,
2032, -2103, -2103, -2103, -2103, 390, 390, 390, 390, 390,
1820, -2103, 2026, 2037, 2028, 1820, 1927, -2103, 214, 164,
145, 145, -2103, -2103, -2103, 1278, 2039, 872, 171, -2103,
2035, 164, -2103, 2952, -2103, 2027, -2103, 1426, -2103, 2253,
5617, 2030, -2103, -2103, 1075, 2029, 2031, 1279, 2033, 2036,
2038, -2103, -2103, -2103, 2047, 40, 903, -2103, 124, 1009,
5617, 40, 5617, 1692, 2952, 2042, 4437, 1287, -2103, -2103,
-2103, -2103, -2103, 2952, -2103, 2051, -2103, -2103, -2103, -2103,
-2103, 1301, 1304, 1308, -2103, -2103, -2103, 754, -2103, 5617,
2952, 2952, 4471, -2103, 124, 124, -2103, -2103, 1964, -2103,
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
-2103, 2041, 544, 2043, 3062, -2103, 124, 124, 124, 2736,
-2103, -2103, -2103, 863, -2103, -2103, -2103, 2616, 124, -2103,
-2103, 1975, 2040, -2103, -2103, 124, 124, 2952, -2103, -2103,
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, 91,
-2103, -2103, -2103, 2952, -2103, 2952, -2103, -2103, -2103, -2103,
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
-2103, -2103, -2103, 1316, 124, 124, 2052, 750, 2048, 1319,
-2103, 1326, 938, 1337, 2054, 1338, 1353, 1354, 1360, 1368,
1378, -2103, 1379, 3360, 2057, -2103, -2103, -113, 1380, -2103,
1383, 1397, 4502, 876, 2045, -2103, 5617, 5617, 1401, 2069,
-2103, -2103, -2103, 2058, 4539, -2103, -2103, -2103, 115, -2103,
-2103, -2103, -2103, -2103, -2103, 1820, -2103, 124, -2103, -2103,
2065, 2059, -2103, 662, 171, 171, 164, -2103, 164, 145,
145, 145, 145, 145, 1071, 4573, -2103, -2103, -2103, -2103,
2952, -2103, -2103, -2103, -2103, 1647, -2103, 124, 2073, 1478,
124, -2103, 124, -2103, 4614, -2103, 2952, 2952, -2103, 4645,
1829, 2952, -2103, -2103, -2103, -2103, 1430, -2103, -2103, 5617,
5617, 2952, 1431, 2072, -2103, 954, -2103, 2952, -2103, 2063,
2068, -2103, -2103, 2075, 2084, -2103, -2103, -2103, -2103, -2103,
1961, 2074, 1442, 2087, 2090, 1445, 785, 124, -2103, -2103,
5617, 721, 2077, 28, -2103, -2103, 2062, -2103, -2103, 217,
4676, 4713, -2103, -2103, -2103, -2103, -2103, -2103, 1451, 2079,
795, 2952, 124, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
-2103, -2103, -2103, -2103, -2103, -2103, -2103, 2086, 2088, -2103,
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, 124, -2103,
2952, -2103, 553, 1469, -2103, 1471, -2103, -2103, -2103, -2103,
-2103, -2103, -2103, -2103, -2103, 2952, 2095, 2097, -2103, -2103,
-2103, 1494, 2085, -2103, 1664, -2103, 164, -2103, 1071, 2092,
171, 171, -2103, -2103, -2103, -2103, 4744, -2103, 3908, -2103,
1475, -2103, -2103, 903, 1810, -2103, 1692, 5617, -2103, 1861,
-2103, 2100, 4787, 754, -2103, 5617, -2103, 2022, 2124, 2126,
2127, 2128, 2129, 124, 124, 2131, 2133, 2134, 4832, -2103,
-2103, -2103, 2952, 124, 124, -2103, -2103, 2139, 124, -2103,
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
-2103, -2103, -2103, -2103, -2103, -2103, -2103, 2148, -2103, -2103,
-2103, -2103, -2103, 1477, -2103, -2103, -2103, -2103, 2135, -2103,
-2103, 2150, -2103, 5617, -2103, 124, 124, 938, -2103, 4863,
-2103, 2145, -2103, 2153, 2154, -2103, 4927, -2103, 2156, -2103,
-2103, 2143, 1493, 1071, -2103, 2952, 1647, -2103, -2103, 2952,
124, 2952, -2103, -2103, -2103, 5617, 1499, -2103, -2103, 2124,
124, 124, 124, 124, -2103, -2103, 2952, 2952, 124, 2952,
1504, -2103, -2103, 2157, -2103, 1508, 2159, 1526, 124, 2952,
-2103, -2103, -2103, -2103, 189, 2160, -2103, 2952, 2078, -2103,
-2103, -2103, -2103, -2103, -2103, 124, 2151, -2103, -2103, 4958,
-2103, 5617, -2103, -2103, 2158, 4992, 2022, -2103, 348, -2103,
2173, 1541, 2174, 1545, 2167, 1552, 5023, 5093, 2164, -2103,
1559, 5151, -2103, 124, 2105, -2103, -2103, -2103, -2103, 1810,
-2103, 5490, 1856, -2103, 2952, 5617, 2169, 1839, 1842, -2103,
2180, -2103, -2103, 2952, 1521, -2103, -2103, 2184, 2186, 124,
124, -2103, 124, -2103, 2647, -2103, -2103, 2952, -2103, 124,
-2103, 2952, -2103, 2175, 1560, 1566, -2103, 2182, 5521, 908,
-2103, 2187, 2188, 124, 5617, 124, 5617, 1580, -2103, -2103,
-2103, -2103, 1600, -2103, 2192, 1601, 1604, 1607, 5552, -2103,
5617, -2103, -2103, -2103, 2952, -2103, -2103, -2103, -2103, -2103,
2178, 1521, -2103, 124, -2103, 2952, -2103, -2103, 2190, 2952,
1612, 1632, 1634, 2952, 2191, -2103, -2103, -2103, 5586, 1667,
-2103, -2103, 5617, 2204, -2103, -2103, -2103, 2952, 2952, 2952,
2198, -2103, -2103, -2103, 5617, -2103, -2103, -47, 380, 1685,
-2103, 2208, 2209, -2103, -2103, -2103, 2202, 2202, 2202, -2103,
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, 541, 2212,
-2103, 2096, -2103, 1686, -2103, -2103, -2103
};
/* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
Performed when YYTABLE does not specify something else to do. Zero
means the default is an error. */
static const yytype_uint16 yydefact[] =
{
2, 0, 1, 10, 11, 9, 0, 0, 3, 151,
150, 790, 340, 538, 538, 538, 538, 538, 340, 538,
556, 538, 20, 538, 538, 159, 538, 561, 340, 155,
538, 340, 538, 538, 340, 486, 538, 538, 538, 339,
538, 783, 538, 538, 341, 792, 538, 156, 157, 786,
45, 538, 538, 538, 538, 538, 538, 538, 538, 558,
538, 538, 484, 484, 538, 538, 538, 340, 538, 0,
538, 340, 340, 538, 538, 339, 20, 340, 340, 326,
0, 538, 538, 340, 340, 538, 340, 340, 340, 340,
153, 340, 538, 212, 538, 158, 538, 538, 0, 20,
340, 538, 538, 538, 560, 340, 538, 340, 536, 538,
538, 340, 538, 538, 538, 340, 20, 340, 45, 538,
538, 154, 45, 538, 340, 538, 538, 538, 340, 538,
538, 557, 340, 538, 340, 538, 538, 538, 538, 538,
538, 340, 340, 537, 20, 340, 340, 538, 538, 538,
0, 340, 8, 340, 538, 538, 538, 784, 538, 538,
538, 538, 538, 538, 538, 538, 538, 538, 538, 538,
538, 538, 538, 538, 538, 538, 538, 538, 538, 538,
538, 538, 538, 538, 340, 538, 785, 538, 1228, 538,
1229, 538, 538, 340, 340, 538, 538, 538, 538, 538,
538, 538, 538, 1313, 1313, 1313, 1313, 1313, 1313, 612,
0, 37, 612, 74, 48, 49, 50, 66, 67, 77,
69, 70, 68, 110, 59, 0, 147, 152, 52, 71,
72, 73, 51, 60, 55, 56, 57, 61, 208, 76,
75, 58, 612, 446, 441, 454, 0, 0, 0, 457,
440, 439, 0, 509, 512, 538, 510, 0, 538, 0,
538, 546, 0, 0, 553, 53, 460, 614, 617, 623,
619, 618, 624, 625, 626, 627, 616, 633, 615, 634,
620, 0, 781, 621, 628, 630, 629, 661, 635, 637,
638, 636, 639, 640, 641, 642, 643, 622, 644, 645,
647, 648, 646, 650, 651, 649, 675, 662, 663, 664,
665, 652, 653, 654, 656, 655, 657, 658, 659, 660,
666, 667, 668, 669, 670, 671, 672, 673, 674, 632,
676, 631, 1035, 1034, 1036, 1037, 1038, 1039, 1040, 1041,
1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049, 1050, 1033,
1051, 1052, 1053, 1054, 1055, 1056, 1057, 1058, 1059, 54,
461, 1195, 1197, 1199, 1200, 1196, 1198, 1193, 1194, 462,
1241, 1242, 1243, 1244, 1245, 1246, 0, 0, 341, 0,
0, 0, 0, 0, 0, 0, 997, 35, 0, 0,
599, 0, 0, 0, 0, 0, 0, 455, 508, 482,
211, 0, 0, 0, 482, 0, 313, 340, 728, 0,
728, 539, 0, 23, 482, 0, 482, 977, 0, 994,
484, 482, 482, 482, 32, 485, 82, 445, 960, 482,
954, 106, 482, 37, 482, 0, 341, 0, 0, 64,
0, 0, 330, 44, 7, 971, 0, 0, 0, 600,
0, 0, 78, 341, 0, 991, 523, 0, 0, 0,
297, 296, 0, 0, 814, 0, 0, 341, 0, 0,
539, 0, 341, 0, 0, 0, 341, 33, 341, 22,
600, 0, 21, 0, 0, 0, 0, 0, 0, 0,
399, 341, 45, 141, 0, 0, 0, 0, 0, 0,
0, 0, 788, 341, 0, 341, 0, 0, 995, 996,
0, 340, 341, 0, 0, 0, 600, 0, 1179, 1178,
1183, 1060, 728, 1185, 728, 1175, 1177, 1061, 1166, 1169,
1172, 728, 728, 728, 1181, 1174, 1176, 728, 728, 728,
728, 1114, 728, 728, 1191, 1148, 0, 45, 1202, 1205,
1208, 1235, 341, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 1261, 0, 613, 4, 20,
20, 0, 0, 45, 5, 0, 0, 0, 0, 0,
45, 20, 0, 0, 0, 148, 165, 0, 0, 0,
0, 529, 0, 529, 0, 0, 0, 0, 529, 223,
6, 487, 538, 538, 447, 442, 0, 458, 449, 448,
456, 83, 173, 0, 0, 0, 407, 0, 406, 411,
409, 410, 408, 382, 0, 0, 352, 383, 355, 385,
384, 356, 401, 403, 396, 354, 357, 599, 399, 543,
544, 0, 381, 380, 32, 0, 603, 604, 541, 0,
601, 600, 0, 545, 600, 565, 548, 547, 601, 551,
0, 0, 0, 0, 0, 0, 0, 0, 0, 45,
0, 777, 778, 776, 0, 774, 764, 0, 0, 436,
0, 324, 0, 525, 979, 980, 976, 45, 311, 809,
811, 978, 36, 13, 599, 0, 482, 0, 193, 0,
311, 0, 185, 0, 710, 708, 844, 932, 933, 808,
805, 806, 483, 517, 223, 436, 311, 677, 988, 983,
471, 342, 0, 0, 0, 0, 0, 720, 723, 712,
0, 498, 683, 680, 681, 452, 0, 0, 501, 989,
443, 444, 459, 453, 472, 107, 500, 45, 518, 0,
200, 0, 383, 0, 0, 37, 25, 804, 801, 802,
325, 327, 0, 0, 45, 972, 973, 0, 701, 699,
687, 684, 685, 0, 0, 0, 79, 0, 45, 992,
990, 0, 0, 953, 0, 45, 0, 19, 0, 0,
0, 0, 958, 0, 0, 0, 498, 524, 0, 0,
936, 963, 600, 0, 600, 601, 140, 34, 12, 144,
577, 0, 765, 0, 0, 0, 728, 707, 705, 893,
930, 931, 0, 704, 702, 964, 400, 515, 0, 0,
0, 914, 0, 926, 925, 928, 927, 0, 692, 0,
690, 695, 0, 0, 37, 24, 0, 311, 945, 948,
0, 45, 0, 303, 299, 0, 0, 578, 311, 0,
528, 0, 1118, 1113, 528, 1150, 1180, 0, 528, 528,
528, 528, 528, 528, 1173, 311, 46, 1201, 1210, 1211,
0, 0, 45, 1234, 1236, 1237, 0, 45, 0, 1025,
1026, 0, 993, 350, 0, 0, 45, 45, 45, 1296,
1250, 45, 0, 0, 20, 43, 38, 42, 0, 40,
17, 46, 311, 133, 135, 137, 111, 0, 0, 20,
340, 149, 539, 599, 166, 147, 311, 180, 182, 184,
188, 528, 191, 528, 197, 199, 201, 210, 0, 214,
0, 45, 0, 450, 425, 0, 352, 365, 364, 377,
363, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
599, 0, 0, 599, 0, 0, 399, 405, 397, 513,
0, 0, 516, 571, 572, 576, 0, 568, 0, 570,
0, 609, 0, 0, 0, 0, 0, 555, 570, 559,
0, 0, 583, 549, 581, 0, 0, 352, 354, 552,
587, 586, 554, 678, 311, 700, 703, 706, 709, 311,
340, 0, 946, 0, 45, 759, 179, 0, 0, 0,
0, 0, 0, 313, 813, 0, 530, 0, 476, 480,
0, 470, 599, 0, 195, 186, 0, 322, 0, 209,
0, 679, 599, 0, 787, 320, 317, 314, 316, 321,
311, 728, 725, 734, 729, 0, 0, 0, 0, 0,
726, 712, 728, 0, 791, 0, 499, 540, 0, 0,
0, 18, 205, 0, 0, 0, 207, 196, 0, 495,
493, 490, 0, 45, 0, 330, 0, 0, 333, 331,
0, 45, 974, 382, 922, 969, 0, 0, 967, 0,
562, 0, 88, 89, 87, 86, 92, 91, 103, 96,
99, 98, 101, 100, 97, 102, 95, 93, 90, 94,
84, 0, 85, 198, 0, 0, 0, 0, 0, 0,
298, 0, 189, 437, 0, 45, 959, 957, 134, 816,
0, 0, 0, 293, 540, 181, 0, 580, 0, 579,
288, 288, 0, 760, 0, 728, 712, 940, 0, 0,
937, 285, 284, 63, 282, 0, 0, 0, 0, 0,
0, 0, 689, 688, 136, 14, 183, 947, 45, 950,
949, 147, 0, 104, 47, 0, 0, 696, 0, 728,
528, 0, 1147, 1117, 1112, 728, 528, 1149, 1192, 728,
528, 728, 528, 528, 528, 728, 528, 728, 528, 697,
0, 0, 0, 0, 1222, 0, 0, 1209, 1213, 1215,
1214, 45, 1204, 852, 1223, 0, 1207, 0, 0, 1238,
1233, 1230, 1231, 0, 0, 1000, 45, 45, 45, 0,
391, 392, 1030, 0, 0, 0, 0, 1262, 1264, 1265,
1266, 1268, 1267, 0, 0, 1277, 1279, 1280, 1281, 0,
0, 1285, 45, 0, 0, 1300, 28, 37, 0, 0,
39, 0, 30, 160, 117, 311, 340, 119, 121, 0,
122, 115, 123, 131, 130, 124, 125, 126, 0, 113,
116, 26, 0, 311, 0, 0, 145, 178, 0, 0,
223, 223, 0, 225, 218, 222, 0, 0, 0, 353,
0, 360, 362, 359, 358, 376, 378, 372, 366, 505,
369, 367, 370, 368, 371, 373, 375, 361, 374, 379,
599, 412, 390, 0, 344, 0, 415, 416, 402, 413,
404, 0, 599, 514, 0, 533, 531, 0, 599, 567,
574, 575, 573, 602, 611, 606, 608, 610, 607, 605,
566, 550, 0, 0, 0, 352, 0, 0, 0, 0,
0, 698, 780, 0, 790, 793, 783, 0, 792, 786,
0, 784, 785, 782, 775, 0, 430, 0, 0, 507,
0, 0, 0, 0, 812, 478, 477, 0, 475, 0,
194, 0, 528, 807, 428, 429, 433, 0, 0, 0,
315, 318, 177, 0, 599, 0, 0, 0, 0, 0,
713, 724, 311, 463, 728, 682, 0, 482, 0, 0,
202, 0, 395, 982, 0, 0, 0, 16, 803, 328,
338, 0, 334, 336, 332, 0, 0, 0, 0, 0,
0, 0, 966, 686, 563, 81, 80, 129, 127, 128,
341, 0, 488, 424, 0, 0, 0, 0, 192, 0,
521, 0, 0, 728, 0, 0, 65, 528, 506, 602,
139, 0, 143, 45, 0, 712, 0, 0, 0, 0,
935, 0, 0, 0, 0, 0, 915, 917, 0, 693,
691, 0, 45, 952, 45, 951, 146, 341, 0, 503,
0, 1182, 0, 728, 1184, 0, 728, 0, 0, 728,
0, 728, 0, 728, 0, 728, 0, 0, 0, 45,
0, 0, 0, 1212, 0, 1203, 1206, 0, 1240, 0,
1004, 1002, 1003, 45, 999, 0, 0, 0, 351, 599,
599, 0, 1029, 1032, 0, 0, 0, 0, 0, 45,
1247, 0, 0, 0, 45, 1248, 1287, 1289, 0, 0,
1292, 1294, 45, 1249, 0, 0, 0, 0, 0, 0,
45, 1299, 15, 29, 41, 0, 174, 161, 118, 0,
45, 0, 45, 27, 160, 540, 540, 170, 173, 169,
0, 187, 190, 215, 0, 0, 0, 248, 246, 253,
250, 264, 257, 262, 0, 0, 216, 239, 251, 243,
254, 244, 259, 245, 0, 238, 0, 233, 230, 219,
220, 0, 0, 426, 352, 0, 388, 599, 348, 345,
346, 0, 399, 0, 535, 534, 0, 0, 582, 353,
0, 0, 0, 352, 589, 352, 593, 352, 591, 311,
0, 599, 519, 0, 0, 981, 0, 312, 479, 481,
173, 323, 0, 599, 520, 0, 985, 599, 984, 319,
321, 727, 0, 0, 0, 737, 0, 0, 0, 0,
711, 465, 482, 502, 0, 204, 203, 382, 494, 491,
489, 0, 492, 0, 329, 0, 0, 0, 0, 0,
0, 968, 0, 1014, 0, 0, 423, 418, 955, 956,
722, 311, 962, 438, 0, 817, 819, 825, 295, 294,
0, 288, 0, 0, 290, 289, 0, 761, 762, 714,
0, 944, 943, 0, 941, 0, 938, 283, 0, 1020,
1009, 0, 1007, 1010, 756, 0, 0, 929, 921, 694,
0, 0, 0, 0, 0, 301, 0, 300, 308, 0,
1191, 0, 1191, 1191, 1127, 0, 1121, 1123, 1124, 1122,
728, 1126, 1125, 0, 1191, 728, 1145, 1144, 0, 0,
1188, 1187, 0, 0, 1191, 0, 1191, 0, 728, 1066,
1070, 1071, 1072, 1068, 1069, 1073, 1074, 1067, 0, 1155,
1159, 1160, 1161, 1157, 1158, 1162, 1163, 1156, 1165, 1164,
728, 0, 1108, 1110, 1111, 1109, 728, 0, 1138, 1139,
728, 0, 0, 0, 0, 0, 0, 1224, 0, 0,
853, 0, 1232, 1001, 0, 1027, 0, 599, 0, 1031,
0, 0, 45, 0, 0, 1263, 0, 0, 0, 1278,
0, 0, 0, 0, 1286, 0, 0, 45, 0, 0,
0, 45, 1301, 0, 0, 0, 109, 795, 0, 112,
0, 174, 0, 147, 0, 172, 171, 268, 254, 267,
0, 256, 261, 255, 260, 0, 0, 0, 0, 0,
223, 213, 224, 242, 0, 223, 235, 236, 0, 0,
0, 0, 279, 224, 280, 0, 0, 228, 269, 274,
277, 230, 221, 0, 504, 0, 414, 386, 389, 0,
347, 0, 532, 569, 570, 0, 0, 352, 0, 0,
0, 779, 773, 789, 0, 0, 0, 526, 0, 341,
527, 0, 987, 0, 0, 0, 741, 0, 739, 736,
731, 735, 733, 0, 45, 0, 464, 451, 206, 335,
337, 0, 0, 0, 970, 965, 132, 0, 1013, 422,
0, 0, 417, 961, 0, 0, 45, 815, 826, 827,
832, 836, 829, 837, 838, 839, 833, 835, 834, 830,
831, 0, 0, 0, 0, 286, 0, 0, 0, 0,
939, 934, 473, 0, 1006, 728, 916, 0, 0, 891,
105, 307, 302, 304, 306, 0, 0, 0, 1076, 728,
1077, 1078, 45, 1119, 728, 1146, 1142, 728, 1191, 0,
1075, 45, 1079, 0, 1080, 0, 1064, 728, 1153, 728,
1106, 728, 1136, 728, 1216, 1217, 1218, 1226, 1227, 45,
1221, 1219, 1220, 0, 0, 0, 0, 394, 0, 0,
1274, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1297, 0, 0, 0, 45, 45, 0, 0, 1307,
0, 0, 0, 0, 0, 31, 176, 175, 0, 0,
120, 114, 108, 0, 0, 162, 599, 167, 0, 249,
247, 265, 258, 263, 217, 223, 599, 0, 241, 237,
224, 0, 234, 0, 271, 270, 0, 226, 230, 0,
0, 0, 0, 0, 231, 0, 427, 387, 349, 398,
0, 584, 596, 598, 597, 0, 431, 0, 0, 810,
0, 434, 0, 986, 757, 730, 0, 0, 45, 0,
0, 0, 845, 975, 846, 1019, 0, 1016, 1018, 421,
420, 0, 0, 0, 818, 0, 828, 0, 289, 0,
0, 766, 763, 720, 715, 716, 718, 719, 942, 1008,
1012, 0, 0, 382, 0, 0, 0, 0, 310, 309,
522, 0, 0, 0, 1120, 1143, 0, 1190, 1189, 0,
0, 0, 1065, 1154, 1107, 1137, 1225, 1239, 0, 0,
393, 0, 0, 1273, 1270, 903, 904, 905, 902, 907,
901, 908, 900, 899, 898, 906, 894, 0, 0, 45,
1269, 1272, 1271, 1283, 1284, 1282, 1290, 1288, 0, 1291,
0, 1293, 0, 0, 1253, 0, 1309, 1310, 45, 1302,
1303, 1304, 1305, 1311, 1312, 0, 0, 0, 796, 163,
164, 0, 0, 240, 599, 242, 0, 281, 229, 0,
273, 272, 275, 276, 278, 474, 0, 771, 770, 772,
0, 768, 432, 0, 998, 435, 0, 742, 740, 0,
732, 0, 0, 0, 1015, 419, 847, 0, 0, 0,
0, 912, 0, 0, 0, 0, 0, 0, 0, 287,
292, 291, 0, 0, 0, 1005, 918, 919, 0, 843,
892, 892, 305, 1092, 1091, 1090, 1097, 1098, 1099, 1096,
1093, 1095, 1094, 1103, 1100, 1101, 1102, 0, 1087, 1131,
1130, 1132, 1133, 0, 1192, 1082, 1084, 1083, 0, 1086,
1085, 0, 1028, 1276, 1275, 0, 0, 0, 1298, 0,
1255, 0, 45, 1257, 1259, 1308, 0, 797, 0, 173,
266, 0, 0, 228, 227, 0, 0, 767, 511, 0,
0, 0, 467, 1017, 824, 823, 0, 821, 863, 860,
0, 0, 0, 0, 910, 911, 0, 0, 0, 0,
0, 717, 923, 1011, 45, 0, 0, 0, 0, 0,
1129, 1186, 1081, 45, 0, 0, 895, 0, 0, 1254,
45, 1251, 45, 1252, 1306, 0, 0, 252, 232, 496,
769, 758, 745, 738, 743, 0, 0, 820, 866, 861,
0, 0, 0, 0, 0, 0, 0, 849, 0, 855,
0, 468, 721, 0, 0, 842, 45, 45, 889, 1089,
1088, 0, 0, 896, 0, 1295, 0, 0, 0, 800,
794, 798, 168, 0, 0, 466, 822, 0, 0, 0,
0, 858, 0, 841, 0, 909, 859, 0, 848, 0,
854, 0, 924, 0, 0, 0, 1128, 0, 0, 355,
1256, 0, 0, 0, 497, 0, 748, 0, 746, 749,
864, 865, 0, 867, 869, 0, 0, 0, 850, 856,
469, 920, 890, 888, 0, 897, 45, 45, 799, 751,
752, 0, 744, 0, 862, 0, 857, 840, 0, 0,
0, 0, 0, 0, 750, 753, 747, 868, 0, 0,
872, 913, 851, 1022, 1258, 1260, 754, 0, 0, 0,
870, 45, 1021, 755, 874, 873, 45, 0, 0, 0,
875, 880, 882, 883, 1023, 1024, 0, 0, 0, 45,
871, 45, 45, 599, 886, 885, 884, 876, 0, 878,
879, 0, 881, 0, 45, 887, 877
};
/* YYPGOTO[NTERM-NUM]. */
static const yytype_int16 yypgoto[] =
{
-2103, -2103, -2103, -2103, -2103, -20, 2004, 1317, -2103, -2103,
-688, -31, -2103, -2103, -408, -2103, 946, -2103, -50, 1318,
-2103, -2103, -2103, 2626, 216, -2103, -2103, -2103, -2103, -2103,
-2103, 338, 631, 1040, -2103, -2103, -2103, -2103, -2103, -2103,
-2103, -2103, -180, -899, -2103, -2103, -2103, 1136, 632, 1648,
-2103, -46, -1581, 346, -2103, -2103, -2103, -2103, -2103, -2103,
1644, -274, -194, -2103, -2103, -2103, 1642, -2103, -636, -2103,
-2103, -2103, -2103, 1529, -2103, -2103, 930, -1269, -1542, 1306,
607, -1550, -42, 109, 1309, -2103, 330, 341, -1818, -2103,
-1548, -1246, -1543, -445, -2103, 135, -1609, -1615, -776, -2103,
-2103, 751, 1097, 516, 71, 250, -2103, 779, -2103, -2103,
-2103, -2103, -2103, 58, -2103, -1465, -358, 1233, -2103, 1218,
851, 873, -378, -2103, -2103, 1179, -2103, -2103, -2103, -2103,
562, 563, 2201, 144, -366, -1321, 343, -326, -1027, 1169,
-544, -508, 1420, -223, 1822, -876, -879, -2103, -2103, -614,
-602, -208, -2103, -848, -2103, -638, -952, -1124, -2103, -2103,
-2103, 322, -2103, -2103, 1569, -2103, -2103, 2049, -2103, 2050,
-2103, -2103, 879, -2103, -371, 18, -2103, -2103, 2056, 2061,
-2103, 841, -2103, -737, -204, 1502, -2103, 986, -2103, -2103,
255, -2103, 1248, 642, -2103, 4031, -413, -1107, -2103, -2103,
-2103, -2103, -2103, -2103, -2103, -186, -2103, 643, -926, -2103,
-2103, -2103, 301, -1309, -632, 1299, -931, -380, -192, -368,
673, -58, -2103, -2103, -2103, 1645, -2103, -2103, 1227, -2103,
-2103, 1200, -2103, 1470, -1986, 1129, -2103, -2103, -2103, 1653,
-2103, 1649, -2103, 1654, -2103, 1652, -993, -2103, -2103, -2103,
-13, -243, -2103, -2103, -2103, -395, -2103, 811, 898, -487,
897, -2103, 156, -2103, -2103, -2103, -227, -2103, -2103, -2103,
-1903, -2103, -2103, -2103, -2103, -2103, -1454, -530, 310, -2103,
-69, -2103, 1517, 1307, -2103, -2103, 1310, -2103, -2103, -2103,
-2103, -191, -2103, -2103, 1239, -2103, -2103, 1281, -2103, 377,
1303, -2103, -2103, -871, -2103, -1896, -2103, -120, -2103, -2103,
345, -2103, -767, -384, 1896, 1547, -2103, -2103, -1553, -2103,
-2103, -2103, -2103, -2103, -62, -2103, -2103, -2103, -202, -2103,
-225, -2103, -242, -2103, -240, -1890, -1195, -787, -2103, 17,
-477, -1065, -2102, -2103, -2103, -2103, -491, -1820, 596, -2103,
-765, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
-488, -1461, 860, -2103, 347, -2103, 1694, -2103, 1865, -2103,
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -1444, 904,
-2103, 1605, -2103, -2103, -2103, -2103, 1982, -2103, -2103, -2103,
408, 1957, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
-2103, -2103, -2103, 824, -2103, -2103, -2103, 355, -2103, -2103,
-2103, -2103, 68, -1952, -2103, -2103, -2103, -2103, -2103, -2103,
-2103, -2103, -2103, -2103, -2103, -2103, -2103, 561, 567, -531,
-936, -912, -1438, -1445, -1427, -1419, -2103, -1417, -1416, -1392,
-2103, -2103, -2103, -2103, -2103, 550, -2103, -2103, -2103, -2103,
-2103, 598, -1407, -1401, -2103, -2103, -2103, 548, -2103, -2103,
595, -2103, 96, -2103, -2103, -2103, -2103, 566, -2103, -2103,
-2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103, -2103,
-2103, -2103, -2103, 349, -2103, 351, 32, -2103, -2103, -2103,
-2103, -2103, -2103, -2103, -2103, 1170, -2103, 1162, -2103, -837,
-2103, 334, -2103, -2103, -2103, 554, 858, -2103, -2103, -2103,
1522, -2103, -2103, -2103, -2103, -2103, -2036, 22, -2103, -2103,
-2103, -2103, 839, -2103, -2103, -2103, -2103, -2103, -2103, 177,
-2103, 836, -2103, -2103, -2103, -2103, 831, -2103, -2103, -2103,
-2103, -2103, 825, -2103, 157, -2103, 1509
};
/* YYDEFGOTO[NTERM-NUM]. */
static const yytype_int16 yydefgoto[] =
{
-1, 1, 6, 7, 209, 387, 210, 844, 755, 211,
910, 623, 808, 693, 573, 908, 909, 444, 2262, 1227,
1518, 212, 213, 624, 1131, 1132, 214, 215, 216, 583,
1298, 1299, 1135, 1300, 217, 218, 219, 220, 1160, 221,
222, 1161, 223, 586, 224, 225, 226, 227, 1596, 1597,
925, 1608, 944, 1886, 228, 229, 230, 231, 232, 233,
789, 1171, 1172, 234, 235, 236, 750, 1083, 1084, 237,
238, 714, 456, 937, 938, 1624, 939, 940, 1924, 1634,
1639, 1640, 1925, 1926, 1635, 1636, 1637, 1626, 1627, 1628,
1629, 1898, 1631, 1632, 1633, 1900, 2144, 1928, 1929, 1930,
1173, 1174, 1490, 1491, 2015, 1745, 1152, 1153, 239, 461,
240, 854, 2032, 2033, 1777, 2034, 1034, 722, 723, 1057,
1058, 1046, 1047, 241, 760, 761, 762, 763, 1099, 1451,
1452, 1453, 400, 377, 407, 1343, 1648, 1344, 892, 1006,
626, 645, 627, 628, 629, 630, 2078, 1086, 977, 1938,
827, 631, 632, 633, 634, 635, 1348, 1650, 636, 1318,
1935, 1416, 1397, 1417, 1027, 1144, 242, 243, 1976, 244,
245, 696, 1039, 1040, 713, 426, 246, 247, 248, 249,
1090, 1091, 1445, 1945, 1946, 1077, 250, 251, 252, 253,
1209, 254, 980, 1356, 255, 379, 731, 1434, 256, 257,
258, 259, 260, 261, 656, 648, 986, 987, 988, 262,
263, 264, 1003, 1004, 1009, 1010, 1011, 1345, 773, 649,
805, 568, 265, 266, 267, 717, 268, 733, 734, 269,
771, 772, 270, 502, 839, 840, 842, 271, 272, 769,
273, 824, 274, 818, 275, 705, 1074, 276, 277, 2194,
2195, 2196, 2197, 1731, 1071, 410, 725, 726, 1070, 1696,
1760, 1967, 1968, 2453, 2454, 2527, 2528, 2550, 2564, 2565,
1765, 1965, 278, 279, 1747, 677, 813, 814, 1953, 2300,
2301, 1954, 674, 675, 280, 281, 282, 283, 2108, 2109,
2490, 2491, 284, 758, 759, 285, 710, 711, 286, 689,
690, 287, 288, 1150, 1737, 2184, 2406, 2407, 1997, 1998,
1999, 2000, 2001, 707, 2002, 2003, 2004, 2468, 1234, 2005,
2470, 2006, 2007, 2008, 2409, 2458, 2499, 2532, 2533, 2569,
2570, 2589, 2590, 2591, 2592, 2593, 2604, 2009, 2206, 2426,
820, 2083, 2246, 2247, 2248, 2010, 832, 1505, 1506, 2027,
1167, 2423, 289, 290, 291, 292, 293, 294, 295, 296,
801, 1169, 1170, 1753, 1754, 297, 848, 298, 784, 299,
785, 300, 1147, 301, 302, 303, 304, 305, 1107, 1108,
306, 766, 307, 308, 309, 685, 686, 310, 311, 1419,
1686, 719, 312, 313, 780, 314, 315, 316, 317, 318,
319, 320, 1244, 1245, 321, 1177, 1761, 1762, 2335, 322,
1724, 2176, 2177, 1763, 323, 2582, 324, 325, 326, 327,
1253, 328, 329, 330, 331, 332, 333, 1210, 1808, 866,
1786, 1787, 1788, 1812, 1813, 1814, 2368, 1815, 1816, 1789,
2212, 2480, 2357, 334, 1216, 1836, 335, 336, 337, 338,
1200, 1790, 1791, 1792, 2363, 339, 1218, 1840, 340, 1206,
1795, 1796, 1797, 341, 342, 343, 1212, 1830, 344, 345,
346, 347, 348, 349, 350, 351, 352, 353, 354, 355,
356, 357, 358, 1801, 1802, 867, 1527, 359, 360, 361,
362, 363, 364, 877, 878, 879, 1228, 1229, 1230, 1235,
1846, 1847, 365, 366, 367, 1241, 1242, 368, 883, 884,
885, 369, 370, 371, 372, 373, 2263, 2264, 2441, 2443,
374, 1256, 1257, 1258, 1259, 1260, 1261, 1262, 2079, 2080,
1264, 1265, 1266, 1267, 1268, 1270, 1271, 2094, 900, 2092,
375, 1274, 1275, 2098, 2099, 2104, 561
};
/* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
positive, shift that token. If negative, reduce the rule whose
number is the opposite. If YYTABLE_NINF, syntax error. */
static const yytype_int16 yytable[] =
{
413, 825, 1105, 682, 1401, 833, 834, 835, 836, 821,
697, 708, 678, 874, 1475, 1252, 1720, 1092, 1251, 1645,
978, 1008, 1008, 1350, 1254, 747, 1306, 1894, 1012, 1927,
571, 425, 425, 720, 646, 2178, 982, 1755, 433, 646,
1748, 2202, 1625, 735, 1237, 738, 2086, 1487, 2088, 647,
741, 742, 743, 1778, 647, 1357, 440, 796, 744, 1081,
2265, 746, 1190, 748, 1658, 1630, 1897, 460, 479, 946,
751, 1899, 482, 653, 1377, 1974, 657, 659, 1430, 462,
-564, 427, 1189, 1913, 1917, 1822, 405, 777, 816, 1932,
1811, 405, 1821, 797, 1834, 970, 477, 2128, -566, 1959,
405, 793, 1063, 1823, 2341, 1476, 798, 804, 1770, 8,
806, 1824, 809, 1825, 1826, 1007, 1007, 701, 905, -542,
2, 3, 2359, 1828, 504, 828, 1347, 1347, 1799, 1829,
1571, 1615, 1616, 1378, 906, 2594, 1817, 843, 1827, 846,
1835, 996, 1547, 1455, 424, -585, 852, 1025, 1396, 376,
1794, 1251, 1508, 1605, 574, 1064, 378, 671, -594, 672,
1919, 598, 384, 1981, 1982, 1983, 728, 1550, -528, 424,
-594, 1202, 391, 1496, 1415, 393, 2141, 408, 396, 1919,
1920, 1921, 1456, 1065, 600, 402, 886, 1775, -564, 409,
737, -595, 972, 412, 585, -138, 905, 702, 687, -566,
-142, -588, 2266, -595, 1467, 1468, 985, 1621, 2142, -62,
2483, 431, -566, -588, 753, 435, 436, 811, 408, 1232,
424, 441, 442, 1066, 1780, 1001, 500, 447, 448, 1312,
450, 451, 452, 453, 1067, 454, -592, 1469, 2267, 1858,
815, -585, 424, 791, 463, 1771, 972, -340, -592, 467,
799, 469, 646, 424, 1477, 472, 1457, 981, 2360, 476,
-542, 478, 1068, -340, 1622, 1223, -594, 647, 484, 1088,
4, 2595, 488, 989, 424, 2436, 491, 991, 493, 1106,
598, 424, -528, 1163, 998, 501, 503, 621, 810, 505,
506, -340, 1516, 424, 1922, 512, 996, 513, 1572, -595,
1551, 517, 443, 1552, 424, 2134, 2135, 2283, 2081, -588,
2133, 2085, 2361, 1922, 1036, 1782, 1623, 1573, 931, 424,
424, 1975, 1712, 2362, 857, 1041, 971, 424, 544, -564,
546, 424, 424, 1072, 1168, 698, -138, 551, 552, 424,
-566, -142, 1044, 424, -592, 673, 676, 1093, 1658, 699,
-62, 683, 684, 688, 684, 1069, 692, 694, 1051, 510,
700, 2178, 704, 706, 706, 709, 2129, 1008, 712, 1901,
1903, 716, 598, 712, 1351, -383, 2131, 5, 727, 1610,
1811, 732, -585, 712, 915, 712, 1822, 1559, -1116, 425,
712, 712, 712, 1821, 927, 928, 929, 930, 712, 1834,
745, 712, 1513, 712, 1823, 1447, 2087, -594, 2365, 756,
757, 1704, 1824, 1507, 1825, 1826, 768, 770, 646, 1651,
1165, 776, 646, 1515, 1828, 511, 1817, 598, 783, 646,
1829, 787, 1719, 647, 1002, 1158, 1185, 647, 740, 1827,
-595, 2182, 829, 800, 647, 1835, 807, 1664, 1666, 1668,
-588, 972, 727, 817, 819, 819, 1606, 823, 800, 997,
572, 1375, 999, 1621, 831, 831, 831, 831, 831, 1564,
841, 1442, 1008, 845, 2037, 847, 783, 1565, 1464, 850,
-1141, 996, 853, 996, 1026, -592, 858, 592, 594, 1187,
996, 567, 1685, 599, 1566, 598, 2497, 876, 1892, 1893,
1197, -590, 1749, 598, 1349, 2366, 1236, 1045, 2596, 1304,
2561, 2562, 575, -590, 1780, 875, 2367, 1219, 2537, 424,
1622, 2228, 2469, 911, 2290, 2291, 593, 2288, 2498, -1116,
917, 1781, 598, 899, 598, -1063, 2076, 2597, 576, 621,
598, 907, 2529, 1305, 912, 913, 914, 700, 698, 902,
903, 724, 920, 921, 1283, -528, 926, 700, 700, 700,
700, 918, 699, 2192, 934, 935, 1007, 2205, 1307, 424,
1897, 2209, 1623, 598, 951, 1899, 598, 601, 952, 598,
646, 598, 598, 1098, 598, 2285, 1310, 1110, 1910, 621,
1340, 1742, 1809, 2465, 1819, 647, 1832, 2598, 1838, 2529,
598, 598, 577, -1152, 1155, 1782, 967, 2304, 1783, -590,
1157, -1168, 1159, 2539, 424, 1311, 1810, 1911, 1820, 1021,
1833, -1141, 1839, 578, 1365, 1366, 1367, 1368, 1369, 584,
716, 1014, 768, 823, 817, 704, 1019, 1032, 591, 847,
-1171, 1625, -1105, 1567, 1568, 1585, 2127, 700, -1135, 1184,
996, 972, 1186, -528, 424, 851, 1381, 1233, 1233, 992,
2576, 1382, 981, 993, 1630, 712, 1156, -528, 1043, 2596,
700, 791, 1418, 424, 2583, 1023, -1063, 2393, 2139, 2140,
1008, -1115, 1859, 2287, -1140, 1251, 1643, -1062, 1024, -1151,
-1167, 995, -1170, 1060, -384, 1105, 1105, 911, 2597, 1842,
1843, 1844, 1422, 1848, 1849, 922, 1560, 1092, -1104, -1134,
-383, 2610, 2612, -384, 1100, 923, 637, 1803, 1082, 1803,
1087, 1743, 970, 1089, 2616, 973, 2343, 1357, 1134, 1664,
1666, 1668, 1586, 587, -385, 1139, 1103, 2344, 2345, 1145,
1008, 1008, 1008, 2346, -1152, 2347, 1133, 1587, 1588, 1589,
-590, 1384, -1168, -388, 2348, 1140, 2349, 1141, 2350, 1759,
405, 2175, 1148, 588, 1151, 976, 1964, 700, 406, 646,
646, 646, 646, 646, 1007, 1385, 1644, 1002, 1002, 1053,
673, -1171, 589, -1105, 647, 647, 647, 647, 647, -1135,
1386, 1103, 1054, 579, 580, 1387, 1388, 700, -386, 590,
1061, 1192, 1389, 1705, 791, 1706, 1181, 2235, 2446, 2236,
976, 25, 700, 1062, 1293, 700, 29, 1294, 2237, 1182,
2238, 1193, -1115, 2435, 1780, -1140, 1780, 791, -1062, 1279,
-1151, -1167, 1238, -1170, 1663, 1665, 1667, 1243, 47, 48,
1352, 1781, 1280, 1781, 1884, 595, 1255, 1263, 1269, -1104,
-1134, 1273, 1885, 1353, 1358, 1240, 2127, 996, 996, 996,
996, 996, 951, 1407, 596, 1443, 952, 1359, 1759, 1592,
597, 1276, 845, 953, 954, 2479, 1408, 2425, 1693, -231,
2351, 50, 1809, 2352, 1278, 652, 598, 1301, 2139, 2140,
1411, 1316, 90, -528, 967, 1819, -793, -793, 1804, 1302,
1804, 1832, 95, 1412, 660, 1838, 1810, 2380, 1439, 1313,
581, 972, 2381, 1461, 424, 1782, -853, 1782, 1783, 1820,
1783, 1440, 1805, 1784, 1805, 1833, 1462, 1598, 1479, 1839,
650, 1785, 1806, 661, 1806, 658, 1390, 1807, 1030, 1807,
1697, 1480, 1699, 2239, 2240, 1604, 2241, 2242, 121, 662,
2463, 1482, 1485, 2119, 2120, 2121, 2122, 2123, 1203, 1204,
2235, 1207, 2236, 2391, 1483, 1486, 2461, 1391, 2353, 1023,
1499, 2237, 1653, 2238, 1395, 663, 1654, 2243, 1656, 668,
669, 118, 1493, 1500, 1251, 1220, 1221, 664, 122, 1553,
1601, 1602, 673, 2091, 2115, 2318, 1251, 1561, 1399, 2089,
2090, 1507, 1554, 2011, 688, 665, 46, 2100, 2101, 666,
1562, 1392, 667, 1651, 670, 2084, 405, 709, 1222, 2244,
1673, 1482, 1008, 1008, 1008, 1770, 2354, 2355, 2356, 2157,
679, 2299, 2245, 1681, 1563, 2162, 1569, 1685, 721, 74,
1574, 2536, 1432, 911, 1692, 1875, 1876, 732, 680, 1570,
1941, 1458, 681, 1575, 2067, 2068, 2535, 1347, 1347, 1347,
1347, 1347, 1582, 757, 1303, 1576, 1703, 1284, 1577, 1578,
1579, 695, 96, 1590, 1700, 1583, 2156, 1671, 770, 1251,
992, 1580, 1581, 703, 993, 1415, 1591, 2139, 2140, 2319,
1672, 642, 643, 1249, 1053, 1481, 2239, 2240, 994, 2241,
2242, 1507, 109, 1507, 1722, 715, 1675, 1677, 1352, 1780,
1285, 730, 995, 718, 1611, 1199, 1947, 1665, 1667, 1205,
1683, 1680, 736, 1455, 1211, 749, 1781, 1215, 1217, 754,
2243, 1687, 764, 1684, 767, 602, 639, 774, 1511, 788,
640, 1713, 1287, 775, 1688, 1734, 641, 642, 643, 778,
1002, 1774, 1223, 1224, 1714, 781, 1225, 1226, 616, 782,
1766, 1249, 1771, 2320, 1383, 786, 1288, 618, 1289, 603,
1902, 1904, 2244, 1767, 1769, 2321, 1411, 2322, 2323, 1857,
2324, 1542, 1055, 2325, 1056, 2245, 1308, 611, 1309, 1957,
790, 612, 613, 614, 615, 619, 1555, 1556, 1557, 1249,
1782, 1290, 25, 1783, 616, 1249, 1291, 29, 1784, 794,
1292, 617, 1978, 618, 1293, 1461, 1785, 1294, 1984, 2019,
795, 729, 1584, 620, 1499, 2273, 2274, 2023, 1985, 47,
48, 882, 2020, 1354, 609, 610, 1457, 2021, 611, 1295,
2024, 619, 612, 613, 614, 615, 822, 1593, 907, 2038,
830, 2040, 2041, 1296, 1732, 616, 855, 2049, 856, 1297,
644, 859, 617, 2045, 618, 861, 2069, 1939, -1191, 620,
2050, 1603, 2299, 2052, 2326, 2054, 2327, 700, 992, 2070,
621, 1313, 993, 90, 880, 2116, 2136, -588, 1944, 642,
643, 1955, 619, 95, 1363, 2167, 994, 1779, 2117, 2137,
1936, 1371, 1372, 1961, 881, 2420, 424, 1963, 2168, 1544,
995, 1951, 1544, 1233, 1233, 1233, 1544, 1233, 1233, 904,
620, 1850, 2172, 2147, 1549, 2173, 621, 2232, 887, 2174,
894, 1977, 622, 860, 1544, 862, 895, 2227, 791, 121,
2233, 1284, 863, 864, 865, 2249, 1544, 2234, 868, 869,
870, 871, 1669, 872, 873, 1610, 1251, 424, 2250, 2252,
992, 1766, 1499, 896, 993, 2292, 2293, 2294, 1766, 916,
1097, 642, 643, 1993, 2253, 2254, 1482, 621, 622, 2378,
2399, 2255, 1251, 150, 1285, 897, 1482, 2258, 2268, 2256,
1286, 1482, 995, 943, 985, 1695, 1695, 898, 1695, 2257,
2259, 2269, 2605, 2606, 2270, 1482, 712, 901, 1082, 2276,
1082, 2514, 2515, 1707, 919, 1360, 1287, 972, 2271, 1361,
611, 625, 2277, 973, 612, 613, 614, 615, 974, 622,
1599, 1213, 1214, 646, 1002, 975, 996, 616, 2313, 1544,
1288, 976, 1289, 1746, 617, 1730, 618, 990, 647, 979,
1181, 2314, 2316, 1499, 1151, 1523, 1948, 1949, 1950, 1544,
1744, 1526, 1772, 2337, 1773, 1529, 2339, 1531, 1529, 1529,
700, 1533, 2371, 1535, 619, 1290, 1000, 2382, 811, 2382,
1291, 1020, 1029, 2396, 1292, 2429, 1035, 1776, 1293, 1845,
2383, 1294, 2384, 1233, 1233, 1233, 2397, 1031, 2430, 1607,
1033, 2136, 620, 1243, 611, 1042, 1048, 2456, 612, 613,
614, 615, 1249, 1295, 2448, 1052, 1499, 2560, 1240, 1255,
2457, 616, 408, 1076, 1263, 2472, 1759, 1296, 617, 2475,
618, 611, 1269, 1297, 2477, 612, 613, 614, 615, 424,
1273, 1073, 803, 642, 643, 1078, 970, 2478, 616, 1461,
1134, 1094, 1890, 1499, 616, 617, 1095, 618, 619, 621,
1766, 2525, 2501, 618, 1883, 1096, 2503, 2509, 2249, 2422,
1101, 1109, 951, 2505, 2249, 1111, 952, 1164, 2158, 1138,
2510, 2542, 1175, 953, 954, 619, 620, 2543, 2551, 955,
956, 619, 958, 2160, 1912, 960, 961, 962, 963, 964,
1178, 2552, 966, 1179, 967, 968, 1188, 1923, 2553, 1461,
1191, 622, 1499, 620, 1194, 1181, 2147, 1202, 1208, 620,
1249, 2554, 2556, 424, 779, 2557, 1707, 1166, 2558, 1707,
1707, 1707, 1231, 2573, 1249, 1272, 1281, 791, 1233, 1952,
2382, 1233, 2382, 621, 2204, 1105, 598, 2464, 1507, 791,
424, 1317, 2297, 2574, 1473, 2575, 644, 611, 1320, 826,
985, 612, 613, 614, 615, 952, 1341, 1682, 992, 838,
621, 712, 993, 1342, 616, 2579, 621, 993, 951, 642,
643, 617, 952, 618, 1370, -343, 994, 1373, 2580, 953,
954, 1986, 1379, 2599, 1647, 622, 956, 1380, 958, 1410,
995, 960, 961, 962, 963, 964, 2600, 2615, 2512, 1089,
967, 619, 1400, 562, 563, 564, 565, 566, 1402, 1424,
1425, 1426, 622, 888, 889, 890, 891, 893, 622, 2340,
1427, 1428, 791, 1429, 2534, 1105, 2281, 951, 791, 620,
1438, 952, 1740, 2030, 2031, 1441, 2284, 1444, 953, 954,
1446, 1450, -936, 1459, 955, 956, 1460, 958, 1471, 1478,
960, 961, 962, 963, 964, 1465, 1494, 655, 2048, 967,
1497, 1233, 1466, 1470, 1484, 1498, 424, 641, 642, 643,
1501, 1502, 945, 947, 948, 1503, 949, 1504, 2534, 616,
1512, 1514, 1521, 950, 1055, 1524, 621, 992, 618, 611,
1536, 993, 1537, 612, 613, 614, 615, 826, 642, 643,
1538, 1539, 2082, 1489, 1540, 994, 616, 1541, 1544, 1545,
1240, 1546, 1549, 617, 1595, 618, 619, 2097, 922, 995,
1600, 2103, 2414, 2415, 1638, 1614, 1615, 1616, 1641, 1646,
1647, 1652, 376, 1657, 1660, 1661, 1662, 1617, 622, 1028,
1670, 1233, 1676, 619, 620, 406, 1618, 752, 985, 1693,
1702, 1716, 1710, 1715, 1038, 1717, 1718, 1456, 1734, 1729,
1741, 1750, 1423, 1768, 1851, 1860, 1855, 1854, 1861, 1619,
25, 620, 1862, 1431, 1620, 29, 752, 2130, 1923, 1923,
1923, 644, 1059, 752, 1863, 1864, 1866, 1856, 1867, 1075,
1923, 812, 1868, 1870, 1871, 1079, 1080, 47, 48, 1872,
1873, 621, 1621, 1877, 1878, 1879, 1880, 1881, 424, 1887,
1889, 1895, 2460, 2462, 2170, 2398, 611, 688, 1905, 1906,
612, 613, 614, 615, 1907, 1915, 1908, 1233, 621, 1909,
1918, 569, 1931, 616, 2113, 1936, 2185, 1937, 1933, 611,
617, 1137, 618, 612, 613, 614, 615, 1956, 1958, 1969,
1973, 90, 1970, 622, 1971, 1987, 616, 1988, -495, 1622,
1994, 95, 1996, 617, 1995, 618, 1495, 2013, 2014, 2017,
619, 1744, 2016, 2018, 2028, 1952, 2025, 2193, 2029, 1771,
622, 1770, 2213, 2035, 2036, 2039, 2042, 2203, 2051, 2053,
2055, 2219, 2074, 619, 2208, 1776, 621, 2075, 620, 791,
1522, 2064, 2065, 932, 2066, 2071, 1525, 121, 2072, 1845,
1528, 1623, 1530, 2077, 1195, 1196, 1532, 2404, 1534, 2095,
2096, 620, 611, 2105, 2110, 791, 612, 613, 614, 615,
2118, -382, 2125, 2126, 2143, 424, 2138, 2146, 2207, 616,
570, 2149, 2151, 2275, 2152, 2150, 617, 2153, 618, 2154,
983, 150, 2155, 2165, 984, 621, 2171, 2187, 424, 2189,
803, 642, 643, 2230, 2231, 2251, 2278, 752, 2261, 2279,
-225, 2303, 616, 2311, 2330, 2286, 619, 2317, 621, 2331,
2332, 618, 2333, 2334, -844, 2336, 1912, 2338, 2358, 2364,
2372, 2375, 2387, 2376, 2388, 1923, 2390, 1923, 1923, 1923,
1923, 1923, 1923, 2394, 620, 2401, 2400, 622, 2309, 619,
1321, 1322, 1323, 1324, 1325, 1326, 1327, 1328, 1329, 1330,
1331, 1332, 1333, 1334, 1335, 1336, 1337, 1338, 1339, 2408,
622, 2410, 2411, 2412, 2413, 826, 2416, 620, 2417, 2418,
1355, 424, 2434, 1233, 2424, 2428, 2432, 1362, 2433, 1364,
2438, 2440, 2442, 2445, 2447, 2473, 2476, 802, 2484, 1085,
2486, 621, 2492, 2494, 1374, 819, 2031, 803, 642, 643,
2500, 2502, 2504, 2513, 644, 2508, 2517, 1104, 2523, 616,
2520, 2530, 2521, 2531, 2522, 2563, 2541, 2544, 618, 2377,
893, 1136, 2546, 2547, 621, 1233, 1405, 2555, 2577, 1142,
1143, 2571, 2581, 2586, 1149, 2601, 2602, 2603, 2097, 2614,
1277, 985, 1059, 622, 2596, 1594, 619, 582, 2111, 1282,
2190, 1888, 1517, 1454, 924, 2389, 1891, 2112, 933, 936,
1613, 1916, 1104, 1049, 2392, 1701, 1314, 2289, 2132, 1315,
1176, 2124, 1757, 2282, 620, 1923, 622, 2012, 1492, 2329,
1473, 2519, 2188, 611, 1739, 2342, 1403, 612, 613, 614,
615, 1420, 1689, 1674, 1449, 1979, 439, 2613, 1980, 1198,
616, 1201, 2148, 2161, 1050, 1709, 1679, 617, 792, 618,
1409, 644, 831, 831, 1736, 1942, 604, 605, 1154, 1943,
752, 752, 2193, 606, 1376, 1435, 1013, 1474, 607, 1463,
1510, 621, 1183, 1016, 1250, 1149, 1015, 619, 1018, 1017,
2421, 1691, 1694, 2308, 2566, 1488, 2191, 2450, 1162, 1413,
1394, 1393, 2548, 1448, 1793, 2159, 2496, 1798, 1404, 1146,
1818, 765, 1831, 2186, 1837, 620, 1841, 2459, 893, 1509,
838, 2567, 13, 14, 2585, 15, 16, 2607, 2427, 1756,
20, 2609, 2026, 622, 1022, 1721, 2198, 691, 23, 2452,
1102, 2163, 849, 27, 2474, 739, 30, 1853, 2199, 1103,
1103, 2403, 424, 2482, 37, 2057, 38, 2061, 40, 2063,
2487, 2044, 2488, 2047, 1346, 1346, 2431, 2059, 2218, 2216,
1548, 1543, 621, 2226, 2439, 2073, 1239, 1852, 1865, 2374,
1869, 59, 951, 1874, 2489, 1882, 952, 611, 1558, 985,
752, 752, 70, 953, 954, 2385, 2082, 2082, 0, 955,
956, 957, 958, 959, 0, 960, 961, 962, 963, 964,
965, 0, 966, 0, 967, 968, 85, 1250, 13, 14,
0, 15, 16, 0, 622, 0, 20, 0, 0, 93,
0, 0, 0, 0, 23, 0, 0, 0, 0, 27,
1414, 0, 30, 0, 1609, 0, 0, 102, 0, 0,
37, 0, 38, 104, 40, 0, 1642, 0, 0, 0,
0, 108, 2489, 110, 2549, 112, 0, 114, 0, 0,
0, 0, 0, 0, 119, 0, 0, 59, 752, 0,
0, 0, 0, 0, 1649, 0, 0, 0, 70, 0,
0, 130, 131, 0, 0, 0, 1655, 0, 0, 0,
0, 2587, 0, 0, 0, 0, 2588, 0, 0, 143,
0, 0, 85, 0, 0, 0, 608, 0, 0, 2588,
0, 2608, 2611, 0, 0, 93, 0, 0, 0, 0,
155, 0, 0, 156, 2611, 0, 0, 0, 0, 0,
0, 0, 0, 102, 0, 1678, 1038, 0, 0, 104,
0, 0, 0, 0, 0, 0, 0, 108, 0, 110,
1690, 112, 0, 114, 0, 0, 0, 1698, 1104, 0,
119, 2043, 0, 0, 0, 0, 2046, 893, 0, 0,
0, 0, 0, 1708, 0, 1711, 0, 130, 131, 2056,
0, 0, 0, 837, 0, 0, 611, 0, 893, 0,
612, 613, 614, 615, 0, 143, 0, 0, 0, 0,
0, 2058, 1726, 616, 0, 0, 0, 2060, 0, 0,
617, 2062, 618, 1738, 837, 0, 155, 611, 0, 156,
0, 612, 613, 614, 615, 0, 1752, 0, 0, 1037,
0, 1758, 611, 1764, 616, 0, 612, 613, 614, 615,
619, 617, 0, 618, 0, 0, 0, 0, 0, 616,
0, 0, 1473, 0, 2201, 611, 617, 0, 618, 612,
613, 614, 615, 0, 0, 0, 0, 1725, 620, 0,
611, 619, 616, 0, 612, 613, 614, 615, 0, 617,
0, 618, 0, 0, 0, 0, 619, 616, 0, 1612,
0, 0, 0, 0, 617, 0, 618, 0, 0, 620,
0, 0, 0, 1751, 0, 424, 611, 0, 0, 619,
612, 613, 614, 615, 620, 0, 0, 0, 0, 0,
0, 0, 951, 616, 619, 621, 952, 0, 0, 0,
617, 0, 618, 953, 954, 0, 424, 620, 0, 1896,
956, 0, -1192, 0, 0, -1192, -1192, -1192, -1192, -1192,
0, 424, 620, 752, 967, 0, 621, 0, 0, 0,
619, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 621, 0, 0, 424, 0, 0, 622, 0, 0,
1940, 826, 1355, 0, 0, 0, 0, 0, 620, 424,
0, 0, 0, 0, 621, 0, 2200, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 622, 621,
2211, 1960, 0, 0, 1962, 2214, 0, 0, 2215, 1085,
0, 1085, 1966, 622, 0, 424, 0, 0, 2222, 0,
2223, 0, 2224, 0, 2225, 0, 0, 0, 0, 0,
1104, 1104, 0, 0, 0, 621, 622, 0, 0, 0,
0, 1723, 0, 0, 1989, 0, 1992, 752, 0, 1733,
0, 622, 1735, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 812, 0, 0, 0, 1104, 1104,
0, 1991, 0, 0, 611, 0, 0, 0, 612, 613,
614, 615, 0, 0, 0, 0, 0, 622, 0, 0,
752, 616, 0, 0, 0, 0, 0, 1800, 617, 0,
618, 0, 0, 0, 0, 0, 752, 752, 752, 0,
752, 752, 611, 0, 752, 0, 612, 613, 614, 615,
611, 0, 0, 0, 612, 1005, 614, 615, 619, 616,
0, 1250, 0, 0, 0, 0, 617, 616, 618, 0,
0, 0, 0, 0, 617, 0, 618, 0, 0, 0,
0, 0, 0, 951, 0, 1727, 620, 952, 611, 0,
0, 0, 0, 0, 953, 954, 619, 0, 0, 1728,
955, 956, 957, 958, 619, 0, 960, 961, 962, 963,
964, 965, 0, 966, 0, 967, 968, 0, 0, 0,
0, 0, 2093, 424, 620, 1914, 0, 0, 0, 2102,
0, 0, 620, 2106, 2107, 0, 0, 0, 0, 0,
0, 2114, 0, 621, 0, 0, 0, 1112, 0, 0,
0, 1113, 611, 0, 0, 0, 0, 752, 1114, 1115,
0, 424, 0, 0, 1116, 1117, 1118, 1119, 0, 424,
1120, 1121, 1122, 1123, 1124, 1125, 1126, 1127, 0, 1128,
1129, 621, 2145, 0, 0, 0, 0, 0, 1649, 621,
0, 0, 0, 0, 0, 622, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 2164, 0, 0, 752, 752, 752, 0,
0, 0, 2169, 0, 0, 951, 0, 1180, 0, 952,
611, 0, 0, 622, 0, 0, 953, 954, 0, 2179,
2180, 622, 955, 956, 957, 958, 0, 0, 960, 961,
962, 963, 964, 965, 0, 966, 0, 967, 968, 0,
0, 0, 0, 0, 0, 0, 1104, 0, 1752, 0,
0, 0, 0, 0, 0, 0, 838, 0, 0, 0,
0, 0, 0, 0, 0, 0, 2210, 0, 951, 0,
0, 1246, 952, 611, 0, 0, 0, 0, 0, 953,
954, 0, 2220, 0, 2221, 955, 956, 957, 958, 0,
0, 960, 961, 962, 963, 964, 965, 0, 966, 0,
967, 968, 951, 0, 0, 1247, 952, 611, 0, 0,
0, 969, 0, 953, 954, 0, 0, 0, 0, 955,
956, 957, 958, 0, 0, 960, 961, 962, 963, 964,
965, 0, 966, 0, 967, 968, 0, 0, 0, 0,
1250, 752, 0, 0, 752, 951, 1104, 1104, 1104, 952,
1149, 1149, 1250, 0, 0, 0, 953, 954, 1149, 1149,
0, 0, 955, 956, 957, 958, 0, 0, 960, 961,
962, 963, 964, 965, 0, 966, 0, 967, 968, 2296,
0, 0, 0, 0, 2298, 1346, 1346, 1346, 1346, 1346,
0, 0, 0, 0, 951, 2307, 1966, 1248, 952, 611,
2312, 0, 0, 0, 0, 953, 954, 0, 0, 0,
2315, 955, 956, 957, 958, 0, 2328, 960, 961, 962,
963, 964, 965, 0, 966, 951, 967, 968, 2260, 952,
611, 0, 0, 0, 0, 1250, 953, 954, 0, 0,
0, 1414, 955, 956, 957, 958, 0, 0, 960, 961,
962, 963, 964, 965, 0, 966, 0, 967, 968, 0,
2373, 1130, 0, 0, 0, 969, 0, 0, 951, 0,
0, 0, 952, 611, 752, 2183, 0, 0, 0, 953,
954, 0, 0, 0, 1319, 955, 956, 957, 958, 2379,
0, 960, 961, 962, 963, 964, 965, 812, 966, 0,
967, 968, 0, 0, 2386, 0, 0, 0, 1104, 0,
1609, 0, 969, 0, 0, 951, 0, 0, 0, 952,
611, 0, 0, 0, 969, 0, 953, 954, 0, 2217,
0, 1398, 955, 956, 957, 958, 0, 0, 960, 961,
962, 963, 964, 965, 0, 966, 2405, 967, 968, 0,
0, 0, 0, 0, 752, 2229, 0, 0, 0, 0,
0, 893, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 969, 969, 969, 969, 951, 969,
1406, 0, 952, 611, 0, 0, 0, 0, 0, 953,
954, 0, 0, 0, 0, 955, 956, 957, 958, 0,
0, 960, 961, 962, 963, 964, 965, 1914, 966, 0,
967, 968, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 2449, 2298, 0, 0, 2451, 0,
2455, 969, 0, 969, 969, 969, 969, 2302, 0, 0,
752, 0, 2305, 0, 0, 2466, 2467, 0, 2471, 0,
951, 0, 1421, 0, 952, 611, 0, 0, 2481, 0,
0, 953, 954, 0, 0, 0, 2485, 955, 956, 957,
958, 0, 0, 960, 961, 962, 963, 964, 965, 0,
966, 0, 967, 968, 0, 2405, 0, 0, 0, 0,
0, 0, 969, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 1250, 2518, 969, 0, 0, 0, 0, 0,
0, 0, 2524, 2526, 969, 0, 0, 0, 0, 0,
951, 0, 0, 838, 952, 611, 2538, 0, 1250, 0,
2540, 953, 954, 0, 0, 969, 1433, 955, 956, 957,
958, 0, 0, 960, 961, 962, 963, 964, 965, 0,
966, 969, 967, 968, 0, 969, 969, 0, 0, 0,
0, 0, 0, 893, 0, 0, 0, 0, 0, 0,
2526, 0, 0, 0, 2568, 0, 0, 0, 2572, 0,
0, 0, 1764, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 1764, 2584, 2568, 0,
0, 0, 0, 0, 1104, 951, 0, 0, 1104, 952,
611, 0, 0, 969, 0, 0, 953, 954, 0, 0,
0, 1436, 955, 956, 957, 958, 0, 0, 960, 961,
962, 963, 964, 965, 0, 966, 951, 967, 968, 0,
952, 611, 0, 0, 0, 752, 752, 953, 954, 0,
0, 0, 1437, 955, 956, 957, 958, 0, 0, 960,
961, 962, 963, 964, 965, 0, 966, 0, 967, 968,
0, 969, 969, 0, 0, 0, 0, 0, 0, 0,
1104, 1104, 1104, 1104, 0, 951, 0, 0, 2183, 952,
611, 0, 0, 0, 0, 0, 953, 954, 752, 0,
0, 1472, 955, 956, 957, 958, 0, 0, 960, 961,
962, 963, 964, 965, 0, 966, 0, 967, 968, 0,
0, 951, 0, 0, 0, 952, 611, 0, 0, 0,
0, 0, 953, 954, 0, 0, 0, 1519, 955, 956,
957, 958, 0, 1104, 960, 961, 962, 963, 964, 965,
0, 966, 0, 967, 968, 0, 0, 0, 0, 0,
0, 0, 0, 951, 0, 1727, 0, 952, 611, 1104,
1104, 0, 1104, 0, 953, 954, 0, 0, 0, 2183,
955, 956, 957, 958, 0, 0, 960, 961, 962, 963,
964, 965, 0, 966, 0, 967, 968, 969, 969, 969,
969, 969, 969, 969, 969, 969, 969, 969, 969, 969,
969, 969, 969, 969, 969, 969, 0, 0, 0, 0,
0, 0, 0, 1104, 0, 0, 0, 0, 0, 0,
0, 969, 0, 0, 0, 0, 0, 951, 969, 0,
969, 952, 611, 0, 0, 0, 0, 0, 953, 954,
969, 0, 0, 1520, 955, 956, 957, 958, 0, 0,
960, 961, 962, 963, 964, 965, 0, 966, 0, 967,
968, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 969, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 380, 381, 382, 383, 0,
385, 0, 386, 0, 388, 389, 0, 390, 0, 0,
0, 392, 0, 394, 395, 0, 0, 397, 398, 399,
0, 401, 0, 403, 404, 0, 0, 411, 0, 0,
0, 0, 414, 415, 416, 417, 418, 419, 420, 421,
0, 422, 423, 0, 0, 428, 429, 430, 0, 432,
969, 434, 0, 0, 437, 438, 0, 0, 0, 0,
0, 0, 445, 446, 969, 0, 449, 0, 0, 0,
0, 0, 0, 455, 0, 457, 0, 458, 459, 0,
0, 0, 464, 465, 466, 969, 0, 468, 0, 0,
470, 471, 0, 473, 474, 475, 0, 0, 0, 0,
480, 481, 0, 0, 483, 0, 485, 486, 487, 0,
489, 490, 0, 0, 492, 0, 494, 495, 496, 497,
498, 499, 0, 0, 0, 0, 0, 0, 507, 508,
509, 0, 0, 0, 969, 514, 515, 516, 0, 518,
519, 520, 521, 522, 523, 524, 525, 526, 527, 528,
529, 530, 531, 532, 533, 534, 535, 536, 537, 538,
539, 540, 541, 542, 543, 0, 545, 0, 547, 0,
548, 0, 549, 550, 0, 0, 553, 554, 555, 556,
557, 558, 559, 560, 951, 969, 0, 0, 952, 611,
0, 0, 0, 0, 0, 953, 954, 0, 0, 0,
1659, 955, 956, 957, 958, 0, 0, 960, 961, 962,
963, 964, 965, 0, 966, 0, 967, 968, 969, 0,
0, 0, 0, 0, 0, 969, 0, 0, 0, 0,
0, 969, 0, 0, 0, 0, 638, 0, 0, 651,
0, 654, 0, 0, 0, 951, 0, 0, 0, 952,
611, 0, 0, 0, 969, 0, 953, 954, 0, 0,
0, 1934, 955, 956, 957, 958, 969, 0, 960, 961,
962, 963, 964, 965, 969, 966, 0, 967, 968, 0,
0, 0, 0, 0, 969, 0, 0, 969, 0, 0,
0, 0, 951, 0, 0, 0, 952, 611, 0, 0,
0, 0, 969, 953, 954, 0, 0, 0, 1972, 955,
956, 957, 958, 0, 969, 960, 961, 962, 963, 964,
965, 0, 966, 0, 967, 968, 0, 951, 969, 1990,
0, 952, 611, 0, 969, 0, 0, 0, 953, 954,
969, 0, 0, 0, 955, 956, 957, 958, 0, 0,
960, 961, 962, 963, 964, 965, 0, 966, 951, 967,
968, 0, 952, 611, 0, 0, 0, 0, 0, 953,
954, 0, 0, 0, 2022, 955, 956, 957, 958, 0,
0, 960, 961, 962, 963, 964, 965, 0, 966, 0,
967, 968, 951, 0, 2166, 0, 952, 611, 0, 0,
0, 0, 0, 953, 954, 0, 0, 0, 0, 955,
956, 957, 958, 0, 0, 960, 961, 962, 963, 964,
965, 0, 966, 0, 967, 968, 951, 0, 2181, 0,
952, 611, 0, 0, 0, 0, 0, 953, 954, 0,
0, 0, 0, 955, 956, 957, 958, 0, 0, 960,
961, 962, 963, 964, 965, 0, 966, 951, 967, 968,
0, 952, 611, 0, 0, 0, 0, 0, 953, 954,
0, 0, 969, 2272, 955, 956, 957, 958, 0, 0,
960, 961, 962, 963, 964, 965, 0, 966, 0, 967,
968, 0, 0, 0, 951, 0, 0, 0, 952, 611,
0, 0, 0, 0, 0, 953, 954, 0, 0, 0,
2280, 955, 956, 957, 958, 0, 969, 960, 961, 962,
963, 964, 965, 0, 966, 0, 967, 968, 951, 0,
0, 0, 952, 611, 0, 0, 969, 0, 969, 953,
954, 0, 969, 0, 2295, 955, 956, 957, 958, 0,
0, 960, 961, 962, 963, 964, 965, 0, 966, 0,
967, 968, 0, 0, 0, 969, 0, 0, 969, 951,
0, 0, 2306, 952, 611, 0, 0, 0, 0, 0,
953, 954, 0, 941, 942, 0, 955, 956, 957, 958,
1130, 0, 960, 961, 962, 963, 964, 965, 0, 966,
951, 967, 968, 0, 952, 611, 0, 0, 0, 0,
0, 953, 954, 0, 0, 0, 2310, 955, 956, 957,
958, 0, 0, 960, 961, 962, 963, 964, 965, 0,
966, 951, 967, 968, 0, 952, 611, 0, 0, 0,
0, 0, 953, 954, 0, 0, 0, 2369, 955, 956,
957, 958, 0, 0, 960, 961, 962, 963, 964, 965,
0, 966, 0, 967, 968, 0, 0, 0, 951, 969,
0, 0, 952, 611, 0, 0, 0, 0, 969, 953,
954, 0, 969, 969, 2370, 955, 956, 957, 958, 0,
969, 960, 961, 962, 963, 964, 965, 0, 966, 951,
967, 968, 2395, 952, 611, 0, 0, 0, 0, 0,
953, 954, 0, 0, 0, 0, 955, 956, 957, 958,
0, 969, 960, 961, 962, 963, 964, 965, 0, 966,
0, 967, 968, 0, 0, 0, 0, 0, 0, 0,
969, 0, 951, 0, 0, 969, 952, 611, 0, 0,
0, 0, 0, 953, 954, 969, 969, 0, 2402, 955,
956, 957, 958, 0, 0, 960, 961, 962, 963, 964,
965, 0, 966, 0, 967, 968, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 969, 951, 0, 0,
2419, 952, 611, 0, 0, 0, 969, 969, 953, 954,
0, 0, 0, 0, 955, 956, 957, 958, 0, 0,
960, 961, 962, 963, 964, 965, 0, 966, 951, 967,
968, 2437, 952, 611, 0, 0, 0, 0, 0, 953,
954, 0, 0, 0, 0, 955, 956, 957, 958, 0,
0, 960, 961, 962, 963, 964, 965, 0, 966, 0,
967, 968, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 969, 0, 969, 0, 0, 0, 0, 0,
0, 0, 951, 969, 0, 0, 952, 611, 969, 0,
0, 969, 0, 953, 954, 0, 0, 0, 2444, 955,
956, 957, 958, 0, 969, 960, 961, 962, 963, 964,
965, 0, 966, 951, 967, 968, 2493, 952, 611, 0,
0, 0, 0, 0, 953, 954, 0, 0, 0, 0,
955, 956, 957, 958, 0, 0, 960, 961, 962, 963,
964, 965, 0, 966, 0, 967, 968, 951, 0, 969,
0, 952, 611, 0, 0, 969, 0, 0, 953, 954,
0, 0, 969, 2495, 955, 956, 957, 958, 0, 0,
960, 961, 962, 963, 964, 965, 0, 966, 951, 967,
968, 969, 952, 611, 0, 0, 0, 0, 0, 953,
954, 0, 0, 0, 2506, 955, 956, 957, 958, 0,
0, 960, 961, 962, 963, 964, 965, 0, 966, 0,
967, 968, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 969, 0, 969, 0, 0,
0, 969, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 969, 969, 0, 0, 0, 969, 951, 0,
0, 2507, 952, 611, 0, 0, 0, 969, 0, 953,
954, 969, 0, 0, 0, 955, 956, 957, 958, 0,
0, 960, 961, 962, 963, 964, 965, 0, 966, 0,
967, 968, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 969, 0, 0, 0, 0, 0,
969, 0, 969, 0, 0, 0, 951, 0, 0, 2511,
952, 611, 9, 0, 969, 0, 969, 953, 954, 10,
0, 0, 0, 955, 956, 957, 958, 0, 0, 960,
961, 962, 963, 964, 965, 0, 966, 0, 967, 968,
0, 0, 0, 0, 969, 0, 0, 0, 969, 11,
12, 13, 14, 0, 15, 16, 17, 18, 19, 20,
969, 0, 21, 22, 0, 0, 0, 23, 24, 25,
0, 26, 27, 28, 29, 30, 31, 0, 32, 33,
34, 35, 36, 37, 0, 38, 39, 40, 41, 42,
43, 0, 0, 44, 45, 46, 47, 48, 0, 0,
49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
59, 60, 61, 62, 63, 64, 65, 66, 67, 68,
69, 70, 0, 71, 0, 72, 73, 0, 74, 75,
76, 0, 0, 77, 0, 0, 78, 79, 0, 80,
81, 82, 83, 0, 84, 85, 86, 87, 88, 89,
90, 91, 92, 0, 0, 0, 0, 0, 93, 94,
95, 96, 0, 0, 0, 0, 97, 0, 0, 98,
99, 0, 0, 100, 101, 0, 102, 0, 0, 0,
103, 0, 104, 0, 105, 0, 0, 0, 106, 107,
108, 109, 110, 111, 112, 113, 114, 115, 0, 116,
117, 118, 0, 119, 0, 120, 121, 0, 122, 0,
123, 124, 125, 126, 0, 0, 127, 128, 129, 0,
130, 131, 132, 0, 133, 134, 135, 0, 136, 0,
137, 138, 139, 140, 141, 0, 142, 0, 143, 144,
0, 0, 145, 146, 147, 0, 0, 148, 149, 0,
150, 151, 0, 152, 153, 0, 0, 0, 154, 155,
0, 0, 156, 0, 0, 157, 0, 0, 0, 158,
159, 0, 0, 160, 161, 162, 0, 163, 164, 165,
166, 167, 168, 169, 170, 171, 172, 173, 0, 174,
0, 0, 175, 0, 0, 0, 176, 177, 178, 179,
180, 0, 181, 182, 0, 0, 183, 184, 185, 186,
0, 0, 0, 0, 187, 188, 189, 190, 191, 192,
0, 0, 0, 0, 0, 0, 0, 193, 0, 194,
0, 195, 196, 197, 198, 199, 0, 0, 0, 200,
201, 202, 203, 204, 205, 951, 206, 207, 0, 952,
611, 208, 0, 0, 0, 0, 953, 954, 0, 0,
0, 2516, 955, 956, 957, 958, 0, 0, 960, 961,
962, 963, 964, 965, 0, 966, 951, 967, 968, 0,
952, 611, 0, 0, 0, 0, 0, 953, 954, 0,
0, 0, 2545, 955, 956, 957, 958, 0, 0, 960,
961, 962, 963, 964, 965, 0, 966, 951, 967, 968,
2559, 952, 611, 0, 0, 0, 0, 0, 953, 954,
0, 0, 0, 0, 955, 956, 957, 958, 0, 0,
960, 961, 962, 963, 964, 965, 0, 966, 0, 967,
968, 951, 0, 2578, 0, 952, 611, 0, 0, 0,
0, 0, 953, 954, 0, 0, 0, 0, 955, 956,
957, 958, 0, 0, 960, 961, 962, 963, 964, 965,
0, 966, 951, 967, 968, 0, 952, 611, 0, 0,
0, 0, 0, 953, 954, 0, 0, 0, 0, 955,
956, 957, 958, 0, 0, 960, 961, 962, 963, 964,
965, 0, 966, 0, 967, 968
};
static const yytype_int16 yycheck[] =
{
50, 489, 767, 381, 1031, 496, 497, 498, 499, 486,
390, 395, 378, 544, 1138, 894, 1460, 754, 894, 1340,
634, 659, 660, 975, 895, 433, 925, 1608, 660, 1638,
210, 62, 63, 404, 257, 1987, 638, 1498, 69, 262,
1494, 2027, 1311, 414, 881, 416, 1866, 1154, 1868, 257,
421, 422, 423, 1518, 262, 981, 76, 470, 429, 747,
2096, 432, 849, 434, 1373, 1311, 1614, 98, 118, 613,
436, 1614, 122, 259, 1005, 8, 262, 263, 1071, 99,
8, 63, 849, 1625, 1634, 1530, 7, 453, 483, 1639,
1528, 7, 1530, 471, 1532, 15, 116, 1915, 15, 1680,
7, 467, 5, 1530, 2206, 175, 472, 475, 71, 116,
476, 1530, 478, 1530, 1530, 659, 660, 391, 5, 116,
0, 1, 94, 1530, 144, 491, 974, 975, 37, 1530,
41, 16, 17, 8, 21, 182, 1528, 503, 1530, 505,
1532, 649, 191, 169, 129, 20, 512, 677, 1027, 15,
266, 1027, 1179, 15, 212, 58, 12, 5, 8, 7,
15, 8, 18, 1716, 1717, 1718, 409, 182, 15, 129,
20, 287, 28, 1166, 1050, 31, 5, 15, 34, 15,
16, 17, 208, 86, 242, 41, 552, 172, 116, 45,
15, 8, 3, 49, 225, 116, 5, 391, 8, 116,
116, 8, 315, 20, 147, 148, 166, 92, 37, 116,
21, 67, 129, 20, 437, 71, 72, 15, 15, 21,
129, 77, 78, 126, 191, 15, 15, 83, 84, 15,
86, 87, 88, 89, 137, 91, 8, 180, 351, 1560,
483, 116, 129, 466, 100, 208, 3, 129, 20, 105,
473, 107, 475, 129, 324, 111, 282, 637, 230, 115,
257, 117, 165, 129, 149, 314, 116, 475, 124, 26,
150, 318, 128, 641, 129, 2377, 132, 645, 134, 767,
8, 129, 129, 813, 652, 141, 142, 149, 480, 145,
146, 129, 1191, 129, 149, 151, 804, 153, 209, 116,
315, 157, 64, 318, 129, 1920, 1921, 2125, 1861, 116,
1919, 1864, 284, 149, 694, 282, 201, 228, 592, 129,
129, 254, 1446, 295, 516, 696, 246, 129, 184, 257,
186, 129, 129, 728, 822, 23, 257, 193, 194, 129,
257, 257, 700, 129, 116, 376, 377, 755, 1657, 37,
257, 382, 383, 384, 385, 258, 387, 388, 716, 15,
391, 2313, 393, 394, 395, 396, 1916, 1005, 399, 1615,
1616, 402, 8, 404, 976, 3, 1918, 257, 409, 1305,
1818, 412, 257, 414, 578, 416, 1831, 15, 116, 420,
421, 422, 423, 1831, 588, 589, 590, 591, 429, 1837,
431, 432, 1189, 434, 1831, 1093, 1867, 257, 191, 440,
441, 1438, 1831, 1178, 1831, 1831, 447, 448, 641, 1345,
815, 452, 645, 1190, 1831, 8, 1818, 8, 459, 652,
1831, 462, 1459, 641, 657, 803, 844, 645, 420, 1831,
257, 1994, 492, 474, 652, 1837, 477, 1378, 1379, 1380,
257, 3, 483, 484, 485, 486, 1304, 488, 489, 651,
15, 1005, 654, 92, 495, 496, 497, 498, 499, 183,
501, 1085, 1110, 504, 26, 506, 507, 191, 1110, 510,
116, 989, 513, 991, 678, 257, 517, 232, 233, 847,
998, 257, 1418, 238, 208, 8, 148, 547, 1605, 1606,
858, 8, 1495, 8, 64, 288, 21, 701, 128, 922,
2546, 2547, 8, 20, 191, 546, 299, 875, 2504, 129,
149, 2074, 2418, 573, 2139, 2140, 8, 2136, 180, 257,
580, 208, 8, 564, 8, 116, 1857, 157, 8, 149,
8, 572, 2494, 923, 575, 576, 577, 578, 23, 569,
570, 407, 583, 584, 912, 37, 587, 588, 589, 590,
591, 581, 37, 2017, 595, 596, 1110, 2028, 926, 129,
2118, 2036, 201, 8, 5, 2118, 8, 7, 9, 8,
803, 8, 8, 763, 8, 2127, 8, 773, 8, 149,
970, 47, 1528, 2413, 1530, 803, 1532, 217, 1534, 2551,
8, 8, 8, 116, 798, 282, 37, 2160, 285, 116,
802, 116, 804, 2509, 129, 37, 1528, 37, 1530, 669,
1532, 257, 1534, 8, 992, 993, 994, 995, 996, 8,
661, 662, 663, 664, 665, 666, 667, 687, 8, 670,
116, 1910, 116, 357, 358, 244, 1915, 678, 116, 843,
1158, 3, 846, 23, 129, 511, 1014, 880, 881, 5,
2563, 1019, 1042, 9, 1910, 696, 18, 37, 699, 128,
701, 894, 1052, 129, 2577, 8, 257, 2286, 16, 17,
1318, 116, 1561, 21, 116, 1561, 1318, 116, 21, 116,
116, 37, 116, 724, 3, 1460, 1461, 747, 157, 1536,
1537, 1538, 1060, 1540, 1541, 5, 15, 1444, 116, 116,
3, 2601, 2602, 3, 764, 15, 15, 84, 749, 84,
751, 177, 15, 754, 2614, 15, 5, 1653, 778, 1660,
1661, 1662, 331, 8, 3, 785, 767, 16, 17, 8,
1378, 1379, 1380, 22, 257, 24, 777, 346, 347, 348,
257, 43, 257, 3, 33, 786, 35, 788, 37, 5,
7, 7, 793, 8, 795, 15, 1692, 798, 15, 992,
993, 994, 995, 996, 1318, 67, 1320, 1000, 1001, 8,
811, 257, 8, 257, 992, 993, 994, 995, 996, 257,
82, 822, 21, 7, 8, 87, 88, 828, 3, 8,
8, 851, 94, 1439, 1027, 1441, 8, 22, 2389, 24,
15, 63, 843, 21, 191, 846, 68, 194, 33, 21,
35, 852, 257, 2376, 191, 257, 191, 1050, 257, 8,
257, 257, 882, 257, 1378, 1379, 1380, 887, 90, 91,
8, 208, 21, 208, 18, 8, 896, 897, 898, 257,
257, 901, 26, 21, 8, 886, 2125, 1365, 1366, 1367,
1368, 1369, 5, 8, 8, 1088, 9, 21, 5, 1277,
8, 902, 903, 16, 17, 2428, 21, 2338, 15, 7,
159, 95, 1818, 162, 904, 15, 8, 918, 16, 17,
8, 941, 144, 15, 37, 1831, 7, 8, 265, 919,
265, 1837, 154, 21, 8, 1841, 1818, 354, 8, 940,
124, 3, 359, 8, 129, 282, 8, 282, 285, 1831,
285, 21, 289, 290, 289, 1837, 21, 1285, 8, 1841,
257, 298, 299, 8, 299, 262, 228, 304, 683, 304,
1427, 21, 1429, 158, 159, 1303, 161, 162, 200, 8,
2411, 8, 8, 1905, 1906, 1907, 1908, 1909, 862, 863,
22, 865, 24, 2284, 21, 21, 2410, 259, 247, 8,
8, 33, 1352, 35, 1024, 8, 1354, 192, 1358, 7,
8, 195, 21, 21, 1860, 147, 148, 8, 202, 8,
7, 8, 1023, 1872, 1893, 41, 1872, 8, 1029, 1870,
1871, 1766, 21, 1740, 1035, 8, 89, 1878, 1879, 8,
21, 303, 8, 1939, 8, 1863, 7, 1048, 180, 234,
1398, 8, 1660, 1661, 1662, 71, 305, 306, 307, 1955,
15, 2155, 247, 1411, 21, 1961, 8, 1963, 7, 122,
8, 2502, 1073, 1093, 1424, 352, 353, 1078, 15, 21,
1652, 1101, 149, 21, 316, 317, 2500, 1905, 1906, 1907,
1908, 1909, 8, 1094, 920, 339, 1437, 44, 342, 343,
344, 15, 155, 8, 1432, 21, 1955, 8, 1109, 1955,
5, 355, 356, 15, 9, 1961, 21, 16, 17, 135,
21, 16, 17, 8, 8, 1145, 158, 159, 23, 161,
162, 1866, 185, 1868, 1470, 15, 21, 21, 8, 191,
87, 15, 37, 149, 1308, 860, 1660, 1661, 1662, 864,
8, 21, 15, 169, 869, 15, 208, 872, 873, 15,
192, 8, 8, 21, 15, 218, 5, 15, 1188, 37,
9, 8, 119, 15, 21, 191, 15, 16, 17, 15,
1373, 1517, 314, 315, 21, 15, 318, 319, 27, 15,
8, 8, 208, 209, 1020, 8, 143, 36, 145, 252,
1615, 1616, 234, 21, 21, 221, 8, 223, 224, 1559,
226, 1231, 5, 229, 7, 247, 931, 10, 933, 21,
15, 14, 15, 16, 17, 64, 1246, 1247, 1248, 8,
282, 178, 63, 285, 27, 8, 183, 68, 290, 15,
187, 34, 21, 36, 191, 8, 298, 194, 21, 8,
15, 410, 1272, 92, 8, 349, 350, 8, 21, 90,
91, 8, 21, 5, 248, 249, 282, 21, 10, 216,
21, 64, 14, 15, 16, 17, 15, 1278, 1279, 1780,
15, 1782, 1783, 230, 1477, 27, 15, 8, 15, 236,
129, 15, 34, 1794, 36, 15, 8, 1647, 15, 92,
21, 1302, 2396, 1804, 320, 1806, 322, 1308, 5, 21,
149, 1312, 9, 144, 15, 8, 8, 8, 1656, 16,
17, 1671, 64, 154, 21, 8, 23, 1520, 21, 21,
21, 1000, 1001, 1683, 15, 2332, 129, 1687, 21, 8,
37, 1669, 8, 1536, 1537, 1538, 8, 1540, 1541, 124,
92, 1544, 21, 1937, 8, 21, 149, 8, 15, 21,
15, 1702, 201, 522, 8, 524, 15, 21, 1561, 200,
21, 44, 531, 532, 533, 8, 8, 21, 537, 538,
539, 540, 1383, 542, 543, 2281, 2232, 129, 21, 21,
5, 8, 8, 15, 9, 2141, 2142, 2143, 8, 7,
231, 16, 17, 1731, 21, 21, 8, 149, 201, 2258,
2306, 21, 2258, 244, 87, 15, 8, 8, 8, 21,
93, 8, 37, 239, 166, 1426, 1427, 15, 1429, 21,
21, 21, 2597, 2598, 21, 8, 1437, 15, 1439, 8,
1441, 2476, 2477, 1444, 124, 5, 119, 3, 21, 9,
10, 252, 21, 15, 14, 15, 16, 17, 246, 201,
1286, 870, 871, 1656, 1657, 246, 1944, 27, 8, 8,
143, 15, 145, 1493, 34, 1476, 36, 26, 1656, 21,
8, 21, 21, 8, 1485, 1200, 1660, 1661, 1662, 8,
1491, 1206, 1512, 21, 1514, 1210, 21, 1212, 1213, 1214,
1501, 1216, 21, 1218, 64, 178, 8, 8, 15, 8,
183, 7, 240, 8, 187, 8, 8, 1518, 191, 1539,
21, 194, 21, 1716, 1717, 1718, 21, 15, 21, 5,
15, 8, 92, 1553, 10, 15, 8, 8, 14, 15,
16, 17, 8, 216, 21, 15, 8, 2544, 1549, 1569,
21, 27, 15, 149, 1574, 21, 5, 230, 34, 21,
36, 10, 1582, 236, 8, 14, 15, 16, 17, 129,
1590, 175, 15, 16, 17, 8, 15, 21, 27, 8,
1600, 8, 1602, 8, 27, 34, 8, 36, 64, 149,
8, 40, 21, 36, 1595, 15, 21, 8, 8, 2334,
8, 8, 5, 21, 8, 26, 9, 7, 1956, 15,
21, 21, 62, 16, 17, 64, 92, 21, 8, 22,
23, 64, 25, 1959, 1625, 28, 29, 30, 31, 32,
15, 21, 35, 15, 37, 38, 8, 1638, 8, 8,
21, 201, 8, 92, 8, 8, 2230, 287, 15, 92,
8, 21, 21, 129, 455, 21, 1657, 816, 21, 1660,
1661, 1662, 8, 21, 8, 8, 213, 1860, 1861, 1670,
8, 1864, 8, 149, 2028, 2410, 8, 2412, 2413, 1872,
129, 15, 5, 21, 7, 21, 129, 10, 8, 490,
166, 14, 15, 16, 17, 9, 64, 1412, 5, 500,
149, 1702, 9, 129, 27, 8, 149, 9, 5, 16,
17, 34, 9, 36, 21, 21, 23, 8, 21, 16,
17, 1722, 8, 8, 8, 201, 23, 8, 25, 37,
37, 28, 29, 30, 31, 32, 21, 21, 2473, 1740,
37, 64, 15, 204, 205, 206, 207, 208, 67, 15,
15, 15, 201, 554, 555, 556, 557, 558, 201, 2206,
15, 15, 1955, 15, 2499, 2500, 2116, 5, 1961, 92,
15, 9, 1487, 1774, 1775, 8, 2126, 8, 16, 17,
26, 129, 7, 15, 22, 23, 7, 25, 18, 37,
28, 29, 30, 31, 32, 21, 7, 5, 1799, 37,
15, 1994, 21, 21, 26, 7, 129, 15, 16, 17,
8, 15, 613, 614, 615, 15, 617, 26, 2553, 27,
8, 8, 21, 624, 5, 21, 149, 5, 36, 10,
15, 9, 15, 14, 15, 16, 17, 638, 16, 17,
15, 15, 1862, 21, 15, 23, 27, 15, 8, 21,
1851, 21, 8, 34, 15, 36, 64, 1877, 5, 37,
15, 1881, 2323, 2324, 15, 15, 16, 17, 62, 21,
8, 7, 15, 8, 8, 8, 8, 27, 201, 680,
255, 2074, 7, 64, 92, 15, 36, 437, 166, 15,
239, 15, 21, 16, 695, 15, 15, 208, 191, 21,
8, 7, 1061, 15, 15, 15, 315, 331, 15, 59,
63, 92, 15, 1072, 64, 68, 466, 1918, 1919, 1920,
1921, 129, 723, 473, 15, 15, 15, 332, 15, 730,
1931, 481, 15, 15, 15, 736, 737, 90, 91, 15,
15, 149, 92, 15, 15, 15, 15, 15, 129, 15,
7, 5, 2410, 2411, 1974, 2303, 10, 1958, 246, 246,
14, 15, 16, 17, 246, 5, 246, 2160, 149, 246,
8, 124, 15, 27, 5, 21, 1996, 21, 15, 10,
34, 782, 36, 14, 15, 16, 17, 8, 7, 21,
8, 144, 21, 201, 21, 15, 27, 21, 26, 149,
15, 154, 8, 34, 173, 36, 1165, 15, 15, 8,
64, 2012, 255, 7, 15, 2016, 21, 2018, 15, 208,
201, 71, 2042, 18, 8, 15, 15, 2028, 15, 15,
15, 2051, 15, 64, 2035, 2036, 149, 15, 92, 2232,
1199, 21, 21, 593, 21, 21, 1205, 200, 21, 2069,
1209, 201, 1211, 21, 855, 856, 1215, 5, 1217, 15,
15, 92, 10, 21, 21, 2258, 14, 15, 16, 17,
8, 15, 5, 15, 9, 129, 7, 20, 8, 27,
233, 21, 21, 8, 21, 26, 34, 21, 36, 21,
5, 244, 15, 21, 9, 149, 15, 26, 129, 26,
15, 16, 17, 21, 26, 21, 7, 657, 21, 21,
15, 8, 27, 254, 21, 26, 64, 15, 149, 21,
15, 36, 8, 132, 7, 21, 2127, 7, 21, 37,
21, 15, 7, 15, 7, 2136, 21, 2138, 2139, 2140,
2141, 2142, 2143, 21, 92, 15, 255, 201, 2168, 64,
951, 952, 953, 954, 955, 956, 957, 958, 959, 960,
961, 962, 963, 964, 965, 966, 967, 968, 969, 15,
201, 15, 15, 15, 15, 976, 15, 92, 15, 15,
981, 129, 2375, 2376, 15, 7, 21, 988, 8, 990,
15, 8, 8, 7, 21, 8, 7, 5, 8, 749,
92, 149, 21, 15, 1005, 2206, 2207, 15, 16, 17,
7, 7, 15, 78, 129, 21, 330, 767, 8, 27,
21, 7, 353, 7, 352, 17, 21, 15, 36, 2249,
1031, 781, 15, 15, 149, 2428, 1037, 15, 17, 789,
790, 21, 8, 15, 794, 7, 7, 15, 2268, 7,
903, 166, 1053, 201, 128, 1279, 64, 223, 1890, 911,
2014, 1600, 1192, 1097, 586, 2281, 1604, 1891, 594, 597,
1310, 1634, 822, 714, 2286, 1434, 940, 2138, 1918, 940,
830, 1910, 1501, 2118, 92, 2286, 201, 1741, 1161, 2188,
7, 2484, 2012, 10, 1485, 2207, 1033, 14, 15, 16,
17, 1053, 1421, 1400, 1095, 1713, 75, 2603, 1715, 859,
27, 861, 1939, 1961, 715, 1444, 1407, 34, 466, 36,
1042, 129, 2323, 2324, 1483, 1653, 247, 247, 796, 1656,
880, 881, 2333, 247, 1005, 1078, 661, 1138, 247, 1109,
1181, 149, 842, 664, 894, 895, 663, 64, 666, 665,
2333, 1423, 1425, 2167, 2551, 1156, 2016, 2396, 811, 1048,
1023, 1021, 2523, 1094, 1523, 1958, 2456, 1526, 1035, 792,
1529, 445, 1531, 1998, 1533, 92, 1535, 2409, 1179, 1180,
1181, 2553, 45, 46, 2579, 48, 49, 2599, 2341, 1499,
53, 2601, 1766, 201, 670, 1461, 2019, 385, 61, 2400,
765, 1963, 507, 66, 2424, 418, 69, 1553, 2023, 2410,
2411, 2313, 129, 2433, 77, 1818, 79, 1837, 81, 1841,
2440, 1793, 2442, 1798, 974, 975, 2364, 1831, 2049, 2048,
1238, 1231, 149, 2069, 2382, 1851, 884, 1549, 1569, 2232,
1574, 104, 5, 1582, 2445, 1590, 9, 10, 1249, 166,
1000, 1001, 115, 16, 17, 2268, 2476, 2477, -1, 22,
23, 24, 25, 26, -1, 28, 29, 30, 31, 32,
33, -1, 35, -1, 37, 38, 139, 1027, 45, 46,
-1, 48, 49, -1, 201, -1, 53, -1, -1, 152,
-1, -1, -1, -1, 61, -1, -1, -1, -1, 66,
1050, -1, 69, -1, 1305, -1, -1, 170, -1, -1,
77, -1, 79, 176, 81, -1, 1317, -1, -1, -1,
-1, 184, 2523, 186, 2525, 188, -1, 190, -1, -1,
-1, -1, -1, -1, 197, -1, -1, 104, 1088, -1,
-1, -1, -1, -1, 1345, -1, -1, -1, 115, -1,
-1, 214, 215, -1, -1, -1, 1357, -1, -1, -1,
-1, 2581, -1, -1, -1, -1, 2586, -1, -1, 232,
-1, -1, 139, -1, -1, -1, 239, -1, -1, 2599,
-1, 2601, 2602, -1, -1, 152, -1, -1, -1, -1,
253, -1, -1, 256, 2614, -1, -1, -1, -1, -1,
-1, -1, -1, 170, -1, 1406, 1407, -1, -1, 176,
-1, -1, -1, -1, -1, -1, -1, 184, -1, 186,
1421, 188, -1, 190, -1, -1, -1, 1428, 1178, -1,
197, 1790, -1, -1, -1, -1, 1795, 1438, -1, -1,
-1, -1, -1, 1444, -1, 1446, -1, 214, 215, 1808,
-1, -1, -1, 7, -1, -1, 10, -1, 1459, -1,
14, 15, 16, 17, -1, 232, -1, -1, -1, -1,
-1, 1830, 1473, 27, -1, -1, -1, 1836, -1, -1,
34, 1840, 36, 1484, 7, -1, 253, 10, -1, 256,
-1, 14, 15, 16, 17, -1, 1497, -1, -1, 7,
-1, 1502, 10, 1504, 27, -1, 14, 15, 16, 17,
64, 34, -1, 36, -1, -1, -1, -1, -1, 27,
-1, -1, 7, -1, 78, 10, 34, -1, 36, 14,
15, 16, 17, -1, -1, -1, -1, 7, 92, -1,
10, 64, 27, -1, 14, 15, 16, 17, -1, 34,
-1, 36, -1, -1, -1, -1, 64, 27, -1, 1309,
-1, -1, -1, -1, 34, -1, 36, -1, -1, 92,
-1, -1, -1, 7, -1, 129, 10, -1, -1, 64,
14, 15, 16, 17, 92, -1, -1, -1, -1, -1,
-1, -1, 5, 27, 64, 149, 9, -1, -1, -1,
34, -1, 36, 16, 17, -1, 129, 92, -1, 1610,
23, -1, 25, -1, -1, 28, 29, 30, 31, 32,
-1, 129, 92, 1373, 37, -1, 149, -1, -1, -1,
64, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, 149, -1, -1, 129, -1, -1, 201, -1, -1,
1651, 1652, 1653, -1, -1, -1, -1, -1, 92, 129,
-1, -1, -1, -1, 149, -1, 2025, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, 201, 149,
2039, 1682, -1, -1, 1685, 2044, -1, -1, 2047, 1439,
-1, 1441, 1693, 201, -1, 129, -1, -1, 2057, -1,
2059, -1, 2061, -1, 2063, -1, -1, -1, -1, -1,
1460, 1461, -1, -1, -1, 149, 201, -1, -1, -1,
-1, 1471, -1, -1, 1725, -1, 1727, 1477, -1, 1479,
-1, 201, 1482, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, 1494, -1, -1, -1, 1498, 1499,
-1, 7, -1, -1, 10, -1, -1, -1, 14, 15,
16, 17, -1, -1, -1, -1, -1, 201, -1, -1,
1520, 27, -1, -1, -1, -1, -1, 1527, 34, -1,
36, -1, -1, -1, -1, -1, 1536, 1537, 1538, -1,
1540, 1541, 10, -1, 1544, -1, 14, 15, 16, 17,
10, -1, -1, -1, 14, 15, 16, 17, 64, 27,
-1, 1561, -1, -1, -1, -1, 34, 27, 36, -1,
-1, -1, -1, -1, 34, -1, 36, -1, -1, -1,
-1, -1, -1, 5, -1, 7, 92, 9, 10, -1,
-1, -1, -1, -1, 16, 17, 64, -1, -1, 21,
22, 23, 24, 25, 64, -1, 28, 29, 30, 31,
32, 33, -1, 35, -1, 37, 38, -1, -1, -1,
-1, -1, 1873, 129, 92, 1625, -1, -1, -1, 1880,
-1, -1, 92, 1884, 1885, -1, -1, -1, -1, -1,
-1, 1892, -1, 149, -1, -1, -1, 5, -1, -1,
-1, 9, 10, -1, -1, -1, -1, 1657, 16, 17,
-1, 129, -1, -1, 22, 23, 24, 25, -1, 129,
28, 29, 30, 31, 32, 33, 34, 35, -1, 37,
38, 149, 1933, -1, -1, -1, -1, -1, 1939, 149,
-1, -1, -1, -1, -1, 201, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, 1964, -1, -1, 1716, 1717, 1718, -1,
-1, -1, 1973, -1, -1, 5, -1, 7, -1, 9,
10, -1, -1, 201, -1, -1, 16, 17, -1, 1990,
1991, 201, 22, 23, 24, 25, -1, -1, 28, 29,
30, 31, 32, 33, -1, 35, -1, 37, 38, -1,
-1, -1, -1, -1, -1, -1, 1766, -1, 2019, -1,
-1, -1, -1, -1, -1, -1, 2027, -1, -1, -1,
-1, -1, -1, -1, -1, -1, 2037, -1, 5, -1,
-1, 8, 9, 10, -1, -1, -1, -1, -1, 16,
17, -1, 2053, -1, 2055, 22, 23, 24, 25, -1,
-1, 28, 29, 30, 31, 32, 33, -1, 35, -1,
37, 38, 5, -1, -1, 8, 9, 10, -1, -1,
-1, 625, -1, 16, 17, -1, -1, -1, -1, 22,
23, 24, 25, -1, -1, 28, 29, 30, 31, 32,
33, -1, 35, -1, 37, 38, -1, -1, -1, -1,
1860, 1861, -1, -1, 1864, 5, 1866, 1867, 1868, 9,
1870, 1871, 1872, -1, -1, -1, 16, 17, 1878, 1879,
-1, -1, 22, 23, 24, 25, -1, -1, 28, 29,
30, 31, 32, 33, -1, 35, -1, 37, 38, 2150,
-1, -1, -1, -1, 2155, 1905, 1906, 1907, 1908, 1909,
-1, -1, -1, -1, 5, 2166, 2167, 8, 9, 10,
2171, -1, -1, -1, -1, 16, 17, -1, -1, -1,
2181, 22, 23, 24, 25, -1, 2187, 28, 29, 30,
31, 32, 33, -1, 35, 5, 37, 38, 8, 9,
10, -1, -1, -1, -1, 1955, 16, 17, -1, -1,
-1, 1961, 22, 23, 24, 25, -1, -1, 28, 29,
30, 31, 32, 33, -1, 35, -1, 37, 38, -1,
2231, 775, -1, -1, -1, 779, -1, -1, 5, -1,
-1, -1, 9, 10, 1994, 1995, -1, -1, -1, 16,
17, -1, -1, -1, 21, 22, 23, 24, 25, 2260,
-1, 28, 29, 30, 31, 32, 33, 2017, 35, -1,
37, 38, -1, -1, 2275, -1, -1, -1, 2028, -1,
2281, -1, 826, -1, -1, 5, -1, -1, -1, 9,
10, -1, -1, -1, 838, -1, 16, 17, -1, 2049,
-1, 21, 22, 23, 24, 25, -1, -1, 28, 29,
30, 31, 32, 33, -1, 35, 2317, 37, 38, -1,
-1, -1, -1, -1, 2074, 2075, -1, -1, -1, -1,
-1, 2332, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, 888, 889, 890, 891, 5, 893,
7, -1, 9, 10, -1, -1, -1, -1, -1, 16,
17, -1, -1, -1, -1, 22, 23, 24, 25, -1,
-1, 28, 29, 30, 31, 32, 33, 2127, 35, -1,
37, 38, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, 2395, 2396, -1, -1, 2399, -1,
2401, 945, -1, 947, 948, 949, 950, 2157, -1, -1,
2160, -1, 2162, -1, -1, 2416, 2417, -1, 2419, -1,
5, -1, 7, -1, 9, 10, -1, -1, 2429, -1,
-1, 16, 17, -1, -1, -1, 2437, 22, 23, 24,
25, -1, -1, 28, 29, 30, 31, 32, 33, -1,
35, -1, 37, 38, -1, 2456, -1, -1, -1, -1,
-1, -1, 1006, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, 2232, 2484, 1028, -1, -1, -1, -1, -1,
-1, -1, 2493, 2494, 1038, -1, -1, -1, -1, -1,
5, -1, -1, 2504, 9, 10, 2507, -1, 2258, -1,
2511, 16, 17, -1, -1, 1059, 21, 22, 23, 24,
25, -1, -1, 28, 29, 30, 31, 32, 33, -1,
35, 1075, 37, 38, -1, 1079, 1080, -1, -1, -1,
-1, -1, -1, 2544, -1, -1, -1, -1, -1, -1,
2551, -1, -1, -1, 2555, -1, -1, -1, 2559, -1,
-1, -1, 2563, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, 2577, 2578, 2579, -1,
-1, -1, -1, -1, 2334, 5, -1, -1, 2338, 9,
10, -1, -1, 1137, -1, -1, 16, 17, -1, -1,
-1, 21, 22, 23, 24, 25, -1, -1, 28, 29,
30, 31, 32, 33, -1, 35, 5, 37, 38, -1,
9, 10, -1, -1, -1, 2375, 2376, 16, 17, -1,
-1, -1, 21, 22, 23, 24, 25, -1, -1, 28,
29, 30, 31, 32, 33, -1, 35, -1, 37, 38,
-1, 1195, 1196, -1, -1, -1, -1, -1, -1, -1,
2410, 2411, 2412, 2413, -1, 5, -1, -1, 2418, 9,
10, -1, -1, -1, -1, -1, 16, 17, 2428, -1,
-1, 21, 22, 23, 24, 25, -1, -1, 28, 29,
30, 31, 32, 33, -1, 35, -1, 37, 38, -1,
-1, 5, -1, -1, -1, 9, 10, -1, -1, -1,
-1, -1, 16, 17, -1, -1, -1, 21, 22, 23,
24, 25, -1, 2473, 28, 29, 30, 31, 32, 33,
-1, 35, -1, 37, 38, -1, -1, -1, -1, -1,
-1, -1, -1, 5, -1, 7, -1, 9, 10, 2499,
2500, -1, 2502, -1, 16, 17, -1, -1, -1, 2509,
22, 23, 24, 25, -1, -1, 28, 29, 30, 31,
32, 33, -1, 35, -1, 37, 38, 1321, 1322, 1323,
1324, 1325, 1326, 1327, 1328, 1329, 1330, 1331, 1332, 1333,
1334, 1335, 1336, 1337, 1338, 1339, -1, -1, -1, -1,
-1, -1, -1, 2553, -1, -1, -1, -1, -1, -1,
-1, 1355, -1, -1, -1, -1, -1, 5, 1362, -1,
1364, 9, 10, -1, -1, -1, -1, -1, 16, 17,
1374, -1, -1, 21, 22, 23, 24, 25, -1, -1,
28, 29, 30, 31, 32, 33, -1, 35, -1, 37,
38, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, 1405, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, 14, 15, 16, 17, -1,
19, -1, 21, -1, 23, 24, -1, 26, -1, -1,
-1, 30, -1, 32, 33, -1, -1, 36, 37, 38,
-1, 40, -1, 42, 43, -1, -1, 46, -1, -1,
-1, -1, 51, 52, 53, 54, 55, 56, 57, 58,
-1, 60, 61, -1, -1, 64, 65, 66, -1, 68,
1474, 70, -1, -1, 73, 74, -1, -1, -1, -1,
-1, -1, 81, 82, 1488, -1, 85, -1, -1, -1,
-1, -1, -1, 92, -1, 94, -1, 96, 97, -1,
-1, -1, 101, 102, 103, 1509, -1, 106, -1, -1,
109, 110, -1, 112, 113, 114, -1, -1, -1, -1,
119, 120, -1, -1, 123, -1, 125, 126, 127, -1,
129, 130, -1, -1, 133, -1, 135, 136, 137, 138,
139, 140, -1, -1, -1, -1, -1, -1, 147, 148,
149, -1, -1, -1, 1558, 154, 155, 156, -1, 158,
159, 160, 161, 162, 163, 164, 165, 166, 167, 168,
169, 170, 171, 172, 173, 174, 175, 176, 177, 178,
179, 180, 181, 182, 183, -1, 185, -1, 187, -1,
189, -1, 191, 192, -1, -1, 195, 196, 197, 198,
199, 200, 201, 202, 5, 1609, -1, -1, 9, 10,
-1, -1, -1, -1, -1, 16, 17, -1, -1, -1,
21, 22, 23, 24, 25, -1, -1, 28, 29, 30,
31, 32, 33, -1, 35, -1, 37, 38, 1642, -1,
-1, -1, -1, -1, -1, 1649, -1, -1, -1, -1,
-1, 1655, -1, -1, -1, -1, 255, -1, -1, 258,
-1, 260, -1, -1, -1, 5, -1, -1, -1, 9,
10, -1, -1, -1, 1678, -1, 16, 17, -1, -1,
-1, 21, 22, 23, 24, 25, 1690, -1, 28, 29,
30, 31, 32, 33, 1698, 35, -1, 37, 38, -1,
-1, -1, -1, -1, 1708, -1, -1, 1711, -1, -1,
-1, -1, 5, -1, -1, -1, 9, 10, -1, -1,
-1, -1, 1726, 16, 17, -1, -1, -1, 21, 22,
23, 24, 25, -1, 1738, 28, 29, 30, 31, 32,
33, -1, 35, -1, 37, 38, -1, 5, 1752, 7,
-1, 9, 10, -1, 1758, -1, -1, -1, 16, 17,
1764, -1, -1, -1, 22, 23, 24, 25, -1, -1,
28, 29, 30, 31, 32, 33, -1, 35, 5, 37,
38, -1, 9, 10, -1, -1, -1, -1, -1, 16,
17, -1, -1, -1, 21, 22, 23, 24, 25, -1,
-1, 28, 29, 30, 31, 32, 33, -1, 35, -1,
37, 38, 5, -1, 7, -1, 9, 10, -1, -1,
-1, -1, -1, 16, 17, -1, -1, -1, -1, 22,
23, 24, 25, -1, -1, 28, 29, 30, 31, 32,
33, -1, 35, -1, 37, 38, 5, -1, 7, -1,
9, 10, -1, -1, -1, -1, -1, 16, 17, -1,
-1, -1, -1, 22, 23, 24, 25, -1, -1, 28,
29, 30, 31, 32, 33, -1, 35, 5, 37, 38,
-1, 9, 10, -1, -1, -1, -1, -1, 16, 17,
-1, -1, 1896, 21, 22, 23, 24, 25, -1, -1,
28, 29, 30, 31, 32, 33, -1, 35, -1, 37,
38, -1, -1, -1, 5, -1, -1, -1, 9, 10,
-1, -1, -1, -1, -1, 16, 17, -1, -1, -1,
21, 22, 23, 24, 25, -1, 1940, 28, 29, 30,
31, 32, 33, -1, 35, -1, 37, 38, 5, -1,
-1, -1, 9, 10, -1, -1, 1960, -1, 1962, 16,
17, -1, 1966, -1, 21, 22, 23, 24, 25, -1,
-1, 28, 29, 30, 31, 32, 33, -1, 35, -1,
37, 38, -1, -1, -1, 1989, -1, -1, 1992, 5,
-1, -1, 8, 9, 10, -1, -1, -1, -1, -1,
16, 17, -1, 602, 603, -1, 22, 23, 24, 25,
2014, -1, 28, 29, 30, 31, 32, 33, -1, 35,
5, 37, 38, -1, 9, 10, -1, -1, -1, -1,
-1, 16, 17, -1, -1, -1, 21, 22, 23, 24,
25, -1, -1, 28, 29, 30, 31, 32, 33, -1,
35, 5, 37, 38, -1, 9, 10, -1, -1, -1,
-1, -1, 16, 17, -1, -1, -1, 21, 22, 23,
24, 25, -1, -1, 28, 29, 30, 31, 32, 33,
-1, 35, -1, 37, 38, -1, -1, -1, 5, 2093,
-1, -1, 9, 10, -1, -1, -1, -1, 2102, 16,
17, -1, 2106, 2107, 21, 22, 23, 24, 25, -1,
2114, 28, 29, 30, 31, 32, 33, -1, 35, 5,
37, 38, 8, 9, 10, -1, -1, -1, -1, -1,
16, 17, -1, -1, -1, -1, 22, 23, 24, 25,
-1, 2145, 28, 29, 30, 31, 32, 33, -1, 35,
-1, 37, 38, -1, -1, -1, -1, -1, -1, -1,
2164, -1, 5, -1, -1, 2169, 9, 10, -1, -1,
-1, -1, -1, 16, 17, 2179, 2180, -1, 21, 22,
23, 24, 25, -1, -1, 28, 29, 30, 31, 32,
33, -1, 35, -1, 37, 38, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, 2210, 5, -1, -1,
8, 9, 10, -1, -1, -1, 2220, 2221, 16, 17,
-1, -1, -1, -1, 22, 23, 24, 25, -1, -1,
28, 29, 30, 31, 32, 33, -1, 35, 5, 37,
38, 8, 9, 10, -1, -1, -1, -1, -1, 16,
17, -1, -1, -1, -1, 22, 23, 24, 25, -1,
-1, 28, 29, 30, 31, 32, 33, -1, 35, -1,
37, 38, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, 2296, -1, 2298, -1, -1, -1, -1, -1,
-1, -1, 5, 2307, -1, -1, 9, 10, 2312, -1,
-1, 2315, -1, 16, 17, -1, -1, -1, 21, 22,
23, 24, 25, -1, 2328, 28, 29, 30, 31, 32,
33, -1, 35, 5, 37, 38, 8, 9, 10, -1,
-1, -1, -1, -1, 16, 17, -1, -1, -1, -1,
22, 23, 24, 25, -1, -1, 28, 29, 30, 31,
32, 33, -1, 35, -1, 37, 38, 5, -1, 2373,
-1, 9, 10, -1, -1, 2379, -1, -1, 16, 17,
-1, -1, 2386, 21, 22, 23, 24, 25, -1, -1,
28, 29, 30, 31, 32, 33, -1, 35, 5, 37,
38, 2405, 9, 10, -1, -1, -1, -1, -1, 16,
17, -1, -1, -1, 21, 22, 23, 24, 25, -1,
-1, 28, 29, 30, 31, 32, 33, -1, 35, -1,
37, 38, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, 2449, -1, 2451, -1, -1,
-1, 2455, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, 2466, 2467, -1, -1, -1, 2471, 5, -1,
-1, 8, 9, 10, -1, -1, -1, 2481, -1, 16,
17, 2485, -1, -1, -1, 22, 23, 24, 25, -1,
-1, 28, 29, 30, 31, 32, 33, -1, 35, -1,
37, 38, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, 2518, -1, -1, -1, -1, -1,
2524, -1, 2526, -1, -1, -1, 5, -1, -1, 8,
9, 10, 6, -1, 2538, -1, 2540, 16, 17, 13,
-1, -1, -1, 22, 23, 24, 25, -1, -1, 28,
29, 30, 31, 32, 33, -1, 35, -1, 37, 38,
-1, -1, -1, -1, 2568, -1, -1, -1, 2572, 43,
44, 45, 46, -1, 48, 49, 50, 51, 52, 53,
2584, -1, 56, 57, -1, -1, -1, 61, 62, 63,
-1, 65, 66, 67, 68, 69, 70, -1, 72, 73,
74, 75, 76, 77, -1, 79, 80, 81, 82, 83,
84, -1, -1, 87, 88, 89, 90, 91, -1, -1,
94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
104, 105, 106, 107, 108, 109, 110, 111, 112, 113,
114, 115, -1, 117, -1, 119, 120, -1, 122, 123,
124, -1, -1, 127, -1, -1, 130, 131, -1, 133,
134, 135, 136, -1, 138, 139, 140, 141, 142, 143,
144, 145, 146, -1, -1, -1, -1, -1, 152, 153,
154, 155, -1, -1, -1, -1, 160, -1, -1, 163,
164, -1, -1, 167, 168, -1, 170, -1, -1, -1,
174, -1, 176, -1, 178, -1, -1, -1, 182, 183,
184, 185, 186, 187, 188, 189, 190, 191, -1, 193,
194, 195, -1, 197, -1, 199, 200, -1, 202, -1,
204, 205, 206, 207, -1, -1, 210, 211, 212, -1,
214, 215, 216, -1, 218, 219, 220, -1, 222, -1,
224, 225, 226, 227, 228, -1, 230, -1, 232, 233,
-1, -1, 236, 237, 238, -1, -1, 241, 242, -1,
244, 245, -1, 247, 248, -1, -1, -1, 252, 253,
-1, -1, 256, -1, -1, 259, -1, -1, -1, 263,
264, -1, -1, 267, 268, 269, -1, 271, 272, 273,
274, 275, 276, 277, 278, 279, 280, 281, -1, 283,
-1, -1, 286, -1, -1, -1, 290, 291, 292, 293,
294, -1, 296, 297, -1, -1, 300, 301, 302, 303,
-1, -1, -1, -1, 308, 309, 310, 311, 312, 313,
-1, -1, -1, -1, -1, -1, -1, 321, -1, 323,
-1, 325, 326, 327, 328, 329, -1, -1, -1, 333,
334, 335, 336, 337, 338, 5, 340, 341, -1, 9,
10, 345, -1, -1, -1, -1, 16, 17, -1, -1,
-1, 21, 22, 23, 24, 25, -1, -1, 28, 29,
30, 31, 32, 33, -1, 35, 5, 37, 38, -1,
9, 10, -1, -1, -1, -1, -1, 16, 17, -1,
-1, -1, 21, 22, 23, 24, 25, -1, -1, 28,
29, 30, 31, 32, 33, -1, 35, 5, 37, 38,
8, 9, 10, -1, -1, -1, -1, -1, 16, 17,
-1, -1, -1, -1, 22, 23, 24, 25, -1, -1,
28, 29, 30, 31, 32, 33, -1, 35, -1, 37,
38, 5, -1, 7, -1, 9, 10, -1, -1, -1,
-1, -1, 16, 17, -1, -1, -1, -1, 22, 23,
24, 25, -1, -1, 28, 29, 30, 31, 32, 33,
-1, 35, 5, 37, 38, -1, 9, 10, -1, -1,
-1, -1, -1, 16, 17, -1, -1, -1, -1, 22,
23, 24, 25, -1, -1, 28, 29, 30, 31, 32,
33, -1, 35, -1, 37, 38
};
/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
symbol of state STATE-NUM. */
static const yytype_uint16 yystos[] =
{
0, 363, 0, 1, 150, 257, 364, 365, 116, 6,
13, 43, 44, 45, 46, 48, 49, 50, 51, 52,
53, 56, 57, 61, 62, 63, 65, 66, 67, 68,
69, 70, 72, 73, 74, 75, 76, 77, 79, 80,
81, 82, 83, 84, 87, 88, 89, 90, 91, 94,
95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
115, 117, 119, 120, 122, 123, 124, 127, 130, 131,
133, 134, 135, 136, 138, 139, 140, 141, 142, 143,
144, 145, 146, 152, 153, 154, 155, 160, 163, 164,
167, 168, 170, 174, 176, 178, 182, 183, 184, 185,
186, 187, 188, 189, 190, 191, 193, 194, 195, 197,
199, 200, 202, 204, 205, 206, 207, 210, 211, 212,
214, 215, 216, 218, 219, 220, 222, 224, 225, 226,
227, 228, 230, 232, 233, 236, 237, 238, 241, 242,
244, 245, 247, 248, 252, 253, 256, 259, 263, 264,
267, 268, 269, 271, 272, 273, 274, 275, 276, 277,
278, 279, 280, 281, 283, 286, 290, 291, 292, 293,
294, 296, 297, 300, 301, 302, 303, 308, 309, 310,
311, 312, 313, 321, 323, 325, 326, 327, 328, 329,
333, 334, 335, 336, 337, 338, 340, 341, 345, 366,
368, 371, 383, 384, 388, 389, 390, 396, 397, 398,
399, 401, 402, 404, 406, 407, 408, 409, 416, 417,
418, 419, 420, 421, 425, 426, 427, 431, 432, 470,
472, 485, 528, 529, 531, 532, 538, 539, 540, 541,
548, 549, 550, 551, 553, 556, 560, 561, 562, 563,
564, 565, 571, 572, 573, 584, 585, 586, 588, 591,
594, 599, 600, 602, 604, 606, 609, 610, 634, 635,
646, 647, 648, 649, 654, 657, 660, 663, 664, 714,
715, 716, 717, 718, 719, 720, 721, 727, 729, 731,
733, 735, 736, 737, 738, 739, 742, 744, 745, 746,
749, 750, 754, 755, 757, 758, 759, 760, 761, 762,
763, 766, 771, 776, 778, 779, 780, 781, 783, 784,
785, 786, 787, 788, 805, 808, 809, 810, 811, 817,
820, 825, 826, 827, 830, 831, 832, 833, 834, 835,
836, 837, 838, 839, 840, 841, 842, 843, 844, 849,
850, 851, 852, 853, 854, 864, 865, 866, 869, 873,
874, 875, 876, 877, 882, 902, 15, 495, 495, 557,
557, 557, 557, 557, 495, 557, 557, 367, 557, 557,
557, 495, 557, 495, 557, 557, 495, 557, 557, 557,
494, 557, 495, 557, 557, 7, 15, 496, 15, 495,
617, 557, 495, 380, 557, 557, 557, 557, 557, 557,
557, 557, 557, 557, 129, 373, 537, 537, 557, 557,
557, 495, 557, 373, 557, 495, 495, 557, 557, 494,
367, 495, 495, 64, 379, 557, 557, 495, 495, 557,
495, 495, 495, 495, 495, 557, 434, 557, 557, 557,
373, 471, 367, 495, 557, 557, 557, 495, 557, 495,
557, 557, 495, 557, 557, 557, 495, 367, 495, 380,
557, 557, 380, 557, 495, 557, 557, 557, 495, 557,
557, 495, 557, 495, 557, 557, 557, 557, 557, 557,
15, 495, 595, 495, 367, 495, 495, 557, 557, 557,
15, 8, 495, 495, 557, 557, 557, 495, 557, 557,
557, 557, 557, 557, 557, 557, 557, 557, 557, 557,
557, 557, 557, 557, 557, 557, 557, 557, 557, 557,
557, 557, 557, 557, 495, 557, 495, 557, 557, 557,
557, 495, 495, 557, 557, 557, 557, 557, 557, 557,
557, 908, 908, 908, 908, 908, 908, 257, 583, 124,
233, 404, 15, 376, 583, 8, 8, 8, 8, 7,
8, 124, 368, 391, 8, 373, 405, 8, 8, 8,
8, 8, 552, 8, 552, 8, 8, 8, 8, 552,
583, 7, 218, 252, 529, 531, 540, 541, 239, 549,
549, 10, 14, 15, 16, 17, 27, 34, 36, 64,
92, 149, 201, 373, 385, 501, 502, 504, 505, 506,
507, 513, 514, 515, 516, 517, 520, 15, 557, 5,
9, 15, 16, 17, 129, 503, 505, 513, 567, 581,
582, 557, 15, 567, 557, 5, 566, 567, 582, 567,
8, 8, 8, 8, 8, 8, 8, 8, 7, 8,
8, 5, 7, 373, 644, 645, 373, 637, 496, 15,
15, 149, 484, 373, 373, 747, 748, 8, 373, 661,
662, 748, 373, 375, 373, 15, 533, 579, 23, 37,
373, 423, 424, 15, 373, 607, 373, 675, 675, 373,
658, 659, 373, 536, 433, 15, 373, 587, 149, 753,
536, 7, 479, 480, 495, 618, 619, 373, 613, 619,
15, 558, 373, 589, 590, 536, 15, 15, 536, 753,
537, 536, 536, 536, 536, 373, 536, 376, 536, 15,
428, 496, 504, 505, 15, 370, 373, 373, 655, 656,
486, 487, 488, 489, 8, 676, 743, 15, 373, 601,
373, 592, 593, 580, 15, 15, 373, 496, 15, 501,
756, 15, 15, 373, 730, 732, 8, 373, 37, 422,
15, 505, 506, 496, 15, 15, 558, 484, 496, 505,
373, 722, 5, 15, 581, 582, 496, 373, 374, 496,
580, 15, 504, 638, 639, 613, 617, 373, 605, 373,
702, 702, 15, 373, 603, 722, 501, 512, 496, 380,
15, 373, 708, 708, 708, 708, 708, 7, 501, 596,
597, 373, 598, 496, 369, 373, 496, 373, 728, 730,
373, 495, 496, 373, 473, 15, 15, 580, 373, 15,
619, 15, 619, 619, 619, 619, 791, 847, 619, 619,
619, 619, 619, 619, 791, 373, 380, 855, 856, 857,
15, 15, 8, 870, 871, 872, 496, 15, 501, 501,
501, 501, 500, 501, 15, 15, 15, 15, 15, 373,
900, 15, 367, 367, 124, 5, 21, 373, 377, 378,
372, 380, 373, 373, 373, 424, 7, 380, 367, 124,
373, 373, 5, 15, 411, 412, 373, 424, 424, 424,
424, 423, 504, 422, 373, 373, 428, 435, 436, 438,
439, 557, 557, 239, 414, 501, 502, 501, 501, 501,
501, 5, 9, 16, 17, 22, 23, 24, 25, 26,
28, 29, 30, 31, 32, 33, 35, 37, 38, 385,
15, 246, 3, 15, 246, 246, 15, 510, 511, 21,
554, 579, 512, 5, 9, 166, 568, 569, 570, 581,
26, 581, 5, 9, 23, 37, 503, 580, 581, 580,
8, 15, 505, 574, 575, 15, 501, 502, 517, 576,
577, 578, 576, 587, 373, 601, 603, 605, 607, 373,
7, 380, 728, 8, 21, 639, 424, 526, 501, 240,
552, 15, 380, 15, 478, 8, 579, 7, 501, 534,
535, 536, 15, 373, 478, 424, 483, 484, 8, 435,
526, 478, 15, 8, 21, 5, 7, 481, 482, 501,
373, 8, 21, 5, 58, 86, 126, 137, 165, 258,
620, 616, 617, 175, 608, 501, 149, 547, 8, 501,
501, 372, 373, 429, 430, 504, 509, 373, 26, 373,
542, 543, 545, 376, 8, 8, 15, 231, 404, 490,
380, 8, 743, 373, 504, 712, 722, 740, 741, 8,
567, 26, 5, 9, 16, 17, 22, 23, 24, 25,
28, 29, 30, 31, 32, 33, 34, 35, 37, 38,
385, 386, 387, 373, 380, 394, 504, 501, 15, 380,
373, 373, 504, 504, 527, 8, 677, 734, 373, 504,
665, 373, 468, 469, 547, 424, 18, 580, 581, 580,
400, 403, 644, 639, 7, 617, 619, 712, 722, 723,
724, 423, 424, 462, 463, 62, 504, 767, 15, 15,
7, 8, 21, 595, 424, 376, 424, 478, 8, 674,
699, 21, 380, 373, 8, 501, 501, 478, 504, 552,
812, 504, 287, 824, 824, 552, 821, 824, 15, 552,
789, 552, 828, 789, 789, 552, 806, 552, 818, 478,
147, 148, 180, 314, 315, 318, 319, 381, 858, 859,
860, 8, 21, 505, 680, 861, 21, 861, 380, 872,
373, 867, 868, 380, 764, 765, 8, 8, 8, 8,
504, 507, 508, 782, 665, 380, 883, 884, 885, 886,
887, 888, 889, 380, 892, 893, 894, 895, 896, 380,
897, 898, 8, 380, 903, 904, 373, 369, 367, 8,
21, 213, 381, 478, 44, 87, 93, 119, 143, 145,
178, 183, 187, 191, 194, 216, 230, 236, 392, 393,
395, 373, 367, 495, 558, 579, 405, 478, 552, 552,
8, 37, 15, 373, 441, 446, 380, 15, 521, 21,
8, 501, 501, 501, 501, 501, 501, 501, 501, 501,
501, 501, 501, 501, 501, 501, 501, 501, 501, 501,
579, 64, 129, 497, 499, 579, 504, 515, 518, 64,
518, 512, 8, 21, 5, 501, 555, 570, 8, 21,
5, 9, 501, 21, 501, 581, 581, 581, 581, 581,
21, 574, 574, 8, 501, 502, 577, 578, 8, 8,
8, 478, 478, 495, 43, 67, 82, 87, 88, 94,
228, 259, 303, 648, 645, 380, 508, 524, 21, 373,
15, 500, 67, 479, 662, 501, 7, 8, 21, 554,
37, 8, 21, 659, 504, 507, 523, 525, 579, 751,
481, 7, 478, 619, 15, 15, 15, 15, 15, 15,
608, 619, 373, 21, 559, 590, 21, 21, 15, 8,
21, 8, 511, 505, 8, 544, 26, 372, 656, 487,
129, 491, 492, 493, 409, 169, 208, 282, 380, 15,
7, 8, 21, 593, 576, 21, 21, 147, 148, 180,
21, 18, 21, 7, 501, 519, 175, 324, 37, 8,
21, 380, 8, 21, 26, 8, 21, 559, 501, 21,
464, 465, 464, 21, 7, 619, 608, 15, 7, 8,
21, 8, 15, 15, 26, 709, 710, 712, 500, 501,
597, 380, 8, 699, 8, 674, 405, 395, 382, 21,
21, 21, 619, 552, 21, 619, 552, 848, 619, 552,
619, 552, 619, 552, 619, 552, 15, 15, 15, 15,
15, 15, 380, 857, 8, 21, 21, 191, 859, 8,
182, 315, 318, 8, 21, 380, 380, 380, 501, 15,
15, 8, 21, 21, 183, 191, 208, 357, 358, 8,
21, 41, 209, 228, 8, 21, 339, 342, 343, 344,
355, 356, 8, 21, 380, 244, 331, 346, 347, 348,
8, 21, 376, 373, 378, 15, 410, 411, 478, 495,
15, 7, 8, 373, 478, 15, 515, 5, 413, 501,
570, 424, 504, 438, 15, 16, 17, 27, 36, 59,
64, 92, 149, 201, 437, 439, 449, 450, 451, 452,
453, 454, 455, 456, 441, 446, 447, 448, 15, 442,
443, 62, 501, 576, 502, 497, 21, 8, 498, 501,
519, 570, 7, 579, 484, 501, 579, 8, 575, 21,
8, 8, 8, 502, 578, 502, 578, 502, 578, 373,
255, 8, 21, 484, 483, 21, 7, 21, 501, 534,
21, 484, 552, 8, 21, 570, 752, 8, 21, 482,
501, 620, 579, 15, 622, 373, 621, 621, 501, 621,
478, 619, 239, 536, 500, 430, 430, 373, 501, 543,
21, 501, 519, 8, 21, 16, 15, 15, 15, 500,
740, 741, 496, 504, 772, 7, 501, 7, 21, 21,
373, 615, 505, 504, 191, 504, 619, 666, 501, 469,
552, 8, 47, 177, 373, 467, 380, 636, 638, 608,
7, 7, 501, 725, 726, 723, 724, 463, 501, 5,
622, 768, 769, 775, 501, 632, 8, 21, 15, 21,
71, 208, 380, 380, 496, 172, 373, 476, 477, 505,
191, 208, 282, 285, 290, 298, 792, 793, 794, 801,
813, 814, 815, 619, 266, 822, 823, 824, 619, 37,
504, 845, 846, 84, 265, 289, 299, 304, 790, 792,
793, 794, 795, 796, 797, 799, 800, 801, 619, 792,
793, 794, 795, 796, 797, 799, 800, 801, 814, 815,
829, 619, 792, 793, 794, 801, 807, 619, 792, 793,
819, 619, 861, 861, 861, 380, 862, 863, 861, 861,
505, 15, 868, 765, 331, 315, 332, 579, 497, 508,
15, 15, 15, 15, 15, 884, 15, 15, 15, 893,
15, 15, 15, 15, 898, 352, 353, 15, 15, 15,
15, 15, 904, 373, 18, 26, 415, 15, 394, 7,
380, 410, 559, 559, 414, 5, 501, 452, 453, 454,
457, 453, 455, 453, 455, 246, 246, 246, 246, 246,
8, 37, 373, 440, 504, 5, 442, 443, 8, 15,
16, 17, 149, 373, 440, 444, 445, 458, 459, 460,
461, 15, 443, 15, 21, 522, 21, 21, 511, 579,
501, 512, 555, 569, 581, 545, 546, 502, 546, 546,
546, 478, 373, 640, 643, 579, 8, 21, 7, 414,
501, 579, 501, 579, 570, 633, 501, 623, 624, 21,
21, 21, 21, 8, 8, 254, 530, 536, 21, 492,
493, 680, 680, 680, 21, 21, 373, 15, 21, 501,
7, 7, 501, 478, 15, 173, 8, 670, 671, 672,
673, 674, 676, 677, 678, 681, 683, 684, 685, 699,
707, 545, 465, 15, 15, 466, 255, 8, 7, 8,
21, 21, 21, 8, 21, 21, 710, 711, 15, 15,
373, 373, 474, 475, 477, 18, 8, 26, 791, 15,
791, 791, 15, 619, 813, 791, 619, 822, 373, 8,
21, 15, 791, 15, 791, 15, 619, 790, 619, 829,
619, 807, 619, 819, 21, 21, 21, 316, 317, 8,
21, 21, 21, 867, 15, 15, 497, 21, 508, 890,
891, 680, 380, 703, 515, 680, 709, 723, 709, 665,
665, 508, 901, 501, 899, 15, 15, 380, 905, 906,
665, 665, 501, 380, 907, 21, 501, 501, 650, 651,
21, 393, 415, 5, 501, 405, 8, 21, 8, 518,
518, 518, 518, 518, 449, 5, 15, 439, 450, 443,
373, 440, 448, 458, 459, 459, 8, 21, 7, 16,
17, 5, 37, 9, 458, 501, 20, 511, 498, 21,
26, 21, 21, 21, 21, 15, 508, 570, 484, 661,
496, 523, 570, 752, 501, 21, 7, 8, 21, 501,
380, 15, 21, 21, 21, 7, 773, 774, 775, 501,
501, 7, 680, 504, 667, 380, 672, 26, 467, 26,
386, 640, 638, 373, 611, 612, 613, 614, 726, 769,
619, 78, 596, 373, 675, 723, 700, 8, 373, 477,
501, 619, 802, 380, 619, 619, 847, 504, 845, 380,
501, 501, 619, 619, 619, 619, 863, 21, 680, 504,
21, 26, 8, 21, 21, 22, 24, 33, 35, 158,
159, 161, 162, 192, 234, 247, 704, 705, 706, 8,
21, 21, 21, 21, 21, 21, 21, 21, 8, 21,
8, 21, 380, 878, 879, 878, 315, 351, 8, 21,
21, 21, 21, 349, 350, 8, 8, 21, 7, 21,
21, 579, 457, 450, 579, 440, 26, 21, 458, 445,
459, 459, 460, 460, 460, 21, 501, 5, 501, 519,
641, 642, 504, 8, 680, 504, 8, 501, 624, 380,
21, 254, 501, 8, 21, 501, 21, 15, 41, 135,
209, 221, 223, 224, 226, 229, 320, 322, 501, 466,
21, 21, 15, 8, 132, 770, 21, 21, 7, 21,
702, 704, 475, 5, 16, 17, 22, 24, 33, 35,
37, 159, 162, 247, 305, 306, 307, 804, 21, 94,
230, 284, 295, 816, 37, 191, 288, 299, 798, 21,
21, 21, 21, 501, 891, 15, 15, 380, 508, 501,
354, 359, 8, 21, 21, 906, 501, 7, 7, 413,
21, 497, 444, 458, 21, 8, 8, 21, 484, 570,
255, 15, 21, 774, 5, 501, 668, 669, 15, 686,
15, 15, 15, 15, 708, 708, 15, 15, 15, 8,
500, 612, 712, 713, 15, 723, 701, 701, 7, 8,
21, 848, 21, 8, 505, 680, 704, 8, 15, 879,
8, 880, 8, 881, 21, 7, 414, 21, 21, 501,
642, 501, 373, 625, 626, 501, 8, 21, 687, 686,
722, 740, 722, 723, 712, 709, 501, 501, 679, 667,
682, 501, 21, 8, 380, 21, 7, 8, 21, 680,
803, 501, 380, 21, 8, 501, 92, 380, 380, 373,
652, 653, 21, 8, 15, 21, 669, 148, 180, 688,
7, 21, 7, 21, 15, 21, 21, 8, 21, 8,
21, 8, 712, 78, 703, 703, 21, 330, 501, 505,
21, 353, 352, 8, 501, 40, 501, 627, 628, 775,
7, 7, 689, 690, 712, 740, 723, 596, 501, 667,
501, 21, 21, 21, 15, 21, 15, 15, 653, 373,
629, 8, 21, 8, 21, 15, 21, 21, 21, 8,
500, 878, 878, 17, 630, 631, 628, 690, 501, 691,
692, 21, 501, 21, 21, 21, 632, 17, 7, 8,
21, 8, 777, 632, 501, 692, 15, 380, 380, 693,
694, 695, 696, 697, 182, 318, 128, 157, 217, 8,
21, 7, 7, 15, 698, 698, 698, 694, 380, 696,
697, 380, 697, 499, 7, 21, 697
};
/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
static const yytype_uint16 yyr1[] =
{
0, 362, 363, 363, 364, 364, 364, 364, 364, 364,
364, 365, 366, 366, 366, 366, 366, 366, 366, 366,
367, 368, 368, 368, 369, 370, 371, 371, 371, 371,
372, 372, 373, 374, 374, 375, 375, 376, 376, 376,
377, 377, 378, 378, 379, 380, 381, 382, 383, 383,
383, 383, 383, 383, 383, 383, 383, 383, 383, 383,
383, 383, 383, 383, 383, 383, 383, 383, 383, 383,
383, 383, 383, 383, 383, 383, 383, 383, 384, 384,
384, 384, 384, 385, 386, 386, 387, 387, 387, 387,
387, 387, 387, 387, 387, 387, 387, 387, 387, 387,
387, 387, 387, 387, 388, 388, 389, 389, 390, 390,
391, 391, 391, 392, 392, 393, 393, 393, 393, 393,
393, 393, 393, 393, 393, 393, 393, 394, 394, 394,
395, 395, 396, 396, 397, 397, 398, 398, 399, 399,
400, 401, 402, 402, 403, 404, 404, 405, 406, 406,
407, 407, 408, 409, 409, 409, 409, 409, 409, 409,
410, 410, 411, 411, 411, 412, 412, 412, 412, 413,
413, 413, 413, 414, 415, 415, 415, 416, 416, 417,
417, 418, 418, 419, 419, 420, 420, 420, 420, 421,
421, 421, 422, 423, 423, 424, 425, 425, 426, 426,
427, 427, 428, 429, 429, 430, 430, 430, 431, 432,
432, 433, 434, 435, 436, 436, 437, 437, 438, 438,
438, 438, 438, 439, 440, 441, 442, 443, 444, 444,
445, 445, 446, 447, 447, 448, 448, 448, 448, 449,
449, 449, 450, 450, 450, 450, 450, 450, 450, 450,
450, 450, 450, 451, 452, 452, 452, 453, 453, 454,
454, 454, 455, 455, 455, 455, 456, 457, 457, 458,
458, 458, 458, 458, 459, 459, 459, 460, 460, 461,
461, 461, 462, 462, 463, 463, 464, 464, 465, 466,
467, 467, 467, 468, 468, 469, 470, 471, 471, 472,
472, 472, 472, 473, 474, 474, 475, 475, 476, 476,
477, 478, 478, 480, 479, 479, 481, 481, 481, 481,
482, 482, 483, 483, 484, 485, 485, 486, 486, 487,
489, 488, 490, 490, 491, 491, 492, 492, 493, 494,
495, 496, 496, 497, 497, 498, 498, 498, 499, 499,
500, 500, 501, 501, 501, 502, 502, 502, 502, 502,
502, 502, 502, 502, 502, 502, 502, 502, 502, 502,
502, 502, 502, 502, 502, 502, 502, 502, 502, 502,
503, 503, 504, 505, 505, 505, 506, 506, 506, 506,
507, 508, 508, 508, 508, 509, 510, 510, 511, 512,
512, 513, 513, 513, 513, 513, 514, 514, 514, 514,
515, 516, 516, 516, 517, 518, 518, 519, 519, 519,
519, 519, 519, 519, 519, 521, 522, 520, 523, 523,
524, 524, 524, 525, 525, 525, 526, 527, 527, 528,
528, 528, 528, 528, 528, 528, 528, 528, 528, 528,
528, 528, 528, 528, 528, 528, 528, 528, 528, 528,
528, 528, 528, 529, 529, 530, 530, 530, 531, 531,
532, 532, 532, 532, 532, 533, 534, 534, 534, 534,
535, 535, 536, 536, 537, 537, 538, 539, 540, 541,
542, 542, 543, 544, 544, 545, 546, 546, 547, 547,
548, 548, 548, 548, 548, 549, 549, 549, 549, 549,
549, 549, 549, 549, 549, 549, 549, 549, 549, 549,
549, 549, 549, 550, 551, 551, 551, 551, 552, 552,
553, 554, 554, 555, 555, 555, 556, 556, 557, 558,
559, 560, 560, 560, 560, 560, 560, 560, 560, 560,
560, 560, 560, 560, 560, 561, 562, 562, 562, 563,
564, 564, 565, 565, 566, 566, 567, 567, 568, 568,
569, 569, 569, 569, 569, 569, 570, 571, 572, 573,
573, 574, 574, 575, 575, 576, 576, 576, 577, 577,
577, 577, 577, 577, 578, 578, 578, 578, 578, 579,
580, 581, 581, 582, 582, 582, 582, 582, 582, 582,
582, 582, 583, 583, 584, 584, 584, 584, 584, 584,
584, 584, 584, 584, 584, 584, 584, 584, 584, 584,
584, 584, 584, 585, 585, 585, 585, 585, 585, 585,
585, 585, 585, 585, 585, 585, 585, 585, 585, 585,
585, 585, 585, 585, 585, 585, 585, 585, 585, 585,
585, 585, 585, 585, 585, 585, 585, 585, 585, 585,
585, 585, 585, 585, 585, 585, 585, 586, 586, 587,
588, 589, 589, 590, 591, 592, 592, 593, 594, 595,
596, 596, 597, 597, 597, 598, 599, 599, 599, 600,
600, 601, 602, 602, 603, 604, 604, 605, 606, 606,
607, 608, 608, 609, 610, 610, 611, 611, 612, 612,
613, 614, 615, 616, 616, 617, 618, 618, 619, 620,
620, 620, 620, 620, 620, 620, 620, 621, 622, 623,
623, 624, 624, 625, 625, 626, 627, 627, 628, 628,
628, 629, 630, 630, 631, 631, 632, 633, 633, 634,
635, 635, 636, 636, 637, 638, 639, 640, 641, 641,
642, 642, 642, 643, 644, 644, 645, 645, 645, 646,
646, 647, 647, 648, 648, 648, 648, 648, 648, 648,
648, 648, 648, 648, 649, 651, 650, 650, 652, 652,
653, 654, 655, 655, 656, 657, 658, 658, 659, 660,
660, 661, 661, 662, 663, 664, 665, 665, 666, 666,
667, 668, 668, 669, 669, 670, 670, 671, 671, 672,
672, 672, 672, 672, 672, 672, 672, 672, 672, 672,
673, 673, 674, 674, 675, 676, 676, 677, 678, 679,
679, 679, 680, 680, 681, 682, 682, 683, 683, 684,
685, 685, 686, 687, 688, 688, 688, 689, 689, 690,
690, 690, 691, 691, 692, 693, 693, 694, 694, 694,
694, 694, 694, 694, 695, 696, 697, 698, 699, 699,
699, 700, 701, 702, 703, 703, 704, 704, 705, 705,
705, 705, 705, 705, 705, 705, 705, 706, 706, 707,
707, 707, 707, 707, 708, 709, 709, 710, 710, 710,
710, 711, 712, 713, 713, 714, 714, 715, 715, 716,
717, 718, 719, 720, 721, 721, 722, 723, 723, 724,
724, 725, 725, 726, 726, 727, 727, 728, 729, 729,
729, 729, 729, 730, 731, 732, 732, 733, 734, 734,
735, 736, 736, 737, 738, 739, 739, 740, 740, 741,
741, 742, 742, 742, 742, 743, 744, 745, 746, 747,
748, 748, 749, 750, 750, 751, 751, 752, 753, 754,
755, 756, 756, 757, 758, 759, 760, 761, 762, 763,
764, 764, 765, 765, 765, 766, 767, 768, 768, 769,
769, 770, 770, 771, 772, 772, 773, 773, 774, 774,
775, 776, 777, 777, 777, 778, 779, 779, 780, 781,
782, 782, 783, 784, 785, 785, 785, 785, 785, 785,
785, 785, 785, 785, 785, 785, 785, 785, 785, 785,
785, 785, 785, 785, 785, 785, 785, 785, 785, 785,
786, 787, 788, 788, 789, 789, 790, 790, 790, 790,
790, 790, 790, 790, 790, 791, 792, 793, 794, 795,
796, 797, 798, 798, 798, 799, 800, 801, 802, 803,
804, 804, 804, 804, 804, 804, 804, 804, 804, 804,
804, 804, 804, 804, 805, 805, 806, 806, 807, 807,
807, 807, 808, 808, 809, 810, 810, 811, 811, 812,
812, 813, 813, 813, 813, 813, 813, 814, 815, 815,
816, 816, 816, 816, 817, 817, 818, 818, 819, 819,
820, 820, 821, 821, 822, 822, 823, 824, 825, 826,
826, 827, 827, 828, 828, 829, 829, 829, 829, 829,
829, 829, 829, 829, 829, 829, 830, 831, 831, 832,
833, 833, 834, 835, 836, 837, 838, 839, 840, 841,
842, 842, 843, 843, 844, 844, 845, 846, 846, 846,
846, 847, 848, 849, 849, 850, 850, 850, 850, 850,
850, 851, 852, 853, 853, 853, 854, 854, 854, 855,
855, 856, 856, 857, 857, 857, 858, 858, 858, 858,
858, 859, 860, 861, 862, 862, 863, 863, 864, 865,
866, 867, 867, 868, 869, 870, 870, 871, 871, 872,
872, 873, 873, 873, 873, 873, 873, 874, 875, 876,
877, 877, 877, 878, 878, 879, 879, 880, 880, 881,
881, 882, 883, 883, 884, 884, 884, 884, 884, 885,
886, 887, 888, 889, 890, 890, 891, 892, 892, 893,
893, 893, 894, 895, 896, 897, 897, 898, 898, 898,
898, 898, 898, 898, 898, 899, 900, 901, 901, 902,
903, 903, 904, 904, 904, 904, 904, 905, 905, 906,
906, 907, 907, 908
};
/* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
static const yytype_uint8 yyr2[] =
{
0, 2, 0, 3, 3, 3, 3, 3, 2, 1,
1, 1, 3, 3, 4, 5, 5, 3, 4, 3,
0, 2, 2, 2, 1, 1, 4, 5, 4, 5,
2, 5, 1, 0, 1, 0, 1, 0, 2, 3,
1, 3, 1, 1, 1, 0, 0, 0, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 2, 4, 2, 5, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
5, 5, 2, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 4, 7, 2, 3, 7, 6,
0, 2, 5, 1, 4, 1, 1, 1, 2, 1,
4, 1, 1, 1, 1, 1, 1, 2, 2, 2,
1, 1, 7, 3, 4, 3, 4, 3, 2, 5,
0, 2, 2, 5, 0, 4, 5, 0, 2, 3,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
0, 1, 5, 6, 6, 0, 1, 5, 9, 1,
1, 2, 2, 0, 0, 2, 2, 5, 4, 4,
3, 4, 3, 4, 3, 3, 4, 5, 3, 4,
5, 3, 3, 1, 3, 2, 4, 3, 4, 3,
3, 3, 3, 3, 3, 1, 4, 1, 1, 4,
3, 0, 0, 4, 1, 3, 1, 3, 2, 3,
3, 4, 2, 0, 1, 1, 3, 5, 1, 3,
0, 1, 7, 1, 3, 2, 2, 3, 1, 1,
4, 3, 2, 1, 1, 1, 1, 3, 1, 3,
1, 1, 6, 1, 1, 2, 2, 1, 3, 1,
2, 2, 1, 3, 1, 3, 5, 1, 1, 1,
2, 2, 3, 3, 1, 3, 3, 1, 3, 1,
1, 3, 1, 3, 1, 1, 3, 5, 0, 0,
1, 4, 4, 1, 3, 3, 2, 1, 3, 3,
6, 6, 7, 1, 1, 3, 1, 1, 1, 3,
3, 0, 3, 0, 2, 3, 1, 1, 2, 3,
1, 1, 1, 3, 1, 3, 1, 1, 3, 4,
0, 2, 2, 1, 1, 3, 1, 3, 1, 0,
0, 0, 2, 0, 1, 1, 1, 2, 2, 4,
1, 3, 1, 3, 1, 1, 1, 1, 3, 3,
3, 3, 3, 2, 2, 2, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 3, 2, 3, 3,
1, 1, 1, 1, 1, 1, 5, 6, 4, 5,
3, 1, 1, 5, 4, 2, 0, 1, 5, 0,
1, 1, 3, 1, 3, 2, 1, 1, 1, 1,
1, 1, 3, 3, 5, 1, 1, 3, 2, 5,
4, 4, 3, 2, 1, 0, 0, 6, 1, 1,
1, 4, 5, 1, 4, 5, 0, 1, 3, 1,
1, 1, 2, 3, 3, 2, 1, 2, 2, 2,
3, 7, 3, 3, 1, 2, 2, 1, 2, 3,
1, 1, 1, 5, 7, 0, 6, 4, 11, 13,
4, 3, 3, 7, 8, 3, 1, 2, 2, 3,
1, 3, 0, 1, 0, 1, 1, 2, 5, 6,
1, 3, 3, 0, 2, 1, 5, 7, 0, 1,
3, 3, 6, 5, 6, 4, 5, 5, 2, 1,
1, 10, 1, 3, 4, 3, 3, 3, 3, 6,
6, 5, 8, 2, 3, 3, 7, 7, 0, 1,
4, 2, 4, 1, 2, 2, 1, 1, 0, 0,
0, 2, 2, 2, 2, 2, 1, 2, 2, 3,
4, 2, 3, 1, 3, 3, 1, 1, 1, 3,
1, 1, 4, 5, 1, 1, 3, 3, 1, 4,
1, 1, 1, 2, 2, 2, 1, 3, 3, 4,
4, 1, 3, 1, 5, 1, 1, 1, 3, 3,
3, 3, 3, 3, 1, 3, 5, 5, 5, 0,
0, 1, 3, 1, 1, 3, 3, 3, 3, 2,
3, 3, 0, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 3, 3, 2,
3, 1, 3, 1, 3, 1, 3, 1, 4, 3,
1, 3, 1, 3, 4, 1, 4, 4, 4, 3,
3, 1, 3, 3, 1, 3, 3, 1, 3, 3,
1, 3, 0, 5, 6, 8, 1, 3, 1, 1,
1, 4, 1, 0, 2, 3, 2, 4, 0, 1,
5, 4, 6, 4, 1, 4, 4, 1, 6, 1,
3, 1, 3, 1, 4, 1, 1, 3, 1, 1,
3, 1, 0, 1, 2, 3, 1, 2, 5, 4,
4, 6, 1, 3, 1, 1, 6, 4, 1, 3,
1, 1, 1, 1, 1, 3, 1, 1, 1, 6,
4, 1, 4, 1, 1, 1, 1, 4, 2, 7,
1, 4, 1, 1, 11, 0, 2, 3, 1, 3,
1, 3, 1, 3, 1, 3, 1, 3, 1, 3,
8, 1, 3, 2, 2, 7, 1, 3, 3, 1,
4, 1, 3, 1, 1, 0, 1, 1, 2, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
8, 6, 8, 6, 1, 6, 6, 6, 6, 1,
3, 5, 1, 3, 6, 1, 3, 8, 6, 6,
4, 5, 5, 0, 2, 2, 0, 1, 3, 1,
4, 7, 1, 3, 3, 1, 3, 5, 3, 3,
1, 3, 1, 1, 3, 3, 3, 3, 10, 8,
10, 0, 0, 1, 2, 4, 4, 6, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 6,
4, 4, 3, 9, 1, 1, 3, 1, 5, 5,
9, 0, 1, 1, 3, 3, 3, 3, 3, 6,
3, 3, 3, 3, 7, 5, 1, 1, 3, 4,
1, 1, 3, 1, 1, 3, 3, 2, 3, 4,
4, 5, 5, 1, 2, 4, 4, 4, 0, 1,
2, 7, 6, 3, 3, 7, 5, 1, 3, 1,
4, 2, 3, 3, 4, 6, 3, 2, 3, 1,
1, 4, 5, 3, 6, 2, 4, 2, 1, 3,
3, 0, 1, 3, 2, 2, 2, 2, 9, 5,
1, 3, 2, 2, 2, 9, 4, 1, 3, 1,
1, 2, 0, 7, 1, 4, 1, 3, 1, 1,
1, 16, 0, 3, 3, 3, 3, 6, 9, 5,
1, 3, 5, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2, 2, 4, 3, 4, 5, 1, 1, 1, 1,
1, 1, 1, 1, 1, 5, 2, 2, 2, 2,
2, 5, 1, 1, 1, 4, 4, 4, 4, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 4, 3, 4, 5, 1, 1,
1, 1, 4, 3, 2, 4, 3, 4, 3, 4,
5, 1, 1, 1, 1, 1, 1, 1, 7, 5,
1, 1, 1, 1, 4, 3, 4, 5, 1, 1,
4, 3, 4, 5, 1, 1, 2, 1, 2, 4,
3, 4, 3, 4, 5, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 2, 4, 3, 2,
4, 3, 2, 3, 2, 2, 2, 2, 2, 2,
3, 2, 5, 2, 5, 2, 5, 1, 1, 3,
3, 0, 0, 1, 1, 1, 1, 1, 1, 1,
1, 3, 2, 5, 4, 2, 5, 4, 2, 2,
1, 1, 3, 2, 2, 2, 4, 4, 4, 4,
4, 4, 1, 1, 1, 3, 2, 2, 1, 1,
4, 1, 3, 1, 3, 0, 1, 1, 2, 6,
3, 1, 1, 1, 1, 1, 1, 5, 5, 5,
3, 10, 10, 1, 3, 2, 5, 0, 6, 0,
6, 2, 1, 3, 1, 1, 1, 1, 1, 5,
5, 5, 5, 5, 1, 3, 3, 1, 3, 1,
1, 1, 5, 5, 5, 1, 3, 2, 5, 2,
5, 5, 2, 5, 2, 5, 1, 1, 3, 5,
1, 3, 5, 5, 5, 5, 7, 1, 3, 2,
2, 2, 2, 0
};
#define yyerrok (yyerrstatus = 0)
#define yyclearin (yychar = YYEMPTY)
#define YYEMPTY (-2)
#define YYEOF 0
#define YYACCEPT goto yyacceptlab
#define YYABORT goto yyabortlab
#define YYERROR goto yyerrorlab
#define YYRECOVERING() (!!yyerrstatus)
#define YYBACKUP(Token, Value) \
do \
if (yychar == YYEMPTY) \
{ \
yychar = (Token); \
yylval = (Value); \
YYPOPSTACK (yylen); \
yystate = *yyssp; \
goto yybackup; \
} \
else \
{ \
yyerror (YY_("syntax error: cannot back up")); \
YYERROR; \
} \
while (0)
/* Error token number */
#define YYTERROR 1
#define YYERRCODE 256
/* Enable debugging if requested. */
#if YYDEBUG
# ifndef YYFPRINTF
# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
# define YYFPRINTF fprintf
# endif
# define YYDPRINTF(Args) \
do { \
if (yydebug) \
YYFPRINTF Args; \
} while (0)
/* This macro is provided for backward compatibility. */
#ifndef YY_LOCATION_PRINT
# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
#endif
# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
do { \
if (yydebug) \
{ \
YYFPRINTF (stderr, "%s ", Title); \
yy_symbol_print (stderr, \
Type, Value); \
YYFPRINTF (stderr, "\n"); \
} \
} while (0)
/*----------------------------------------.
| Print this symbol's value on YYOUTPUT. |
`----------------------------------------*/
static void
yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
{
FILE *yyo = yyoutput;
YYUSE (yyo);
if (!yyvaluep)
return;
# ifdef YYPRINT
if (yytype < YYNTOKENS)
YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
# endif
YYUSE (yytype);
}
/*--------------------------------.
| Print this symbol on YYOUTPUT. |
`--------------------------------*/
static void
yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
{
YYFPRINTF (yyoutput, "%s %s (",
yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
yy_symbol_value_print (yyoutput, yytype, yyvaluep);
YYFPRINTF (yyoutput, ")");
}
/*------------------------------------------------------------------.
| yy_stack_print -- Print the state stack from its BOTTOM up to its |
| TOP (included). |
`------------------------------------------------------------------*/
static void
yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
{
YYFPRINTF (stderr, "Stack now");
for (; yybottom <= yytop; yybottom++)
{
int yybot = *yybottom;
YYFPRINTF (stderr, " %d", yybot);
}
YYFPRINTF (stderr, "\n");
}
# define YY_STACK_PRINT(Bottom, Top) \
do { \
if (yydebug) \
yy_stack_print ((Bottom), (Top)); \
} while (0)
/*------------------------------------------------.
| Report that the YYRULE is going to be reduced. |
`------------------------------------------------*/
static void
yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule)
{
unsigned long int yylno = yyrline[yyrule];
int yynrhs = yyr2[yyrule];
int yyi;
YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
yyrule - 1, yylno);
/* The symbols being reduced. */
for (yyi = 0; yyi < yynrhs; yyi++)
{
YYFPRINTF (stderr, " $%d = ", yyi + 1);
yy_symbol_print (stderr,
yystos[yyssp[yyi + 1 - yynrhs]],
&(yyvsp[(yyi + 1) - (yynrhs)])
);
YYFPRINTF (stderr, "\n");
}
}
# define YY_REDUCE_PRINT(Rule) \
do { \
if (yydebug) \
yy_reduce_print (yyssp, yyvsp, Rule); \
} while (0)
/* Nonzero means print parse trace. It is left uninitialized so that
multiple parsers can coexist. */
int yydebug;
#else /* !YYDEBUG */
# define YYDPRINTF(Args)
# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
# define YY_STACK_PRINT(Bottom, Top)
# define YY_REDUCE_PRINT(Rule)
#endif /* !YYDEBUG */
/* YYINITDEPTH -- initial size of the parser's stacks. */
#ifndef YYINITDEPTH
# define YYINITDEPTH 200
#endif
/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
if the built-in stack extension method is used).
Do not make this value too large; the results are undefined if
YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
evaluated with infinite-precision integer arithmetic. */
#ifndef YYMAXDEPTH
# define YYMAXDEPTH 10000
#endif
#if YYERROR_VERBOSE
# ifndef yystrlen
# if defined __GLIBC__ && defined _STRING_H
# define yystrlen strlen
# else
/* Return the length of YYSTR. */
static YYSIZE_T
yystrlen (const char *yystr)
{
YYSIZE_T yylen;
for (yylen = 0; yystr[yylen]; yylen++)
continue;
return yylen;
}
# endif
# endif
# ifndef yystpcpy
# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
# define yystpcpy stpcpy
# else
/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
YYDEST. */
static char *
yystpcpy (char *yydest, const char *yysrc)
{
char *yyd = yydest;
const char *yys = yysrc;
while ((*yyd++ = *yys++) != '\0')
continue;
return yyd - 1;
}
# endif
# endif
# ifndef yytnamerr
/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
quotes and backslashes, so that it's suitable for yyerror. The
heuristic is that double-quoting is unnecessary unless the string
contains an apostrophe, a comma, or backslash (other than
backslash-backslash). YYSTR is taken from yytname. If YYRES is
null, do not copy; instead, return the length of what the result
would have been. */
static YYSIZE_T
yytnamerr (char *yyres, const char *yystr)
{
if (*yystr == '"')
{
YYSIZE_T yyn = 0;
char const *yyp = yystr;
for (;;)
switch (*++yyp)
{
case '\'':
case ',':
goto do_not_strip_quotes;
case '\\':
if (*++yyp != '\\')
goto do_not_strip_quotes;
/* Fall through. */
default:
if (yyres)
yyres[yyn] = *yyp;
yyn++;
break;
case '"':
if (yyres)
yyres[yyn] = '\0';
return yyn;
}
do_not_strip_quotes: ;
}
if (! yyres)
return yystrlen (yystr);
return yystpcpy (yyres, yystr) - yyres;
}
# endif
/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
about the unexpected token YYTOKEN for the state stack whose top is
YYSSP.
Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
not large enough to hold the message. In that case, also set
*YYMSG_ALLOC to the required number of bytes. Return 2 if the
required number of bytes is too large to store. */
static int
yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
yytype_int16 *yyssp, int yytoken)
{
YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
YYSIZE_T yysize = yysize0;
enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
/* Internationalized format string. */
const char *yyformat = YY_NULLPTR;
/* Arguments of yyformat. */
char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
/* Number of reported tokens (one for the "unexpected", one per
"expected"). */
int yycount = 0;
/* There are many possibilities here to consider:
- If this state is a consistent state with a default action, then
the only way this function was invoked is if the default action
is an error action. In that case, don't check for expected
tokens because there are none.
- The only way there can be no lookahead present (in yychar) is if
this state is a consistent state with a default action. Thus,
detecting the absence of a lookahead is sufficient to determine
that there is no unexpected or expected token to report. In that
case, just report a simple "syntax error".
- Don't assume there isn't a lookahead just because this state is a
consistent state with a default action. There might have been a
previous inconsistent state, consistent state with a non-default
action, or user semantic action that manipulated yychar.
- Of course, the expected token list depends on states to have
correct lookahead information, and it depends on the parser not
to perform extra reductions after fetching a lookahead from the
scanner and before detecting a syntax error. Thus, state merging
(from LALR or IELR) and default reductions corrupt the expected
token list. However, the list is correct for canonical LR with
one exception: it will still contain any token that will not be
accepted due to an error action in a later state.
*/
if (yytoken != YYEMPTY)
{
int yyn = yypact[*yyssp];
yyarg[yycount++] = yytname[yytoken];
if (!yypact_value_is_default (yyn))
{
/* Start YYX at -YYN if negative to avoid negative indexes in
YYCHECK. In other words, skip the first -YYN actions for
this state because they are default actions. */
int yyxbegin = yyn < 0 ? -yyn : 0;
/* Stay within bounds of both yycheck and yytname. */
int yychecklim = YYLAST - yyn + 1;
int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
int yyx;
for (yyx = yyxbegin; yyx < yyxend; ++yyx)
if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
&& !yytable_value_is_error (yytable[yyx + yyn]))
{
if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
{
yycount = 1;
yysize = yysize0;
break;
}
yyarg[yycount++] = yytname[yyx];
{
YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
if (! (yysize <= yysize1
&& yysize1 <= YYSTACK_ALLOC_MAXIMUM))
return 2;
yysize = yysize1;
}
}
}
}
switch (yycount)
{
# define YYCASE_(N, S) \
case N: \
yyformat = S; \
break
YYCASE_(0, YY_("syntax error"));
YYCASE_(1, YY_("syntax error, unexpected %s"));
YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
# undef YYCASE_
}
{
YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
return 2;
yysize = yysize1;
}
if (*yymsg_alloc < yysize)
{
*yymsg_alloc = 2 * yysize;
if (! (yysize <= *yymsg_alloc
&& *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
*yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
return 1;
}
/* Avoid sprintf, as that infringes on the user's name space.
Don't have undefined behavior even if the translation
produced a string with the wrong number of "%s"s. */
{
char *yyp = *yymsg;
int yyi = 0;
while ((*yyp = *yyformat) != '\0')
if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
{
yyp += yytnamerr (yyp, yyarg[yyi++]);
yyformat += 2;
}
else
{
yyp++;
yyformat++;
}
}
return 0;
}
#endif /* YYERROR_VERBOSE */
/*-----------------------------------------------.
| Release the memory associated to this symbol. |
`-----------------------------------------------*/
static void
yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
{
YYUSE (yyvaluep);
if (!yymsg)
yymsg = "Deleting";
YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
YYUSE (yytype);
YY_IGNORE_MAYBE_UNINITIALIZED_END
}
/* The lookahead symbol. */
int yychar;
/* The semantic value of the lookahead symbol. */
YYSTYPE yylval;
/* Number of syntax errors so far. */
int yynerrs;
/*----------.
| yyparse. |
`----------*/
int
yyparse (void)
{
int yystate;
/* Number of tokens to shift before error messages enabled. */
int yyerrstatus;
/* The stacks and their tools:
'yyss': related to states.
'yyvs': related to semantic values.
Refer to the stacks through separate pointers, to allow yyoverflow
to reallocate them elsewhere. */
/* The state stack. */
yytype_int16 yyssa[YYINITDEPTH];
yytype_int16 *yyss;
yytype_int16 *yyssp;
/* The semantic value stack. */
YYSTYPE yyvsa[YYINITDEPTH];
YYSTYPE *yyvs;
YYSTYPE *yyvsp;
YYSIZE_T yystacksize;
int yyn;
int yyresult;
/* Lookahead token as an internal (translated) token number. */
int yytoken = 0;
/* The variables used to return semantic value and location from the
action routines. */
YYSTYPE yyval;
#if YYERROR_VERBOSE
/* Buffer for error messages, and its allocated size. */
char yymsgbuf[128];
char *yymsg = yymsgbuf;
YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
#endif
#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
/* The number of symbols on the RHS of the reduced rule.
Keep to zero when no symbol should be popped. */
int yylen = 0;
yyssp = yyss = yyssa;
yyvsp = yyvs = yyvsa;
yystacksize = YYINITDEPTH;
YYDPRINTF ((stderr, "Starting parse\n"));
yystate = 0;
yyerrstatus = 0;
yynerrs = 0;
yychar = YYEMPTY; /* Cause a token to be read. */
goto yysetstate;
/*------------------------------------------------------------.
| yynewstate -- Push a new state, which is found in yystate. |
`------------------------------------------------------------*/
yynewstate:
/* In all cases, when you get here, the value and location stacks
have just been pushed. So pushing a state here evens the stacks. */
yyssp++;
yysetstate:
*yyssp = yystate;
if (yyss + yystacksize - 1 <= yyssp)
{
/* Get the current used size of the three stacks, in elements. */
YYSIZE_T yysize = yyssp - yyss + 1;
#ifdef yyoverflow
{
/* Give user a chance to reallocate the stack. Use copies of
these so that the &'s don't force the real ones into
memory. */
YYSTYPE *yyvs1 = yyvs;
yytype_int16 *yyss1 = yyss;
/* Each stack pointer address is followed by the size of the
data in use in that stack, in bytes. This used to be a
conditional around just the two extra args, but that might
be undefined if yyoverflow is a macro. */
yyoverflow (YY_("memory exhausted"),
&yyss1, yysize * sizeof (*yyssp),
&yyvs1, yysize * sizeof (*yyvsp),
&yystacksize);
yyss = yyss1;
yyvs = yyvs1;
}
#else /* no yyoverflow */
# ifndef YYSTACK_RELOCATE
goto yyexhaustedlab;
# else
/* Extend the stack our own way. */
if (YYMAXDEPTH <= yystacksize)
goto yyexhaustedlab;
yystacksize *= 2;
if (YYMAXDEPTH < yystacksize)
yystacksize = YYMAXDEPTH;
{
yytype_int16 *yyss1 = yyss;
union yyalloc *yyptr =
(union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
if (! yyptr)
goto yyexhaustedlab;
YYSTACK_RELOCATE (yyss_alloc, yyss);
YYSTACK_RELOCATE (yyvs_alloc, yyvs);
# undef YYSTACK_RELOCATE
if (yyss1 != yyssa)
YYSTACK_FREE (yyss1);
}
# endif
#endif /* no yyoverflow */
yyssp = yyss + yysize - 1;
yyvsp = yyvs + yysize - 1;
YYDPRINTF ((stderr, "Stack size increased to %lu\n",
(unsigned long int) yystacksize));
if (yyss + yystacksize - 1 <= yyssp)
YYABORT;
}
YYDPRINTF ((stderr, "Entering state %d\n", yystate));
if (yystate == YYFINAL)
YYACCEPT;
goto yybackup;
/*-----------.
| yybackup. |
`-----------*/
yybackup:
/* Do appropriate processing given the current state. Read a
lookahead token if we need one and don't already have one. */
/* First try to decide what to do without reference to lookahead token. */
yyn = yypact[yystate];
if (yypact_value_is_default (yyn))
goto yydefault;
/* Not known => get a lookahead token if don't already have one. */
/* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
if (yychar == YYEMPTY)
{
YYDPRINTF ((stderr, "Reading a token: "));
yychar = yylex ();
}
if (yychar <= YYEOF)
{
yychar = yytoken = YYEOF;
YYDPRINTF ((stderr, "Now at end of input.\n"));
}
else
{
yytoken = YYTRANSLATE (yychar);
YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
}
/* If the proper action on seeing token YYTOKEN is to reduce or to
detect an error, take that action. */
yyn += yytoken;
if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
goto yydefault;
yyn = yytable[yyn];
if (yyn <= 0)
{
if (yytable_value_is_error (yyn))
goto yyerrlab;
yyn = -yyn;
goto yyreduce;
}
/* Count tokens shifted since error; after three, turn off error
status. */
if (yyerrstatus)
yyerrstatus--;
/* Shift the lookahead token. */
YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
/* Discard the shifted token. */
yychar = YYEMPTY;
yystate = yyn;
YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
*++yyvsp = yylval;
YY_IGNORE_MAYBE_UNINITIALIZED_END
goto yynewstate;
/*-----------------------------------------------------------.
| yydefault -- do the default action for the current state. |
`-----------------------------------------------------------*/
yydefault:
yyn = yydefact[yystate];
if (yyn == 0)
goto yyerrlab;
goto yyreduce;
/*-----------------------------.
| yyreduce -- Do a reduction. |
`-----------------------------*/
yyreduce:
/* yyn is the number of a rule to reduce with. */
yylen = yyr2[yyn];
/* If YYLEN is nonzero, implement the default value of the action:
'$$ = $1'.
Otherwise, the following line sets YYVAL to garbage.
This behavior is undocumented and Bison
users should not rely upon it. Assigning to YYVAL
unconditionally makes the parser a bit smaller, and it avoids a
GCC warning that YYVAL may be used uninitialized. */
yyval = yyvsp[1-yylen];
YY_REDUCE_PRINT (yyn);
switch (yyn)
{
case 2:
#line 797 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = BFNULL; }
#line 4460 "gram1.tab.c" /* yacc.c:1646 */
break;
case 3:
#line 799 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = set_stat_list((yyvsp[-2].bf_node),(yyvsp[-1].bf_node)); }
#line 4466 "gram1.tab.c" /* yacc.c:1646 */
break;
case 4:
#line 803 "gram1.y" /* yacc.c:1646 */
{ lastwasbranch = NO; (yyval.bf_node) = BFNULL; }
#line 4472 "gram1.tab.c" /* yacc.c:1646 */
break;
case 5:
#line 805 "gram1.y" /* yacc.c:1646 */
{
if ((yyvsp[-1].bf_node) != BFNULL)
{
(yyvsp[-1].bf_node)->label = (yyvsp[-2].label);
(yyval.bf_node) = (yyvsp[-1].bf_node);
if (is_openmp_stmt) { /*OMP*/
is_openmp_stmt = 0;
if((yyvsp[-1].bf_node)) { /*OMP*/
if ((yyvsp[-1].bf_node)->decl_specs != -BIT_OPENMP) (yyvsp[-1].bf_node)->decl_specs = BIT_OPENMP; /*OMP*/
} /*OMP*/
} /*OMP*/
}
}
#line 4490 "gram1.tab.c" /* yacc.c:1646 */
break;
case 6:
#line 819 "gram1.y" /* yacc.c:1646 */
{ PTR_BFND p;
if(lastwasbranch && ! thislabel)
/*if (warn_all)
warn("statement cannot be reached", 36);*/
lastwasbranch = thiswasbranch;
thiswasbranch = NO;
if((yyvsp[-1].bf_node)) (yyvsp[-1].bf_node)->label = (yyvsp[-2].label);
if((yyvsp[-2].label) && (yyvsp[-1].bf_node)) (yyvsp[-2].label)->statbody = (yyvsp[-1].bf_node); /*8.11.06 podd*/
if((yyvsp[-2].label)) {
/*$1->statbody = $2;*/ /*8.11.06 podd*/
if((yyvsp[-2].label)->labtype == LABFORMAT)
err("label already that of a format",39);
else
(yyvsp[-2].label)->labtype = LABEXEC;
}
if (is_openmp_stmt) { /*OMP*/
is_openmp_stmt = 0;
if((yyvsp[-1].bf_node)) { /*OMP*/
if ((yyvsp[-1].bf_node)->decl_specs != -BIT_OPENMP) (yyvsp[-1].bf_node)->decl_specs = BIT_OPENMP; /*OMP*/
} /*OMP*/
} /*OMP*/
for (p = pred_bfnd; (yyvsp[-2].label) &&
((p->variant == FOR_NODE)||(p->variant == WHILE_NODE)) &&
(p->entry.for_node.doend) &&
(p->entry.for_node.doend->stateno == (yyvsp[-2].label)->stateno);
p = p->control_parent)
++end_group;
(yyval.bf_node) = (yyvsp[-1].bf_node);
}
#line 4525 "gram1.tab.c" /* yacc.c:1646 */
break;
case 7:
#line 850 "gram1.y" /* yacc.c:1646 */
{ /* PTR_LLND p; */
doinclude( (yyvsp[0].charp) );
/* p = make_llnd(fi, STRING_VAL, LLNULL, LLNULL, SMNULL);
p->entry.string_val = $3;
p->type = global_string;
$$ = get_bfnd(fi, INCLUDE_STAT, SMNULL, p, LLNULL); */
(yyval.bf_node) = BFNULL;
}
#line 4538 "gram1.tab.c" /* yacc.c:1646 */
break;
case 8:
#line 859 "gram1.y" /* yacc.c:1646 */
{
err("Unclassifiable statement", 10);
flline();
(yyval.bf_node) = BFNULL;
}
#line 4548 "gram1.tab.c" /* yacc.c:1646 */
break;
case 9:
#line 865 "gram1.y" /* yacc.c:1646 */
{ PTR_CMNT p;
PTR_BFND bif;
if (last_bfnd && last_bfnd->control_parent &&((last_bfnd->control_parent->variant == LOGIF_NODE)
||(last_bfnd->control_parent->variant == FORALL_STAT)))
bif = last_bfnd->control_parent;
else
bif = last_bfnd;
p=bif->entry.Template.cmnt_ptr;
if(p)
p->string = StringConcatenation(p->string,commentbuf);
else
{
p = make_comment(fi,commentbuf, FULL);
bif->entry.Template.cmnt_ptr = p;
}
(yyval.bf_node) = BFNULL;
}
#line 4571 "gram1.tab.c" /* yacc.c:1646 */
break;
case 10:
#line 885 "gram1.y" /* yacc.c:1646 */
{
flline(); needkwd = NO; inioctl = NO;
/*!!!*/
opt_kwd_ = NO; intonly = NO; opt_kwd_hedr = NO; opt_kwd_r = NO; as_op_kwd_= NO; optcorner = NO;
yyerrok; yyclearin; (yyval.bf_node) = BFNULL;
}
#line 4582 "gram1.tab.c" /* yacc.c:1646 */
break;
case 11:
#line 894 "gram1.y" /* yacc.c:1646 */
{
if(yystno)
{
(yyval.label) = thislabel = make_label_node(fi,yystno);
thislabel->scope = cur_scope();
if (thislabel->labdefined && (thislabel->scope == cur_scope()))
errstr("Label %s already defined",convic(thislabel->stateno),40);
else
thislabel->labdefined = YES;
}
else
(yyval.label) = thislabel = LBNULL;
}
#line 4600 "gram1.tab.c" /* yacc.c:1646 */
break;
case 12:
#line 910 "gram1.y" /* yacc.c:1646 */
{ PTR_BFND p;
if (pred_bfnd != global_bfnd)
err("Misplaced PROGRAM statement", 33);
p = get_bfnd(fi,PROG_HEDR, (yyvsp[0].symbol), LLNULL, LLNULL, LLNULL);
(yyvsp[0].symbol)->entry.prog_decl.prog_hedr=p;
set_blobs(p, global_bfnd, NEW_GROUP1);
add_scope_level(p, NO);
position = IN_PROC;
}
#line 4615 "gram1.tab.c" /* yacc.c:1646 */
break;
case 13:
#line 922 "gram1.y" /* yacc.c:1646 */
{ PTR_BFND q = BFNULL;
(yyvsp[0].symbol)->variant = PROCEDURE_NAME;
(yyvsp[0].symbol)->decl = YES; /* variable declaration has been seen. */
q = get_bfnd(fi,BLOCK_DATA, (yyvsp[0].symbol), LLNULL, LLNULL, LLNULL);
set_blobs(q, global_bfnd, NEW_GROUP1);
add_scope_level(q, NO);
}
#line 4628 "gram1.tab.c" /* yacc.c:1646 */
break;
case 14:
#line 932 "gram1.y" /* yacc.c:1646 */
{
install_param_list((yyvsp[-1].symbol), (yyvsp[0].symbol), LLNULL, PROCEDURE_NAME);
/* if there is only a control end the control parent is not set */
}
#line 4638 "gram1.tab.c" /* yacc.c:1646 */
break;
case 15:
#line 939 "gram1.y" /* yacc.c:1646 */
{ install_param_list((yyvsp[-1].symbol), (yyvsp[0].symbol), LLNULL, PROCEDURE_NAME);
if((yyvsp[-4].ll_node)->variant == RECURSIVE_OP)
(yyvsp[-1].symbol)->attr = (yyvsp[-1].symbol)->attr | RECURSIVE_BIT;
pred_bfnd->entry.Template.ll_ptr3 = (yyvsp[-4].ll_node);
}
#line 4648 "gram1.tab.c" /* yacc.c:1646 */
break;
case 16:
#line 945 "gram1.y" /* yacc.c:1646 */
{
install_param_list((yyvsp[-2].symbol), (yyvsp[-1].symbol), (yyvsp[0].ll_node), FUNCTION_NAME);
pred_bfnd->entry.Template.ll_ptr1 = (yyvsp[0].ll_node);
}
#line 4657 "gram1.tab.c" /* yacc.c:1646 */
break;
case 17:
#line 950 "gram1.y" /* yacc.c:1646 */
{
install_param_list((yyvsp[-2].symbol), (yyvsp[-1].symbol), (yyvsp[0].ll_node), FUNCTION_NAME);
pred_bfnd->entry.Template.ll_ptr1 = (yyvsp[0].ll_node);
}
#line 4666 "gram1.tab.c" /* yacc.c:1646 */
break;
case 18:
#line 955 "gram1.y" /* yacc.c:1646 */
{PTR_BFND p, bif;
PTR_SYMB q = SMNULL;
PTR_LLND l = LLNULL;
if(parstate==OUTSIDE || procclass==CLMAIN || procclass==CLBLOCK)
err("Misplaced ENTRY statement", 35);
bif = cur_scope();
if (bif->variant == FUNC_HEDR) {
q = make_function((yyvsp[-2].hash_entry), bif->entry.Template.symbol->type, LOCAL);
l = construct_entry_list(q, (yyvsp[-1].symbol), FUNCTION_NAME);
}
else if ((bif->variant == PROC_HEDR) ||
(bif->variant == PROS_HEDR) || /* added for FORTRAN M */
(bif->variant == PROG_HEDR)) {
q = make_procedure((yyvsp[-2].hash_entry),LOCAL);
l = construct_entry_list(q, (yyvsp[-1].symbol), PROCEDURE_NAME);
}
p = get_bfnd(fi,ENTRY_STAT, q, l, (yyvsp[0].ll_node), LLNULL);
set_blobs(p, pred_bfnd, SAME_GROUP);
q->decl = YES; /*4.02.03*/
q->entry.proc_decl.proc_hedr = p; /*5.02.03*/
}
#line 4694 "gram1.tab.c" /* yacc.c:1646 */
break;
case 19:
#line 979 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB s;
PTR_BFND p;
/*
s = make_global_entity($3, MODULE_NAME, global_default, NO);
s->decl = YES;
p = get_bfnd(fi, MODULE_STMT, s, LLNULL, LLNULL, LLNULL);
s->entry.Template.func_hedr = p;
set_blobs(p, pred_bfnd, NEW_GROUP1);
add_scope_level(p, NO);
*/
/*position = IN_MODULE;*/
s = make_module((yyvsp[0].hash_entry));
s->decl = YES; /* variable declaration has been seen. */
if (pred_bfnd != global_bfnd)
err("Misplaced MODULE statement", 33);
p = get_bfnd(fi, MODULE_STMT, s, LLNULL, LLNULL, LLNULL);
s->entry.Template.func_hedr = p; /* !!!????*/
set_blobs(p, global_bfnd, NEW_GROUP1);
add_scope_level(p, NO);
position = IN_MODULE; /*IN_PROC*/
privateall = 0;
}
#line 4723 "gram1.tab.c" /* yacc.c:1646 */
break;
case 20:
#line 1005 "gram1.y" /* yacc.c:1646 */
{ newprog();
if (position == IN_OUTSIDE)
position = IN_PROC;
else if (position != IN_INTERNAL_PROC){
if(!is_interface_stat(pred_bfnd))
position--;
}
else {
if(!is_interface_stat(pred_bfnd))
err("Internal procedures can not contain procedures",304);
}
}
#line 4740 "gram1.tab.c" /* yacc.c:1646 */
break;
case 21:
#line 1020 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi, RECURSIVE_OP, LLNULL, LLNULL, SMNULL); }
#line 4746 "gram1.tab.c" /* yacc.c:1646 */
break;
case 22:
#line 1022 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi, PURE_OP, LLNULL, LLNULL, SMNULL); }
#line 4752 "gram1.tab.c" /* yacc.c:1646 */
break;
case 23:
#line 1024 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi, ELEMENTAL_OP, LLNULL, LLNULL, SMNULL); }
#line 4758 "gram1.tab.c" /* yacc.c:1646 */
break;
case 24:
#line 1028 "gram1.y" /* yacc.c:1646 */
{ PTR_BFND p;
(yyval.symbol) = make_procedure((yyvsp[0].hash_entry), LOCAL);
(yyval.symbol)->decl = YES; /* variable declaration has been seen. */
/* if (pred_bfnd != global_bfnd)
{
err("Misplaced SUBROUTINE statement", 34);
}
*/
p = get_bfnd(fi,PROC_HEDR, (yyval.symbol), LLNULL, LLNULL, LLNULL);
(yyval.symbol)->entry.proc_decl.proc_hedr = p;
set_blobs(p, pred_bfnd, NEW_GROUP1);
add_scope_level(p, NO);
}
#line 4777 "gram1.tab.c" /* yacc.c:1646 */
break;
case 25:
#line 1045 "gram1.y" /* yacc.c:1646 */
{ PTR_BFND p;
(yyval.symbol) = make_function((yyvsp[0].hash_entry), TYNULL, LOCAL);
(yyval.symbol)->decl = YES; /* variable declaration has been seen. */
/* if (pred_bfnd != global_bfnd)
err("Misplaced FUNCTION statement", 34); */
p = get_bfnd(fi,FUNC_HEDR, (yyval.symbol), LLNULL, LLNULL, LLNULL);
(yyval.symbol)->entry.func_decl.func_hedr = p;
set_blobs(p, pred_bfnd, NEW_GROUP1);
add_scope_level(p, NO);
}
#line 4793 "gram1.tab.c" /* yacc.c:1646 */
break;
case 26:
#line 1059 "gram1.y" /* yacc.c:1646 */
{ PTR_BFND p;
PTR_LLND l;
(yyval.symbol) = make_function((yyvsp[0].hash_entry), (yyvsp[-3].data_type), LOCAL);
(yyval.symbol)->decl = YES; /* variable declaration has been seen. */
l = make_llnd(fi, TYPE_OP, LLNULL, LLNULL, SMNULL);
l->type = (yyvsp[-3].data_type);
p = get_bfnd(fi,FUNC_HEDR, (yyval.symbol), LLNULL, l, LLNULL);
(yyval.symbol)->entry.func_decl.func_hedr = p;
/* if (pred_bfnd != global_bfnd)
err("Misplaced FUNCTION statement", 34);*/
set_blobs(p, pred_bfnd, NEW_GROUP1);
add_scope_level(p, NO);
/*
$$ = make_function($4, $1, LOCAL);
$$->decl = YES;
p = get_bfnd(fi,FUNC_HEDR, $$, LLNULL, LLNULL, LLNULL);
if (pred_bfnd != global_bfnd)
errstr("cftn.gram: misplaced SUBROUTINE statement.");
set_blobs(p, pred_bfnd, NEW_GROUP1);
add_scope_level(p, NO);
*/
}
#line 4821 "gram1.tab.c" /* yacc.c:1646 */
break;
case 27:
#line 1083 "gram1.y" /* yacc.c:1646 */
{ PTR_BFND p;
PTR_LLND l;
(yyval.symbol) = make_function((yyvsp[0].hash_entry), (yyvsp[-4].data_type), LOCAL);
(yyval.symbol)->decl = YES; /* variable declaration has been seen. */
if((yyvsp[-3].ll_node)->variant == RECURSIVE_OP)
(yyval.symbol)->attr = (yyval.symbol)->attr | RECURSIVE_BIT;
l = make_llnd(fi, TYPE_OP, LLNULL, LLNULL, SMNULL);
l->type = (yyvsp[-4].data_type);
/* if (pred_bfnd != global_bfnd)
err("Misplaced FUNCTION statement", 34);*/
p = get_bfnd(fi,FUNC_HEDR, (yyval.symbol), LLNULL, l, (yyvsp[-3].ll_node));
(yyval.symbol)->entry.func_decl.func_hedr = p;
set_blobs(p, pred_bfnd, NEW_GROUP1);
add_scope_level(p, NO);
}
#line 4841 "gram1.tab.c" /* yacc.c:1646 */
break;
case 28:
#line 1099 "gram1.y" /* yacc.c:1646 */
{ PTR_BFND p;
(yyval.symbol) = make_function((yyvsp[0].hash_entry), TYNULL, LOCAL);
(yyval.symbol)->decl = YES; /* variable declaration has been seen. */
if((yyvsp[-3].ll_node)->variant == RECURSIVE_OP)
(yyval.symbol)->attr = (yyval.symbol)->attr | RECURSIVE_BIT;
/*if (pred_bfnd != global_bfnd)
err("Misplaced FUNCTION statement",34);*/
p = get_bfnd(fi,FUNC_HEDR, (yyval.symbol), LLNULL, LLNULL, (yyvsp[-3].ll_node));
(yyval.symbol)->entry.func_decl.func_hedr = p;
set_blobs(p, pred_bfnd, NEW_GROUP1);
add_scope_level(p, NO);
}
#line 4859 "gram1.tab.c" /* yacc.c:1646 */
break;
case 29:
#line 1113 "gram1.y" /* yacc.c:1646 */
{ PTR_BFND p;
PTR_LLND l;
(yyval.symbol) = make_function((yyvsp[0].hash_entry), (yyvsp[-3].data_type), LOCAL);
(yyval.symbol)->decl = YES; /* variable declaration has been seen. */
if((yyvsp[-4].ll_node)->variant == RECURSIVE_OP)
(yyval.symbol)->attr = (yyval.symbol)->attr | RECURSIVE_BIT;
l = make_llnd(fi, TYPE_OP, LLNULL, LLNULL, SMNULL);
l->type = (yyvsp[-3].data_type);
/* if (pred_bfnd != global_bfnd)
err("Misplaced FUNCTION statement",34);*/
p = get_bfnd(fi,FUNC_HEDR, (yyval.symbol), LLNULL, l, (yyvsp[-4].ll_node));
(yyval.symbol)->entry.func_decl.func_hedr = p;
set_blobs(p, pred_bfnd, NEW_GROUP1);
add_scope_level(p, NO);
}
#line 4879 "gram1.tab.c" /* yacc.c:1646 */
break;
case 30:
#line 1131 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = LLNULL; }
#line 4885 "gram1.tab.c" /* yacc.c:1646 */
break;
case 31:
#line 1133 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB s;
s = make_scalar((yyvsp[-1].hash_entry), TYNULL, LOCAL);
(yyval.ll_node) = make_llnd(fi, VAR_REF, LLNULL, LLNULL, s);
}
#line 4894 "gram1.tab.c" /* yacc.c:1646 */
break;
case 32:
#line 1140 "gram1.y" /* yacc.c:1646 */
{ (yyval.hash_entry) = look_up_sym(yytext); }
#line 4900 "gram1.tab.c" /* yacc.c:1646 */
break;
case 33:
#line 1143 "gram1.y" /* yacc.c:1646 */
{ (yyval.symbol) = make_program(look_up_sym("_MAIN")); }
#line 4906 "gram1.tab.c" /* yacc.c:1646 */
break;
case 34:
#line 1145 "gram1.y" /* yacc.c:1646 */
{
(yyval.symbol) = make_program((yyvsp[0].hash_entry));
(yyval.symbol)->decl = YES; /* variable declaration has been seen. */
}
#line 4915 "gram1.tab.c" /* yacc.c:1646 */
break;
case 35:
#line 1151 "gram1.y" /* yacc.c:1646 */
{ (yyval.symbol) = make_program(look_up_sym("_BLOCK")); }
#line 4921 "gram1.tab.c" /* yacc.c:1646 */
break;
case 36:
#line 1153 "gram1.y" /* yacc.c:1646 */
{
(yyval.symbol) = make_program((yyvsp[0].hash_entry));
(yyval.symbol)->decl = YES; /* variable declaration has been seen. */
}
#line 4930 "gram1.tab.c" /* yacc.c:1646 */
break;
case 37:
#line 1160 "gram1.y" /* yacc.c:1646 */
{ (yyval.symbol) = SMNULL; }
#line 4936 "gram1.tab.c" /* yacc.c:1646 */
break;
case 38:
#line 1162 "gram1.y" /* yacc.c:1646 */
{ (yyval.symbol) = SMNULL; }
#line 4942 "gram1.tab.c" /* yacc.c:1646 */
break;
case 39:
#line 1164 "gram1.y" /* yacc.c:1646 */
{ (yyval.symbol) = (yyvsp[-1].symbol); }
#line 4948 "gram1.tab.c" /* yacc.c:1646 */
break;
case 41:
#line 1169 "gram1.y" /* yacc.c:1646 */
{ (yyval.symbol) = set_id_list((yyvsp[-2].symbol), (yyvsp[0].symbol)); }
#line 4954 "gram1.tab.c" /* yacc.c:1646 */
break;
case 42:
#line 1173 "gram1.y" /* yacc.c:1646 */
{
(yyval.symbol) = make_scalar((yyvsp[0].hash_entry), TYNULL, IO);
}
#line 4962 "gram1.tab.c" /* yacc.c:1646 */
break;
case 43:
#line 1177 "gram1.y" /* yacc.c:1646 */
{ (yyval.symbol) = make_scalar(look_up_sym("*"), TYNULL, IO); }
#line 4968 "gram1.tab.c" /* yacc.c:1646 */
break;
case 44:
#line 1183 "gram1.y" /* yacc.c:1646 */
{ char *s;
s = copyn(yyleng+1, yytext);
s[yyleng] = '\0';
(yyval.charp) = s;
}
#line 4979 "gram1.tab.c" /* yacc.c:1646 */
break;
case 45:
#line 1192 "gram1.y" /* yacc.c:1646 */
{ needkwd = 1; }
#line 4985 "gram1.tab.c" /* yacc.c:1646 */
break;
case 46:
#line 1196 "gram1.y" /* yacc.c:1646 */
{ needkwd = NO; }
#line 4991 "gram1.tab.c" /* yacc.c:1646 */
break;
case 47:
#line 1201 "gram1.y" /* yacc.c:1646 */
{ colon_flag = YES; }
#line 4997 "gram1.tab.c" /* yacc.c:1646 */
break;
case 62:
#line 1223 "gram1.y" /* yacc.c:1646 */
{
saveall = YES;
(yyval.bf_node) = get_bfnd(fi,SAVE_DECL, SMNULL, LLNULL, LLNULL, LLNULL);
}
#line 5006 "gram1.tab.c" /* yacc.c:1646 */
break;
case 63:
#line 1228 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = get_bfnd(fi,SAVE_DECL, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL);
}
#line 5014 "gram1.tab.c" /* yacc.c:1646 */
break;
case 64:
#line 1233 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND p;
p = make_llnd(fi,STMT_STR, LLNULL, LLNULL, SMNULL);
p->entry.string_val = copys(stmtbuf);
(yyval.bf_node) = get_bfnd(fi,FORMAT_STAT, SMNULL, p, LLNULL, LLNULL);
}
#line 5025 "gram1.tab.c" /* yacc.c:1646 */
break;
case 65:
#line 1240 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,PARAM_DECL, SMNULL, (yyvsp[-1].ll_node), LLNULL, LLNULL); }
#line 5031 "gram1.tab.c" /* yacc.c:1646 */
break;
case 78:
#line 1256 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi, INTERFACE_STMT, SMNULL, LLNULL, LLNULL, LLNULL);
add_scope_level((yyval.bf_node), NO);
}
#line 5039 "gram1.tab.c" /* yacc.c:1646 */
break;
case 79:
#line 1260 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB s;
s = make_procedure((yyvsp[0].hash_entry), LOCAL);
s->variant = INTERFACE_NAME;
(yyval.bf_node) = get_bfnd(fi, INTERFACE_STMT, s, LLNULL, LLNULL, LLNULL);
add_scope_level((yyval.bf_node), NO);
}
#line 5051 "gram1.tab.c" /* yacc.c:1646 */
break;
case 80:
#line 1268 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB s;
s = make_function((yyvsp[-1].hash_entry), global_default, LOCAL);
s->variant = INTERFACE_NAME;
(yyval.bf_node) = get_bfnd(fi, INTERFACE_OPERATOR, s, LLNULL, LLNULL, LLNULL);
add_scope_level((yyval.bf_node), NO);
}
#line 5063 "gram1.tab.c" /* yacc.c:1646 */
break;
case 81:
#line 1276 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB s;
s = make_procedure(look_up_sym("="), LOCAL);
s->variant = INTERFACE_NAME;
(yyval.bf_node) = get_bfnd(fi, INTERFACE_ASSIGNMENT, s, LLNULL, LLNULL, LLNULL);
add_scope_level((yyval.bf_node), NO);
}
#line 5076 "gram1.tab.c" /* yacc.c:1646 */
break;
case 82:
#line 1285 "gram1.y" /* yacc.c:1646 */
{ parstate = INDCL;
(yyval.bf_node) = get_bfnd(fi, CONTROL_END, SMNULL, LLNULL, LLNULL, LLNULL);
/*process_interface($$);*/ /*podd 01.02.03*/
delete_beyond_scope_level(pred_bfnd);
}
#line 5086 "gram1.tab.c" /* yacc.c:1646 */
break;
case 83:
#line 1293 "gram1.y" /* yacc.c:1646 */
{ (yyval.hash_entry) = look_up_sym(yytext); }
#line 5092 "gram1.tab.c" /* yacc.c:1646 */
break;
case 84:
#line 1297 "gram1.y" /* yacc.c:1646 */
{ (yyval.hash_entry) = (yyvsp[0].hash_entry); }
#line 5098 "gram1.tab.c" /* yacc.c:1646 */
break;
case 85:
#line 1299 "gram1.y" /* yacc.c:1646 */
{ (yyval.hash_entry) = (yyvsp[0].hash_entry); }
#line 5104 "gram1.tab.c" /* yacc.c:1646 */
break;
case 86:
#line 1303 "gram1.y" /* yacc.c:1646 */
{ (yyval.hash_entry) = look_up_op(PLUS); }
#line 5110 "gram1.tab.c" /* yacc.c:1646 */
break;
case 87:
#line 1305 "gram1.y" /* yacc.c:1646 */
{ (yyval.hash_entry) = look_up_op(MINUS); }
#line 5116 "gram1.tab.c" /* yacc.c:1646 */
break;
case 88:
#line 1307 "gram1.y" /* yacc.c:1646 */
{ (yyval.hash_entry) = look_up_op(ASTER); }
#line 5122 "gram1.tab.c" /* yacc.c:1646 */
break;
case 89:
#line 1309 "gram1.y" /* yacc.c:1646 */
{ (yyval.hash_entry) = look_up_op(DASTER); }
#line 5128 "gram1.tab.c" /* yacc.c:1646 */
break;
case 90:
#line 1311 "gram1.y" /* yacc.c:1646 */
{ (yyval.hash_entry) = look_up_op(SLASH); }
#line 5134 "gram1.tab.c" /* yacc.c:1646 */
break;
case 91:
#line 1313 "gram1.y" /* yacc.c:1646 */
{ (yyval.hash_entry) = look_up_op(DSLASH); }
#line 5140 "gram1.tab.c" /* yacc.c:1646 */
break;
case 92:
#line 1315 "gram1.y" /* yacc.c:1646 */
{ (yyval.hash_entry) = look_up_op(AND); }
#line 5146 "gram1.tab.c" /* yacc.c:1646 */
break;
case 93:
#line 1317 "gram1.y" /* yacc.c:1646 */
{ (yyval.hash_entry) = look_up_op(OR); }
#line 5152 "gram1.tab.c" /* yacc.c:1646 */
break;
case 94:
#line 1319 "gram1.y" /* yacc.c:1646 */
{ (yyval.hash_entry) = look_up_op(XOR); }
#line 5158 "gram1.tab.c" /* yacc.c:1646 */
break;
case 95:
#line 1321 "gram1.y" /* yacc.c:1646 */
{ (yyval.hash_entry) = look_up_op(NOT); }
#line 5164 "gram1.tab.c" /* yacc.c:1646 */
break;
case 96:
#line 1323 "gram1.y" /* yacc.c:1646 */
{ (yyval.hash_entry) = look_up_op(EQ); }
#line 5170 "gram1.tab.c" /* yacc.c:1646 */
break;
case 97:
#line 1325 "gram1.y" /* yacc.c:1646 */
{ (yyval.hash_entry) = look_up_op(NE); }
#line 5176 "gram1.tab.c" /* yacc.c:1646 */
break;
case 98:
#line 1327 "gram1.y" /* yacc.c:1646 */
{ (yyval.hash_entry) = look_up_op(GT); }
#line 5182 "gram1.tab.c" /* yacc.c:1646 */
break;
case 99:
#line 1329 "gram1.y" /* yacc.c:1646 */
{ (yyval.hash_entry) = look_up_op(GE); }
#line 5188 "gram1.tab.c" /* yacc.c:1646 */
break;
case 100:
#line 1331 "gram1.y" /* yacc.c:1646 */
{ (yyval.hash_entry) = look_up_op(LT); }
#line 5194 "gram1.tab.c" /* yacc.c:1646 */
break;
case 101:
#line 1333 "gram1.y" /* yacc.c:1646 */
{ (yyval.hash_entry) = look_up_op(LE); }
#line 5200 "gram1.tab.c" /* yacc.c:1646 */
break;
case 102:
#line 1335 "gram1.y" /* yacc.c:1646 */
{ (yyval.hash_entry) = look_up_op(NEQV); }
#line 5206 "gram1.tab.c" /* yacc.c:1646 */
break;
case 103:
#line 1337 "gram1.y" /* yacc.c:1646 */
{ (yyval.hash_entry) = look_up_op(EQV); }
#line 5212 "gram1.tab.c" /* yacc.c:1646 */
break;
case 104:
#line 1342 "gram1.y" /* yacc.c:1646 */
{
PTR_SYMB s;
type_var = s = make_derived_type((yyvsp[0].hash_entry), TYNULL, LOCAL);
(yyval.bf_node) = get_bfnd(fi, STRUCT_DECL, s, LLNULL, LLNULL, LLNULL);
add_scope_level((yyval.bf_node), NO);
}
#line 5224 "gram1.tab.c" /* yacc.c:1646 */
break;
case 105:
#line 1351 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB s;
type_var = s = make_derived_type((yyvsp[0].hash_entry), TYNULL, LOCAL);
s->attr = s->attr | type_opt;
(yyval.bf_node) = get_bfnd(fi, STRUCT_DECL, s, (yyvsp[-2].ll_node), LLNULL, LLNULL);
add_scope_level((yyval.bf_node), NO);
}
#line 5236 "gram1.tab.c" /* yacc.c:1646 */
break;
case 106:
#line 1361 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = get_bfnd(fi, CONTROL_END, SMNULL, LLNULL, LLNULL, LLNULL);
if (type_var != SMNULL)
process_type(type_var, (yyval.bf_node));
type_var = SMNULL;
delete_beyond_scope_level(pred_bfnd);
}
#line 5248 "gram1.tab.c" /* yacc.c:1646 */
break;
case 107:
#line 1369 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = get_bfnd(fi, CONTROL_END, SMNULL, LLNULL, LLNULL, LLNULL);
if (type_var != SMNULL)
process_type(type_var, (yyval.bf_node));
type_var = SMNULL;
delete_beyond_scope_level(pred_bfnd);
}
#line 5260 "gram1.tab.c" /* yacc.c:1646 */
break;
case 108:
#line 1379 "gram1.y" /* yacc.c:1646 */
{
PTR_LLND q, r, l;
/* PTR_SYMB s;*/
PTR_TYPE t;
int type_opts;
vartype = (yyvsp[-6].data_type);
if((yyvsp[-1].ll_node) && vartype->variant != T_STRING)
errstr("Non character entity %s has length specification",(yyvsp[-4].hash_entry)->ident,41);
t = make_type_node(vartype, (yyvsp[-1].ll_node));
type_opts = type_options;
if ((yyvsp[-2].ll_node)) type_opts = type_opts | DIMENSION_BIT;
if ((yyvsp[-2].ll_node))
q = deal_with_options((yyvsp[-4].hash_entry), t, type_opts, (yyvsp[-2].ll_node), ndim, (yyvsp[0].ll_node), (yyvsp[-2].ll_node));
else q = deal_with_options((yyvsp[-4].hash_entry), t, type_opts, attr_dims, attr_ndim, (yyvsp[0].ll_node), (yyvsp[-2].ll_node));
r = make_llnd(fi, EXPR_LIST, q, LLNULL, SMNULL);
l = make_llnd(fi, TYPE_OP, LLNULL, LLNULL, SMNULL);
l->type = vartype;
(yyval.bf_node) = get_bfnd(fi,VAR_DECL, SMNULL, r, l, (yyvsp[-5].ll_node));
}
#line 5285 "gram1.tab.c" /* yacc.c:1646 */
break;
case 109:
#line 1400 "gram1.y" /* yacc.c:1646 */
{
PTR_LLND q, r;
/* PTR_SYMB s;*/
PTR_TYPE t;
int type_opts;
if((yyvsp[-1].ll_node) && vartype->variant != T_STRING)
errstr("Non character entity %s has length specification",(yyvsp[-3].hash_entry)->ident,41);
t = make_type_node(vartype, (yyvsp[-1].ll_node));
type_opts = type_options;
if ((yyvsp[-2].ll_node)) type_opts = type_opts | DIMENSION_BIT;
if ((yyvsp[-2].ll_node))
q = deal_with_options((yyvsp[-3].hash_entry), t, type_opts, (yyvsp[-2].ll_node), ndim, (yyvsp[0].ll_node), (yyvsp[-2].ll_node));
else q = deal_with_options((yyvsp[-3].hash_entry), t, type_opts, attr_dims, attr_ndim, (yyvsp[0].ll_node), (yyvsp[-2].ll_node));
r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
add_to_lowLevelList(r, (yyvsp[-5].bf_node)->entry.Template.ll_ptr1);
}
#line 5306 "gram1.tab.c" /* yacc.c:1646 */
break;
case 110:
#line 1419 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = LLNULL; }
#line 5312 "gram1.tab.c" /* yacc.c:1646 */
break;
case 111:
#line 1421 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = LLNULL; }
#line 5318 "gram1.tab.c" /* yacc.c:1646 */
break;
case 112:
#line 1423 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[-2].ll_node); }
#line 5324 "gram1.tab.c" /* yacc.c:1646 */
break;
case 113:
#line 1427 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); }
#line 5330 "gram1.tab.c" /* yacc.c:1646 */
break;
case 114:
#line 1429 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-3].ll_node), (yyvsp[0].ll_node), EXPR_LIST); }
#line 5336 "gram1.tab.c" /* yacc.c:1646 */
break;
case 115:
#line 1433 "gram1.y" /* yacc.c:1646 */
{ type_options = type_options | PARAMETER_BIT;
(yyval.ll_node) = make_llnd(fi, PARAMETER_OP, LLNULL, LLNULL, SMNULL);
}
#line 5344 "gram1.tab.c" /* yacc.c:1646 */
break;
case 116:
#line 1437 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
#line 5350 "gram1.tab.c" /* yacc.c:1646 */
break;
case 117:
#line 1439 "gram1.y" /* yacc.c:1646 */
{ type_options = type_options | ALLOCATABLE_BIT;
(yyval.ll_node) = make_llnd(fi, ALLOCATABLE_OP, LLNULL, LLNULL, SMNULL);
}
#line 5358 "gram1.tab.c" /* yacc.c:1646 */
break;
case 118:
#line 1443 "gram1.y" /* yacc.c:1646 */
{ type_options = type_options | DIMENSION_BIT;
attr_ndim = ndim;
attr_dims = (yyvsp[0].ll_node);
(yyval.ll_node) = make_llnd(fi, DIMENSION_OP, (yyvsp[0].ll_node), LLNULL, SMNULL);
}
#line 5368 "gram1.tab.c" /* yacc.c:1646 */
break;
case 119:
#line 1449 "gram1.y" /* yacc.c:1646 */
{ type_options = type_options | EXTERNAL_BIT;
(yyval.ll_node) = make_llnd(fi, EXTERNAL_OP, LLNULL, LLNULL, SMNULL);
}
#line 5376 "gram1.tab.c" /* yacc.c:1646 */
break;
case 120:
#line 1453 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[-1].ll_node); }
#line 5382 "gram1.tab.c" /* yacc.c:1646 */
break;
case 121:
#line 1455 "gram1.y" /* yacc.c:1646 */
{ type_options = type_options | INTRINSIC_BIT;
(yyval.ll_node) = make_llnd(fi, INTRINSIC_OP, LLNULL, LLNULL, SMNULL);
}
#line 5390 "gram1.tab.c" /* yacc.c:1646 */
break;
case 122:
#line 1459 "gram1.y" /* yacc.c:1646 */
{ type_options = type_options | OPTIONAL_BIT;
(yyval.ll_node) = make_llnd(fi, OPTIONAL_OP, LLNULL, LLNULL, SMNULL);
}
#line 5398 "gram1.tab.c" /* yacc.c:1646 */
break;
case 123:
#line 1463 "gram1.y" /* yacc.c:1646 */
{ type_options = type_options | POINTER_BIT;
(yyval.ll_node) = make_llnd(fi, POINTER_OP, LLNULL, LLNULL, SMNULL);
}
#line 5406 "gram1.tab.c" /* yacc.c:1646 */
break;
case 124:
#line 1467 "gram1.y" /* yacc.c:1646 */
{ type_options = type_options | SAVE_BIT;
(yyval.ll_node) = make_llnd(fi, SAVE_OP, LLNULL, LLNULL, SMNULL);
}
#line 5414 "gram1.tab.c" /* yacc.c:1646 */
break;
case 125:
#line 1471 "gram1.y" /* yacc.c:1646 */
{ type_options = type_options | SAVE_BIT;
(yyval.ll_node) = make_llnd(fi, STATIC_OP, LLNULL, LLNULL, SMNULL);
}
#line 5422 "gram1.tab.c" /* yacc.c:1646 */
break;
case 126:
#line 1475 "gram1.y" /* yacc.c:1646 */
{ type_options = type_options | TARGET_BIT;
(yyval.ll_node) = make_llnd(fi, TARGET_OP, LLNULL, LLNULL, SMNULL);
}
#line 5430 "gram1.tab.c" /* yacc.c:1646 */
break;
case 127:
#line 1481 "gram1.y" /* yacc.c:1646 */
{ type_options = type_options | IN_BIT; type_opt = IN_BIT;
(yyval.ll_node) = make_llnd(fi, IN_OP, LLNULL, LLNULL, SMNULL);
}
#line 5438 "gram1.tab.c" /* yacc.c:1646 */
break;
case 128:
#line 1485 "gram1.y" /* yacc.c:1646 */
{ type_options = type_options | OUT_BIT; type_opt = OUT_BIT;
(yyval.ll_node) = make_llnd(fi, OUT_OP, LLNULL, LLNULL, SMNULL);
}
#line 5446 "gram1.tab.c" /* yacc.c:1646 */
break;
case 129:
#line 1489 "gram1.y" /* yacc.c:1646 */
{ type_options = type_options | INOUT_BIT; type_opt = INOUT_BIT;
(yyval.ll_node) = make_llnd(fi, INOUT_OP, LLNULL, LLNULL, SMNULL);
}
#line 5454 "gram1.tab.c" /* yacc.c:1646 */
break;
case 130:
#line 1495 "gram1.y" /* yacc.c:1646 */
{ type_options = type_options | PUBLIC_BIT;
type_opt = PUBLIC_BIT;
(yyval.ll_node) = make_llnd(fi, PUBLIC_OP, LLNULL, LLNULL, SMNULL);
}
#line 5463 "gram1.tab.c" /* yacc.c:1646 */
break;
case 131:
#line 1500 "gram1.y" /* yacc.c:1646 */
{ type_options = type_options | PRIVATE_BIT;
type_opt = PRIVATE_BIT;
(yyval.ll_node) = make_llnd(fi, PRIVATE_OP, LLNULL, LLNULL, SMNULL);
}
#line 5472 "gram1.tab.c" /* yacc.c:1646 */
break;
case 132:
#line 1507 "gram1.y" /* yacc.c:1646 */
{
PTR_LLND q, r;
PTR_SYMB s;
s = make_scalar((yyvsp[0].hash_entry), TYNULL, LOCAL);
s->attr = s->attr | type_opt;
q = make_llnd(fi,VAR_REF, LLNULL, LLNULL, s);
r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
(yyval.bf_node) = get_bfnd(fi, INTENT_STMT, SMNULL, r, (yyvsp[-3].ll_node), LLNULL);
}
#line 5487 "gram1.tab.c" /* yacc.c:1646 */
break;
case 133:
#line 1518 "gram1.y" /* yacc.c:1646 */
{
PTR_LLND q, r;
PTR_SYMB s;
s = make_scalar((yyvsp[0].hash_entry), TYNULL, LOCAL);
s->attr = s->attr | type_opt;
q = make_llnd(fi,VAR_REF, LLNULL, LLNULL, s);
r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
add_to_lowLevelList(r, (yyvsp[-2].bf_node)->entry.Template.ll_ptr1);
}
#line 5502 "gram1.tab.c" /* yacc.c:1646 */
break;
case 134:
#line 1531 "gram1.y" /* yacc.c:1646 */
{
PTR_LLND q, r;
PTR_SYMB s;
s = make_scalar((yyvsp[0].hash_entry), TYNULL, LOCAL);
s->attr = s->attr | OPTIONAL_BIT;
q = make_llnd(fi,VAR_REF, LLNULL, LLNULL, s);
r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
(yyval.bf_node) = get_bfnd(fi, OPTIONAL_STMT, SMNULL, r, LLNULL, LLNULL);
}
#line 5517 "gram1.tab.c" /* yacc.c:1646 */
break;
case 135:
#line 1542 "gram1.y" /* yacc.c:1646 */
{
PTR_LLND q, r;
PTR_SYMB s;
s = make_scalar((yyvsp[0].hash_entry), TYNULL, LOCAL);
s->attr = s->attr | OPTIONAL_BIT;
q = make_llnd(fi,VAR_REF, LLNULL, LLNULL, s);
r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
add_to_lowLevelList(r, (yyvsp[-2].bf_node)->entry.Template.ll_ptr1);
}
#line 5532 "gram1.tab.c" /* yacc.c:1646 */
break;
case 136:
#line 1555 "gram1.y" /* yacc.c:1646 */
{
PTR_LLND r;
PTR_SYMB s;
s = (yyvsp[0].ll_node)->entry.Template.symbol;
s->attr = s->attr | SAVE_BIT;
r = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
(yyval.bf_node) = get_bfnd(fi, STATIC_STMT, SMNULL, r, LLNULL, LLNULL);
}
#line 5546 "gram1.tab.c" /* yacc.c:1646 */
break;
case 137:
#line 1565 "gram1.y" /* yacc.c:1646 */
{
PTR_LLND r;
PTR_SYMB s;
s = (yyvsp[0].ll_node)->entry.Template.symbol;
s->attr = s->attr | SAVE_BIT;
r = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
add_to_lowLevelList(r, (yyvsp[-2].bf_node)->entry.Template.ll_ptr1);
}
#line 5560 "gram1.tab.c" /* yacc.c:1646 */
break;
case 138:
#line 1578 "gram1.y" /* yacc.c:1646 */
{
privateall = 1;
(yyval.bf_node) = get_bfnd(fi, PRIVATE_STMT, SMNULL, LLNULL, LLNULL, LLNULL);
}
#line 5569 "gram1.tab.c" /* yacc.c:1646 */
break;
case 139:
#line 1583 "gram1.y" /* yacc.c:1646 */
{
/*type_options = type_options | PRIVATE_BIT;*/
(yyval.bf_node) = get_bfnd(fi, PRIVATE_STMT, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL);
}
#line 5578 "gram1.tab.c" /* yacc.c:1646 */
break;
case 140:
#line 1589 "gram1.y" /* yacc.c:1646 */
{type_opt = PRIVATE_BIT;}
#line 5584 "gram1.tab.c" /* yacc.c:1646 */
break;
case 141:
#line 1593 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = get_bfnd(fi, SEQUENCE_STMT, SMNULL, LLNULL, LLNULL, LLNULL);
}
#line 5592 "gram1.tab.c" /* yacc.c:1646 */
break;
case 142:
#line 1598 "gram1.y" /* yacc.c:1646 */
{
/*saveall = YES;*/ /*14.03.03*/
(yyval.bf_node) = get_bfnd(fi, PUBLIC_STMT, SMNULL, LLNULL, LLNULL, LLNULL);
}
#line 5601 "gram1.tab.c" /* yacc.c:1646 */
break;
case 143:
#line 1603 "gram1.y" /* yacc.c:1646 */
{
/*type_options = type_options | PUBLIC_BIT;*/
(yyval.bf_node) = get_bfnd(fi, PUBLIC_STMT, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL);
}
#line 5610 "gram1.tab.c" /* yacc.c:1646 */
break;
case 144:
#line 1609 "gram1.y" /* yacc.c:1646 */
{type_opt = PUBLIC_BIT;}
#line 5616 "gram1.tab.c" /* yacc.c:1646 */
break;
case 145:
#line 1613 "gram1.y" /* yacc.c:1646 */
{
type_options = 0;
/* following block added by dbg */
ndim = 0;
attr_ndim = 0;
attr_dims = LLNULL;
/* end section added by dbg */
(yyval.data_type) = make_type_node((yyvsp[-3].data_type), (yyvsp[-1].ll_node));
}
#line 5630 "gram1.tab.c" /* yacc.c:1646 */
break;
case 146:
#line 1623 "gram1.y" /* yacc.c:1646 */
{ PTR_TYPE t;
type_options = 0;
ndim = 0;
attr_ndim = 0;
attr_dims = LLNULL;
t = lookup_type((yyvsp[-2].hash_entry));
vartype = t;
(yyval.data_type) = make_type_node(t, LLNULL);
}
#line 5645 "gram1.tab.c" /* yacc.c:1646 */
break;
case 147:
#line 1636 "gram1.y" /* yacc.c:1646 */
{opt_kwd_hedr = YES;}
#line 5651 "gram1.tab.c" /* yacc.c:1646 */
break;
case 148:
#line 1641 "gram1.y" /* yacc.c:1646 */
{ PTR_TYPE p;
PTR_LLND q;
PTR_SYMB s;
s = (yyvsp[0].hash_entry)->id_attr;
if (s)
s->attr = (yyvsp[-1].token);
else {
p = undeftype ? global_unknown : impltype[*(yyvsp[0].hash_entry)->ident - 'a'];
s = install_entry((yyvsp[0].hash_entry), SOFT);
s->attr = (yyvsp[-1].token);
set_type(s, p, LOCAL);
}
q = make_llnd(fi,VAR_REF, LLNULL, LLNULL, (yyvsp[0].hash_entry)->id_attr);
q = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
(yyval.bf_node) = get_bfnd(fi,ATTR_DECL, SMNULL, q, LLNULL, LLNULL);
}
#line 5672 "gram1.tab.c" /* yacc.c:1646 */
break;
case 149:
#line 1660 "gram1.y" /* yacc.c:1646 */
{ PTR_TYPE p;
PTR_LLND q, r;
PTR_SYMB s;
int att;
att = (yyvsp[-2].bf_node)->entry.Template.ll_ptr1->entry.Template.ll_ptr1->
entry.Template.symbol->attr;
s = (yyvsp[0].hash_entry)->id_attr;
if (s)
s->attr = att;
else {
p = undeftype ? global_unknown : impltype[*(yyvsp[0].hash_entry)->ident - 'a'];
s = install_entry((yyvsp[0].hash_entry), SOFT);
s->attr = att;
set_type(s, p, LOCAL);
}
q = make_llnd(fi,VAR_REF, LLNULL, LLNULL, (yyvsp[0].hash_entry)->id_attr);
for (r = (yyvsp[-2].bf_node)->entry.Template.ll_ptr1;
r->entry.list.next;
r = r->entry.list.next) ;
r->entry.list.next = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
}
#line 5700 "gram1.tab.c" /* yacc.c:1646 */
break;
case 150:
#line 1686 "gram1.y" /* yacc.c:1646 */
{ (yyval.token) = ATT_GLOBAL; }
#line 5706 "gram1.tab.c" /* yacc.c:1646 */
break;
case 151:
#line 1688 "gram1.y" /* yacc.c:1646 */
{ (yyval.token) = ATT_CLUSTER; }
#line 5712 "gram1.tab.c" /* yacc.c:1646 */
break;
case 152:
#line 1700 "gram1.y" /* yacc.c:1646 */
{
/* varleng = ($1<0 || $1==TYLONG ? 0 : typesize[$1]); */
vartype = (yyvsp[0].data_type);
}
#line 5721 "gram1.tab.c" /* yacc.c:1646 */
break;
case 153:
#line 1707 "gram1.y" /* yacc.c:1646 */
{ (yyval.data_type) = global_int; }
#line 5727 "gram1.tab.c" /* yacc.c:1646 */
break;
case 154:
#line 1708 "gram1.y" /* yacc.c:1646 */
{ (yyval.data_type) = global_float; }
#line 5733 "gram1.tab.c" /* yacc.c:1646 */
break;
case 155:
#line 1709 "gram1.y" /* yacc.c:1646 */
{ (yyval.data_type) = global_complex; }
#line 5739 "gram1.tab.c" /* yacc.c:1646 */
break;
case 156:
#line 1710 "gram1.y" /* yacc.c:1646 */
{ (yyval.data_type) = global_double; }
#line 5745 "gram1.tab.c" /* yacc.c:1646 */
break;
case 157:
#line 1711 "gram1.y" /* yacc.c:1646 */
{ (yyval.data_type) = global_dcomplex; }
#line 5751 "gram1.tab.c" /* yacc.c:1646 */
break;
case 158:
#line 1712 "gram1.y" /* yacc.c:1646 */
{ (yyval.data_type) = global_bool; }
#line 5757 "gram1.tab.c" /* yacc.c:1646 */
break;
case 159:
#line 1713 "gram1.y" /* yacc.c:1646 */
{ (yyval.data_type) = global_string; }
#line 5763 "gram1.tab.c" /* yacc.c:1646 */
break;
case 160:
#line 1718 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = LLNULL; }
#line 5769 "gram1.tab.c" /* yacc.c:1646 */
break;
case 161:
#line 1720 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
#line 5775 "gram1.tab.c" /* yacc.c:1646 */
break;
case 162:
#line 1724 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi, LEN_OP, (yyvsp[-2].ll_node), LLNULL, SMNULL); }
#line 5781 "gram1.tab.c" /* yacc.c:1646 */
break;
case 163:
#line 1726 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND l;
l = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
l->entry.string_val = (char *)"*";
(yyval.ll_node) = make_llnd(fi, LEN_OP, l,l, SMNULL);
}
#line 5792 "gram1.tab.c" /* yacc.c:1646 */
break;
case 164:
#line 1733 "gram1.y" /* yacc.c:1646 */
{(yyval.ll_node) = make_llnd(fi, LEN_OP, (yyvsp[-1].ll_node), (yyvsp[-1].ll_node), SMNULL);}
#line 5798 "gram1.tab.c" /* yacc.c:1646 */
break;
case 165:
#line 1737 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = LLNULL; }
#line 5804 "gram1.tab.c" /* yacc.c:1646 */
break;
case 166:
#line 1739 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
#line 5810 "gram1.tab.c" /* yacc.c:1646 */
break;
case 167:
#line 1741 "gram1.y" /* yacc.c:1646 */
{ /*$$ = make_llnd(fi, PAREN_OP, $2, LLNULL, SMNULL);*/ (yyval.ll_node) = (yyvsp[-2].ll_node); }
#line 5816 "gram1.tab.c" /* yacc.c:1646 */
break;
case 168:
#line 1749 "gram1.y" /* yacc.c:1646 */
{ if((yyvsp[-2].ll_node)->variant==LENGTH_OP && (yyvsp[-6].ll_node)->variant==(yyvsp[-2].ll_node)->variant)
(yyvsp[-2].ll_node)->variant=KIND_OP;
(yyval.ll_node) = make_llnd(fi, CONS, (yyvsp[-6].ll_node), (yyvsp[-2].ll_node), SMNULL);
}
#line 5825 "gram1.tab.c" /* yacc.c:1646 */
break;
case 169:
#line 1756 "gram1.y" /* yacc.c:1646 */
{ if(vartype->variant == T_STRING)
(yyval.ll_node) = make_llnd(fi,LENGTH_OP,(yyvsp[0].ll_node),LLNULL,SMNULL);
else
(yyval.ll_node) = make_llnd(fi,KIND_OP,(yyvsp[0].ll_node),LLNULL,SMNULL);
}
#line 5835 "gram1.tab.c" /* yacc.c:1646 */
break;
case 170:
#line 1762 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND l;
l = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
l->entry.string_val = (char *)"*";
(yyval.ll_node) = make_llnd(fi,LENGTH_OP,l,LLNULL,SMNULL);
}
#line 5845 "gram1.tab.c" /* yacc.c:1646 */
break;
case 171:
#line 1768 "gram1.y" /* yacc.c:1646 */
{ /* $$ = make_llnd(fi, SPEC_PAIR, $2, LLNULL, SMNULL); */
char *q;
q = (yyvsp[-1].ll_node)->entry.string_val;
if (strcmp(q, "len") == 0)
(yyval.ll_node) = make_llnd(fi,LENGTH_OP,(yyvsp[0].ll_node),LLNULL,SMNULL);
else
(yyval.ll_node) = make_llnd(fi,KIND_OP,(yyvsp[0].ll_node),LLNULL,SMNULL);
}
#line 5858 "gram1.tab.c" /* yacc.c:1646 */
break;
case 172:
#line 1777 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND l;
l = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
l->entry.string_val = (char *)"*";
(yyval.ll_node) = make_llnd(fi,LENGTH_OP,l,LLNULL,SMNULL);
}
#line 5868 "gram1.tab.c" /* yacc.c:1646 */
break;
case 173:
#line 1785 "gram1.y" /* yacc.c:1646 */
{endioctl();}
#line 5874 "gram1.tab.c" /* yacc.c:1646 */
break;
case 174:
#line 1798 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = LLNULL; }
#line 5880 "gram1.tab.c" /* yacc.c:1646 */
break;
case 175:
#line 1800 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
#line 5886 "gram1.tab.c" /* yacc.c:1646 */
break;
case 176:
#line 1803 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi, POINTST_OP, LLNULL, (yyvsp[0].ll_node), SMNULL); }
#line 5892 "gram1.tab.c" /* yacc.c:1646 */
break;
case 177:
#line 1807 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB s;
PTR_LLND q, r;
if(! (yyvsp[0].ll_node)) {
err("No dimensions in DIMENSION statement", 42);
}
if(statement_kind == 1) /*DVM-directive*/
err("No shape specification", 65);
s = make_array((yyvsp[-1].hash_entry), TYNULL, (yyvsp[0].ll_node), ndim, LOCAL);
s->attr = s->attr | DIMENSION_BIT;
q = make_llnd(fi,ARRAY_REF, (yyvsp[0].ll_node), LLNULL, s);
s->type->entry.ar_decl.ranges = (yyvsp[0].ll_node);
r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
(yyval.bf_node) = get_bfnd(fi,DIM_STAT, SMNULL, r, LLNULL, LLNULL);
}
#line 5911 "gram1.tab.c" /* yacc.c:1646 */
break;
case 178:
#line 1822 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB s;
PTR_LLND q, r;
if(! (yyvsp[0].ll_node)) {
err("No dimensions in DIMENSION statement", 42);
}
s = make_array((yyvsp[-1].hash_entry), TYNULL, (yyvsp[0].ll_node), ndim, LOCAL);
s->attr = s->attr | DIMENSION_BIT;
q = make_llnd(fi,ARRAY_REF, (yyvsp[0].ll_node), LLNULL, s);
s->type->entry.ar_decl.ranges = (yyvsp[0].ll_node);
r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
add_to_lowLevelList(r, (yyvsp[-3].bf_node)->entry.Template.ll_ptr1);
}
#line 5928 "gram1.tab.c" /* yacc.c:1646 */
break;
case 179:
#line 1838 "gram1.y" /* yacc.c:1646 */
{/* PTR_SYMB s;*/
PTR_LLND r;
/*if(!$5) {
err("No dimensions in ALLOCATABLE statement",305);
}
s = make_array($4, TYNULL, $5, ndim, LOCAL);
s->attr = s->attr | ALLOCATABLE_BIT;
q = make_llnd(fi,ARRAY_REF, $5, LLNULL, s);
s->type->entry.ar_decl.ranges = $5;
r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
*/
(yyvsp[0].ll_node)->entry.Template.symbol->attr = (yyvsp[0].ll_node)->entry.Template.symbol->attr | ALLOCATABLE_BIT;
r = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
(yyval.bf_node) = get_bfnd(fi, ALLOCATABLE_STMT, SMNULL, r, LLNULL, LLNULL);
}
#line 5949 "gram1.tab.c" /* yacc.c:1646 */
break;
case 180:
#line 1856 "gram1.y" /* yacc.c:1646 */
{ /*PTR_SYMB s;*/
PTR_LLND r;
/* if(! $4) {
err("No dimensions in ALLOCATABLE statement",305);
}
s = make_array($3, TYNULL, $4, ndim, LOCAL);
s->attr = s->attr | ALLOCATABLE_BIT;
q = make_llnd(fi,ARRAY_REF, $4, LLNULL, s);
s->type->entry.ar_decl.ranges = $4;
r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
*/
(yyvsp[0].ll_node)->entry.Template.symbol->attr = (yyvsp[0].ll_node)->entry.Template.symbol->attr | ALLOCATABLE_BIT;
r = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
add_to_lowLevelList(r, (yyvsp[-2].bf_node)->entry.Template.ll_ptr1);
}
#line 5971 "gram1.tab.c" /* yacc.c:1646 */
break;
case 181:
#line 1876 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB s;
PTR_LLND r;
/* if(! $5) {
err("No dimensions in POINTER statement",306);
}
s = make_array($4, TYNULL, $5, ndim, LOCAL);
s->attr = s->attr | POINTER_BIT;
q = make_llnd(fi,ARRAY_REF, $5, LLNULL, s);
s->type->entry.ar_decl.ranges = $5;
*/
/*s = make_pointer( $4->entry.Template.symbol->parent, TYNULL, LOCAL);*/ /*17.02.03*/
/*$4->entry.Template.symbol->attr = $4->entry.Template.symbol->attr | POINTER_BIT;*/
s = (yyvsp[0].ll_node)->entry.Template.symbol; /*17.02.03*/
s->attr = s->attr | POINTER_BIT;
r = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
(yyval.bf_node) = get_bfnd(fi, POINTER_STMT, SMNULL, r, LLNULL, LLNULL);
}
#line 5995 "gram1.tab.c" /* yacc.c:1646 */
break;
case 182:
#line 1896 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB s;
PTR_LLND r;
/* if(! $4) {
err("No dimensions in POINTER statement",306);
}
s = make_array($3, TYNULL, $4, ndim, LOCAL);
s->attr = s->attr | POINTER_BIT;
q = make_llnd(fi,ARRAY_REF, $4, LLNULL, s);
s->type->entry.ar_decl.ranges = $4;
*/
/*s = make_pointer( $3->entry.Template.symbol->parent, TYNULL, LOCAL);*/ /*17.02.03*/
/*$3->entry.Template.symbol->attr = $3->entry.Template.symbol->attr | POINTER_BIT;*/
s = (yyvsp[0].ll_node)->entry.Template.symbol; /*17.02.03*/
s->attr = s->attr | POINTER_BIT;
r = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
add_to_lowLevelList(r, (yyvsp[-2].bf_node)->entry.Template.ll_ptr1);
}
#line 6019 "gram1.tab.c" /* yacc.c:1646 */
break;
case 183:
#line 1918 "gram1.y" /* yacc.c:1646 */
{/* PTR_SYMB s;*/
PTR_LLND r;
/* if(! $5) {
err("No dimensions in TARGET statement",307);
}
s = make_array($4, TYNULL, $5, ndim, LOCAL);
s->attr = s->attr | TARGET_BIT;
q = make_llnd(fi,ARRAY_REF, $5, LLNULL, s);
s->type->entry.ar_decl.ranges = $5;
*/
(yyvsp[0].ll_node)->entry.Template.symbol->attr = (yyvsp[0].ll_node)->entry.Template.symbol->attr | TARGET_BIT;
r = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
(yyval.bf_node) = get_bfnd(fi, TARGET_STMT, SMNULL, r, LLNULL, LLNULL);
}
#line 6040 "gram1.tab.c" /* yacc.c:1646 */
break;
case 184:
#line 1935 "gram1.y" /* yacc.c:1646 */
{ /*PTR_SYMB s;*/
PTR_LLND r;
/* if(! $4) {
err("No dimensions in TARGET statement",307);
}
s = make_array($3, TYNULL, $4, ndim, LOCAL);
s->attr = s->attr | TARGET_BIT;
q = make_llnd(fi,ARRAY_REF, $4, LLNULL, s);
s->type->entry.ar_decl.ranges = $4;
*/
(yyvsp[0].ll_node)->entry.Template.symbol->attr = (yyvsp[0].ll_node)->entry.Template.symbol->attr | TARGET_BIT;
r = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
add_to_lowLevelList(r, (yyvsp[-2].bf_node)->entry.Template.ll_ptr1);
}
#line 6060 "gram1.tab.c" /* yacc.c:1646 */
break;
case 185:
#line 1953 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND p, q;
p = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
q = make_llnd(fi,COMM_LIST, p, LLNULL, SMNULL);
(yyval.bf_node) = get_bfnd(fi,COMM_STAT, SMNULL, q, LLNULL, LLNULL);
}
#line 6071 "gram1.tab.c" /* yacc.c:1646 */
break;
case 186:
#line 1960 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND p, q;
p = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
q = make_llnd(fi,COMM_LIST, p, LLNULL, (yyvsp[-1].symbol));
(yyval.bf_node) = get_bfnd(fi,COMM_STAT, SMNULL, q, LLNULL, LLNULL);
}
#line 6082 "gram1.tab.c" /* yacc.c:1646 */
break;
case 187:
#line 1967 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND p, q;
p = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
q = make_llnd(fi,COMM_LIST, p, LLNULL, (yyvsp[-2].symbol));
add_to_lowList(q, (yyvsp[-4].bf_node)->entry.Template.ll_ptr1);
}
#line 6093 "gram1.tab.c" /* yacc.c:1646 */
break;
case 188:
#line 1974 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND p, r;
p = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
/*q = make_llnd(fi,COMM_LIST, p, LLNULL, SMNULL);*/
for (r = (yyvsp[-2].bf_node)->entry.Template.ll_ptr1;
r->entry.list.next;
r = r->entry.list.next);
add_to_lowLevelList(p, r->entry.Template.ll_ptr1);
}
#line 6107 "gram1.tab.c" /* yacc.c:1646 */
break;
case 189:
#line 1987 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND q, r;
q = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
r = make_llnd(fi,NAMELIST_LIST, q, LLNULL, (yyvsp[-1].symbol));
(yyval.bf_node) = get_bfnd(fi,NAMELIST_STAT, SMNULL, r, LLNULL, LLNULL);
}
#line 6118 "gram1.tab.c" /* yacc.c:1646 */
break;
case 190:
#line 1994 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND q, r;
q = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
r = make_llnd(fi,NAMELIST_LIST, q, LLNULL, (yyvsp[-2].symbol));
add_to_lowList(r, (yyvsp[-4].bf_node)->entry.Template.ll_ptr1);
}
#line 6129 "gram1.tab.c" /* yacc.c:1646 */
break;
case 191:
#line 2001 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND q, r;
q = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
for (r = (yyvsp[-2].bf_node)->entry.Template.ll_ptr1;
r->entry.list.next;
r = r->entry.list.next);
add_to_lowLevelList(q, r->entry.Template.ll_ptr1);
}
#line 6142 "gram1.tab.c" /* yacc.c:1646 */
break;
case 192:
#line 2012 "gram1.y" /* yacc.c:1646 */
{ (yyval.symbol) = make_local_entity((yyvsp[-1].hash_entry), NAMELIST_NAME,global_default,LOCAL); }
#line 6148 "gram1.tab.c" /* yacc.c:1646 */
break;
case 193:
#line 2016 "gram1.y" /* yacc.c:1646 */
{ (yyval.symbol) = NULL; /*make_common(look_up_sym("*"));*/ }
#line 6154 "gram1.tab.c" /* yacc.c:1646 */
break;
case 194:
#line 2018 "gram1.y" /* yacc.c:1646 */
{ (yyval.symbol) = make_common((yyvsp[-1].hash_entry)); }
#line 6160 "gram1.tab.c" /* yacc.c:1646 */
break;
case 195:
#line 2023 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB s;
if((yyvsp[0].ll_node)) {
s = make_array((yyvsp[-1].hash_entry), TYNULL, (yyvsp[0].ll_node), ndim, LOCAL);
s->attr = s->attr | DIMENSION_BIT;
s->type->entry.ar_decl.ranges = (yyvsp[0].ll_node);
(yyval.ll_node) = make_llnd(fi,ARRAY_REF, (yyvsp[0].ll_node), LLNULL, s);
}
else {
s = make_scalar((yyvsp[-1].hash_entry), TYNULL, LOCAL);
(yyval.ll_node) = make_llnd(fi,VAR_REF, LLNULL, LLNULL, s);
}
}
#line 6179 "gram1.tab.c" /* yacc.c:1646 */
break;
case 196:
#line 2041 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND p, q;
PTR_SYMB s;
s = make_external((yyvsp[0].hash_entry), TYNULL);
s->attr = s->attr | EXTERNAL_BIT;
q = make_llnd(fi, VAR_REF, LLNULL, LLNULL, s);
p = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
(yyval.bf_node) = get_bfnd(fi,EXTERN_STAT, SMNULL, p, LLNULL, LLNULL);
}
#line 6193 "gram1.tab.c" /* yacc.c:1646 */
break;
case 197:
#line 2052 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND p, q;
PTR_SYMB s;
s = make_external((yyvsp[0].hash_entry), TYNULL);
s->attr = s->attr | EXTERNAL_BIT;
p = make_llnd(fi, VAR_REF, LLNULL, LLNULL, s);
q = make_llnd(fi,EXPR_LIST, p, LLNULL, SMNULL);
add_to_lowLevelList(q, (yyvsp[-2].bf_node)->entry.Template.ll_ptr1);
}
#line 6207 "gram1.tab.c" /* yacc.c:1646 */
break;
case 198:
#line 2064 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND p, q;
PTR_SYMB s;
s = make_intrinsic((yyvsp[0].hash_entry), TYNULL); /*make_function($3, TYNULL, NO);*/
s->attr = s->attr | INTRINSIC_BIT;
q = make_llnd(fi, VAR_REF, LLNULL, LLNULL, s);
p = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
(yyval.bf_node) = get_bfnd(fi,INTRIN_STAT, SMNULL, p,
LLNULL, LLNULL);
}
#line 6222 "gram1.tab.c" /* yacc.c:1646 */
break;
case 199:
#line 2076 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND p, q;
PTR_SYMB s;
s = make_intrinsic((yyvsp[0].hash_entry), TYNULL); /* make_function($3, TYNULL, NO);*/
s->attr = s->attr | INTRINSIC_BIT;
p = make_llnd(fi, VAR_REF, LLNULL, LLNULL, s);
q = make_llnd(fi,EXPR_LIST, p, LLNULL, SMNULL);
add_to_lowLevelList(q, (yyvsp[-2].bf_node)->entry.Template.ll_ptr1);
}
#line 6236 "gram1.tab.c" /* yacc.c:1646 */
break;
case 200:
#line 2090 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = get_bfnd(fi,EQUI_STAT, SMNULL, (yyvsp[0].ll_node),
LLNULL, LLNULL);
}
#line 6245 "gram1.tab.c" /* yacc.c:1646 */
break;
case 201:
#line 2096 "gram1.y" /* yacc.c:1646 */
{
add_to_lowLevelList((yyvsp[0].ll_node), (yyvsp[-2].bf_node)->entry.Template.ll_ptr1);
}
#line 6253 "gram1.tab.c" /* yacc.c:1646 */
break;
case 202:
#line 2103 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,EQUI_LIST, (yyvsp[-1].ll_node), LLNULL, SMNULL);
}
#line 6261 "gram1.tab.c" /* yacc.c:1646 */
break;
case 203:
#line 2109 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND p;
p = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
(yyval.ll_node) = make_llnd(fi,EXPR_LIST, (yyvsp[-2].ll_node), p, SMNULL);
}
#line 6270 "gram1.tab.c" /* yacc.c:1646 */
break;
case 204:
#line 2115 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND p;
p = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
add_to_lowLevelList(p, (yyvsp[-2].ll_node));
}
#line 6280 "gram1.tab.c" /* yacc.c:1646 */
break;
case 205:
#line 2123 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB s;
s=make_scalar((yyvsp[0].hash_entry),TYNULL,LOCAL);
(yyval.ll_node) = make_llnd(fi,VAR_REF, LLNULL, LLNULL, s);
s->attr = s->attr | EQUIVALENCE_BIT;
/*$$=$1; $$->entry.Template.symbol->attr = $$->entry.Template.symbol->attr | EQUIVALENCE_BIT; */
}
#line 6291 "gram1.tab.c" /* yacc.c:1646 */
break;
case 206:
#line 2130 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB s;
s=make_array((yyvsp[-3].hash_entry),TYNULL,LLNULL,0,LOCAL);
(yyval.ll_node) = make_llnd(fi,ARRAY_REF, (yyvsp[-1].ll_node), LLNULL, s);
s->attr = s->attr | EQUIVALENCE_BIT;
/*$$->entry.Template.symbol->attr = $$->entry.Template.symbol->attr | EQUIVALENCE_BIT; */
}
#line 6302 "gram1.tab.c" /* yacc.c:1646 */
break;
case 208:
#line 2149 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND p;
data_stat = NO;
p = make_llnd(fi,STMT_STR, LLNULL, LLNULL,
SMNULL);
p->entry.string_val = copys(stmtbuf);
(yyval.bf_node) = get_bfnd(fi,DATA_DECL, SMNULL, p, LLNULL, LLNULL);
}
#line 6314 "gram1.tab.c" /* yacc.c:1646 */
break;
case 211:
#line 2163 "gram1.y" /* yacc.c:1646 */
{data_stat = YES;}
#line 6320 "gram1.tab.c" /* yacc.c:1646 */
break;
case 212:
#line 2167 "gram1.y" /* yacc.c:1646 */
{
if (parstate == OUTSIDE)
{ PTR_BFND p;
p = get_bfnd(fi,PROG_HEDR,
make_program(look_up_sym("_MAIN")),
LLNULL, LLNULL, LLNULL);
set_blobs(p, global_bfnd, NEW_GROUP1);
add_scope_level(p, NO);
position = IN_PROC;
/*parstate = INDCL;*/
}
if(parstate < INDCL)
{
/* enddcl();*/
parstate = INDCL;
}
}
#line 6343 "gram1.tab.c" /* yacc.c:1646 */
break;
case 223:
#line 2212 "gram1.y" /* yacc.c:1646 */
{;}
#line 6349 "gram1.tab.c" /* yacc.c:1646 */
break;
case 224:
#line 2216 "gram1.y" /* yacc.c:1646 */
{ (yyval.symbol)= make_scalar((yyvsp[0].hash_entry), TYNULL, LOCAL);}
#line 6355 "gram1.tab.c" /* yacc.c:1646 */
break;
case 225:
#line 2220 "gram1.y" /* yacc.c:1646 */
{ (yyval.symbol)= make_scalar((yyvsp[0].hash_entry), TYNULL, LOCAL);
(yyval.symbol)->attr = (yyval.symbol)->attr | DATA_BIT;
}
#line 6363 "gram1.tab.c" /* yacc.c:1646 */
break;
case 226:
#line 2226 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi, DATA_SUBS, (yyvsp[-1].ll_node), LLNULL, SMNULL); }
#line 6369 "gram1.tab.c" /* yacc.c:1646 */
break;
case 227:
#line 2230 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi, DATA_RANGE, (yyvsp[-3].ll_node), (yyvsp[-1].ll_node), SMNULL); }
#line 6375 "gram1.tab.c" /* yacc.c:1646 */
break;
case 228:
#line 2234 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
#line 6381 "gram1.tab.c" /* yacc.c:1646 */
break;
case 229:
#line 2236 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = add_to_lowLevelList((yyvsp[0].ll_node), (yyvsp[-2].ll_node)); }
#line 6387 "gram1.tab.c" /* yacc.c:1646 */
break;
case 230:
#line 2240 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = LLNULL; }
#line 6393 "gram1.tab.c" /* yacc.c:1646 */
break;
case 231:
#line 2242 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
#line 6399 "gram1.tab.c" /* yacc.c:1646 */
break;
case 232:
#line 2246 "gram1.y" /* yacc.c:1646 */
{(yyval.ll_node)= make_llnd(fi, DATA_IMPL_DO, (yyvsp[-5].ll_node), (yyvsp[-1].ll_node), (yyvsp[-3].symbol)); }
#line 6405 "gram1.tab.c" /* yacc.c:1646 */
break;
case 233:
#line 2250 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
#line 6411 "gram1.tab.c" /* yacc.c:1646 */
break;
case 234:
#line 2252 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = add_to_lowLevelList((yyvsp[0].ll_node), (yyvsp[-2].ll_node)); }
#line 6417 "gram1.tab.c" /* yacc.c:1646 */
break;
case 235:
#line 2256 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi, DATA_ELT, (yyvsp[0].ll_node), LLNULL, (yyvsp[-1].symbol)); }
#line 6423 "gram1.tab.c" /* yacc.c:1646 */
break;
case 236:
#line 2258 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi, DATA_ELT, (yyvsp[0].ll_node), LLNULL, (yyvsp[-1].symbol)); }
#line 6429 "gram1.tab.c" /* yacc.c:1646 */
break;
case 237:
#line 2260 "gram1.y" /* yacc.c:1646 */
{
(yyvsp[-1].ll_node)->entry.Template.ll_ptr2 = (yyvsp[0].ll_node);
(yyval.ll_node) = make_llnd(fi, DATA_ELT, (yyvsp[-1].ll_node), LLNULL, (yyvsp[-2].symbol));
}
#line 6438 "gram1.tab.c" /* yacc.c:1646 */
break;
case 238:
#line 2265 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi, DATA_ELT, (yyvsp[0].ll_node), LLNULL, SMNULL); }
#line 6444 "gram1.tab.c" /* yacc.c:1646 */
break;
case 252:
#line 2289 "gram1.y" /* yacc.c:1646 */
{if((yyvsp[-4].ll_node)->entry.Template.symbol->variant != TYPE_NAME)
errstr("Undefined type %s",(yyvsp[-4].ll_node)->entry.Template.symbol->ident,319);
}
#line 6452 "gram1.tab.c" /* yacc.c:1646 */
break;
case 269:
#line 2334 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,ICON_EXPR, (yyvsp[0].ll_node), LLNULL, SMNULL); }
#line 6458 "gram1.tab.c" /* yacc.c:1646 */
break;
case 270:
#line 2336 "gram1.y" /* yacc.c:1646 */
{
PTR_LLND p;
p = intrinsic_op_node("+", UNARY_ADD_OP, (yyvsp[0].ll_node), LLNULL);
(yyval.ll_node) = make_llnd(fi,ICON_EXPR, p, LLNULL, SMNULL);
}
#line 6469 "gram1.tab.c" /* yacc.c:1646 */
break;
case 271:
#line 2343 "gram1.y" /* yacc.c:1646 */
{
PTR_LLND p;
p = intrinsic_op_node("-", MINUS_OP, (yyvsp[0].ll_node), LLNULL);
(yyval.ll_node) = make_llnd(fi,ICON_EXPR, p, LLNULL, SMNULL);
}
#line 6480 "gram1.tab.c" /* yacc.c:1646 */
break;
case 272:
#line 2350 "gram1.y" /* yacc.c:1646 */
{
PTR_LLND p;
p = intrinsic_op_node("+", ADD_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node));
(yyval.ll_node) = make_llnd(fi,ICON_EXPR, p, LLNULL, SMNULL);
}
#line 6491 "gram1.tab.c" /* yacc.c:1646 */
break;
case 273:
#line 2357 "gram1.y" /* yacc.c:1646 */
{
PTR_LLND p;
p = intrinsic_op_node("-", SUBT_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node));
(yyval.ll_node) = make_llnd(fi,ICON_EXPR, p, LLNULL, SMNULL);
}
#line 6502 "gram1.tab.c" /* yacc.c:1646 */
break;
case 274:
#line 2366 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
#line 6508 "gram1.tab.c" /* yacc.c:1646 */
break;
case 275:
#line 2368 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = intrinsic_op_node("*", MULT_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
#line 6514 "gram1.tab.c" /* yacc.c:1646 */
break;
case 276:
#line 2370 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = intrinsic_op_node("/", DIV_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
#line 6520 "gram1.tab.c" /* yacc.c:1646 */
break;
case 277:
#line 2374 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
#line 6526 "gram1.tab.c" /* yacc.c:1646 */
break;
case 278:
#line 2376 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = intrinsic_op_node("**", EXP_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
#line 6532 "gram1.tab.c" /* yacc.c:1646 */
break;
case 279:
#line 2380 "gram1.y" /* yacc.c:1646 */
{
PTR_LLND p;
p = make_llnd(fi,INT_VAL, LLNULL, LLNULL, SMNULL);
p->entry.ival = atoi(yytext);
p->type = global_int;
(yyval.ll_node) = make_llnd(fi,EXPR_LIST, p, LLNULL, SMNULL);
}
#line 6545 "gram1.tab.c" /* yacc.c:1646 */
break;
case 280:
#line 2389 "gram1.y" /* yacc.c:1646 */
{
PTR_LLND p;
p = make_llnd(fi,VAR_REF, LLNULL, LLNULL, (yyvsp[0].symbol));
(yyval.ll_node) = make_llnd(fi,EXPR_LIST, p, LLNULL, SMNULL);
}
#line 6556 "gram1.tab.c" /* yacc.c:1646 */
break;
case 281:
#line 2396 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,EXPR_LIST, (yyvsp[-1].ll_node), LLNULL, SMNULL);
}
#line 6564 "gram1.tab.c" /* yacc.c:1646 */
break;
case 282:
#line 2403 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL); }
#line 6570 "gram1.tab.c" /* yacc.c:1646 */
break;
case 283:
#line 2405 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); }
#line 6576 "gram1.tab.c" /* yacc.c:1646 */
break;
case 284:
#line 2409 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node);
(yyval.ll_node)->entry.Template.symbol->attr = (yyval.ll_node)->entry.Template.symbol->attr | SAVE_BIT;
}
#line 6584 "gram1.tab.c" /* yacc.c:1646 */
break;
case 285:
#line 2413 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,COMM_LIST, LLNULL, LLNULL, (yyvsp[0].symbol));
(yyval.ll_node)->entry.Template.symbol->attr = (yyval.ll_node)->entry.Template.symbol->attr | SAVE_BIT;
}
#line 6592 "gram1.tab.c" /* yacc.c:1646 */
break;
case 286:
#line 2419 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node), LLNULL, EXPR_LIST); }
#line 6598 "gram1.tab.c" /* yacc.c:1646 */
break;
case 287:
#line 2421 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-4].ll_node), (yyvsp[-1].ll_node), EXPR_LIST); }
#line 6604 "gram1.tab.c" /* yacc.c:1646 */
break;
case 288:
#line 2425 "gram1.y" /* yacc.c:1646 */
{ as_op_kwd_ = YES; }
#line 6610 "gram1.tab.c" /* yacc.c:1646 */
break;
case 289:
#line 2429 "gram1.y" /* yacc.c:1646 */
{ as_op_kwd_ = NO; }
#line 6616 "gram1.tab.c" /* yacc.c:1646 */
break;
case 290:
#line 2434 "gram1.y" /* yacc.c:1646 */
{
PTR_SYMB s;
s = make_scalar((yyvsp[0].hash_entry), TYNULL, LOCAL);
s->attr = s->attr | type_opt;
(yyval.ll_node) = make_llnd(fi,VAR_REF, LLNULL, LLNULL, s);
}
#line 6627 "gram1.tab.c" /* yacc.c:1646 */
break;
case 291:
#line 2441 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB s;
s = make_function((yyvsp[-1].hash_entry), global_default, LOCAL);
s->variant = INTERFACE_NAME;
s->attr = s->attr | type_opt;
(yyval.ll_node) = make_llnd(fi,OPERATOR_OP, LLNULL, LLNULL, s);
}
#line 6638 "gram1.tab.c" /* yacc.c:1646 */
break;
case 292:
#line 2448 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB s;
s = make_procedure(look_up_sym("="), LOCAL);
s->variant = INTERFACE_NAME;
s->attr = s->attr | type_opt;
(yyval.ll_node) = make_llnd(fi,ASSIGNMENT_OP, LLNULL, LLNULL, s);
}
#line 6649 "gram1.tab.c" /* yacc.c:1646 */
break;
case 293:
#line 2458 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); }
#line 6655 "gram1.tab.c" /* yacc.c:1646 */
break;
case 294:
#line 2460 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); }
#line 6661 "gram1.tab.c" /* yacc.c:1646 */
break;
case 295:
#line 2464 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB p;
/* The check if name and expr have compatible types has
not been done yet. */
p = make_constant((yyvsp[-2].hash_entry), TYNULL);
p->attr = p->attr | PARAMETER_BIT;
p->entry.const_value = (yyvsp[0].ll_node);
(yyval.ll_node) = make_llnd(fi,CONST_REF, LLNULL, LLNULL, p);
}
#line 6675 "gram1.tab.c" /* yacc.c:1646 */
break;
case 296:
#line 2476 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi, MODULE_PROC_STMT, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL); }
#line 6681 "gram1.tab.c" /* yacc.c:1646 */
break;
case 297:
#line 2479 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB s;
PTR_LLND q;
s = make_function((yyvsp[0].hash_entry), TYNULL, LOCAL);
s->variant = ROUTINE_NAME;
q = make_llnd(fi, VAR_REF, LLNULL, LLNULL, s);
(yyval.ll_node) = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
}
#line 6694 "gram1.tab.c" /* yacc.c:1646 */
break;
case 298:
#line 2488 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND p, q;
PTR_SYMB s;
s = make_function((yyvsp[0].hash_entry), TYNULL, LOCAL);
s->variant = ROUTINE_NAME;
p = make_llnd(fi, VAR_REF, LLNULL, LLNULL, s);
q = make_llnd(fi,EXPR_LIST, p, LLNULL, SMNULL);
add_to_lowLevelList(q, (yyvsp[-2].ll_node));
}
#line 6708 "gram1.tab.c" /* yacc.c:1646 */
break;
case 299:
#line 2501 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi, USE_STMT, (yyvsp[0].symbol), LLNULL, LLNULL, LLNULL);
/*add_scope_level($3->entry.Template.func_hedr, YES);*/ /*17.06.01*/
copy_module_scope((yyvsp[0].symbol),LLNULL); /*17.03.03*/
colon_flag = NO;
}
#line 6718 "gram1.tab.c" /* yacc.c:1646 */
break;
case 300:
#line 2507 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi, USE_STMT, (yyvsp[-3].symbol), (yyvsp[0].ll_node), LLNULL, LLNULL);
/*add_scope_level(module_scope, YES); *//* 17.06.01*/
copy_module_scope((yyvsp[-3].symbol),(yyvsp[0].ll_node)); /*17.03.03 */
colon_flag = NO;
}
#line 6728 "gram1.tab.c" /* yacc.c:1646 */
break;
case 301:
#line 2513 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND l;
l = make_llnd(fi, ONLY_NODE, LLNULL, LLNULL, SMNULL);
(yyval.bf_node) = get_bfnd(fi, USE_STMT, (yyvsp[-3].symbol), l, LLNULL, LLNULL);
}
#line 6738 "gram1.tab.c" /* yacc.c:1646 */
break;
case 302:
#line 2519 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND l;
l = make_llnd(fi, ONLY_NODE, (yyvsp[0].ll_node), LLNULL, SMNULL);
(yyval.bf_node) = get_bfnd(fi, USE_STMT, (yyvsp[-4].symbol), l, LLNULL, LLNULL);
}
#line 6748 "gram1.tab.c" /* yacc.c:1646 */
break;
case 303:
#line 2527 "gram1.y" /* yacc.c:1646 */
{
if ((yyvsp[0].hash_entry)->id_attr == SMNULL)
warn1("Unknown module %s", (yyvsp[0].hash_entry)->ident,308);
(yyval.symbol) = make_global_entity((yyvsp[0].hash_entry), MODULE_NAME, global_default, NO);
module_scope = (yyval.symbol)->entry.Template.func_hedr;
}
#line 6760 "gram1.tab.c" /* yacc.c:1646 */
break;
case 304:
#line 2537 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); }
#line 6766 "gram1.tab.c" /* yacc.c:1646 */
break;
case 305:
#line 2539 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); }
#line 6772 "gram1.tab.c" /* yacc.c:1646 */
break;
case 306:
#line 2543 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
#line 6778 "gram1.tab.c" /* yacc.c:1646 */
break;
case 307:
#line 2545 "gram1.y" /* yacc.c:1646 */
{ PTR_HASH oldhash,copyhash;
PTR_SYMB oldsym, newsym;
PTR_LLND m;
oldhash = just_look_up_sym_in_scope(module_scope, (yyvsp[0].hash_entry)->ident);
if (oldhash == HSNULL) {
errstr("Unknown identifier %s.", (yyvsp[0].hash_entry)->ident,309);
(yyval.ll_node)= LLNULL;
}
else {
oldsym = oldhash->id_attr;
copyhash=just_look_up_sym_in_scope(cur_scope(), (yyvsp[0].hash_entry)->ident);
if( copyhash && copyhash->id_attr && copyhash->id_attr->entry.Template.tag==module_scope->id)
{
newsym = copyhash->id_attr;
newsym->entry.Template.tag = 0;
}
else
{
newsym = make_local_entity((yyvsp[0].hash_entry), oldsym->variant, oldsym->type,LOCAL);
/* copies data in entry.Template structure and attr */
copy_sym_data(oldsym, newsym);
/*newsym->entry.Template.base_name = oldsym;*//*19.03.03*/
}
/* l = make_llnd(fi, VAR_REF, LLNULL, LLNULL, oldsym);*/
m = make_llnd(fi, VAR_REF, LLNULL, LLNULL, newsym);
(yyval.ll_node) = make_llnd(fi, RENAME_NODE, m, LLNULL, oldsym);
}
}
#line 6812 "gram1.tab.c" /* yacc.c:1646 */
break;
case 308:
#line 2578 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); }
#line 6818 "gram1.tab.c" /* yacc.c:1646 */
break;
case 309:
#line 2580 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); }
#line 6824 "gram1.tab.c" /* yacc.c:1646 */
break;
case 310:
#line 2584 "gram1.y" /* yacc.c:1646 */
{ PTR_HASH oldhash,copyhash;
PTR_SYMB oldsym, newsym;
PTR_LLND l, m;
oldhash = just_look_up_sym_in_scope(module_scope, (yyvsp[0].hash_entry)->ident);
if (oldhash == HSNULL) {
errstr("Unknown identifier %s", (yyvsp[0].hash_entry)->ident,309);
(yyval.ll_node)= LLNULL;
}
else {
oldsym = oldhash->id_attr;
copyhash = just_look_up_sym_in_scope(cur_scope(), (yyvsp[0].hash_entry)->ident);
if(copyhash && copyhash->id_attr && copyhash->id_attr->entry.Template.tag==module_scope->id)
{
delete_symbol(copyhash->id_attr);
copyhash->id_attr = SMNULL;
}
newsym = make_local_entity((yyvsp[-2].hash_entry), oldsym->variant, oldsym->type, LOCAL);
/* copies data in entry.Template structure and attr */
copy_sym_data(oldsym, newsym);
/*newsym->entry.Template.base_name = oldsym;*//*19.03.03*/
l = make_llnd(fi, VAR_REF, LLNULL, LLNULL, oldsym);
m = make_llnd(fi, VAR_REF, LLNULL, LLNULL, newsym);
(yyval.ll_node) = make_llnd(fi, RENAME_NODE, m, l, SMNULL);
}
}
#line 6856 "gram1.tab.c" /* yacc.c:1646 */
break;
case 311:
#line 2622 "gram1.y" /* yacc.c:1646 */
{ ndim = 0; explicit_shape = 1; (yyval.ll_node) = LLNULL; }
#line 6862 "gram1.tab.c" /* yacc.c:1646 */
break;
case 312:
#line 2624 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[-1].ll_node); }
#line 6868 "gram1.tab.c" /* yacc.c:1646 */
break;
case 313:
#line 2627 "gram1.y" /* yacc.c:1646 */
{ ndim = 0; explicit_shape = 1;}
#line 6874 "gram1.tab.c" /* yacc.c:1646 */
break;
case 314:
#line 2628 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
(yyval.ll_node)->type = global_default;
}
#line 6883 "gram1.tab.c" /* yacc.c:1646 */
break;
case 315:
#line 2633 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); }
#line 6889 "gram1.tab.c" /* yacc.c:1646 */
break;
case 316:
#line 2637 "gram1.y" /* yacc.c:1646 */
{
if(ndim == maxdim)
err("Too many dimensions", 43);
else if(ndim < maxdim)
(yyval.ll_node) = (yyvsp[0].ll_node);
++ndim;
}
#line 6901 "gram1.tab.c" /* yacc.c:1646 */
break;
case 317:
#line 2645 "gram1.y" /* yacc.c:1646 */
{
if(ndim == maxdim)
err("Too many dimensions", 43);
else if(ndim < maxdim)
(yyval.ll_node) = make_llnd(fi, DDOT, LLNULL, LLNULL, SMNULL);
++ndim;
explicit_shape = 0;
}
#line 6914 "gram1.tab.c" /* yacc.c:1646 */
break;
case 318:
#line 2654 "gram1.y" /* yacc.c:1646 */
{
if(ndim == maxdim)
err("Too many dimensions", 43);
else if(ndim < maxdim)
(yyval.ll_node) = make_llnd(fi,DDOT, (yyvsp[-1].ll_node), LLNULL, SMNULL);
++ndim;
explicit_shape = 0;
}
#line 6927 "gram1.tab.c" /* yacc.c:1646 */
break;
case 319:
#line 2663 "gram1.y" /* yacc.c:1646 */
{
if(ndim == maxdim)
err("Too many dimensions", 43);
else if(ndim < maxdim)
(yyval.ll_node) = make_llnd(fi,DDOT, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), SMNULL);
++ndim;
}
#line 6939 "gram1.tab.c" /* yacc.c:1646 */
break;
case 320:
#line 2673 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,STAR_RANGE, LLNULL, LLNULL, SMNULL);
(yyval.ll_node)->type = global_default;
explicit_shape = 0;
}
#line 6949 "gram1.tab.c" /* yacc.c:1646 */
break;
case 322:
#line 2682 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); }
#line 6955 "gram1.tab.c" /* yacc.c:1646 */
break;
case 323:
#line 2684 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); }
#line 6961 "gram1.tab.c" /* yacc.c:1646 */
break;
case 324:
#line 2688 "gram1.y" /* yacc.c:1646 */
{PTR_LABEL p;
p = make_label_node(fi,convci(yyleng, yytext));
p->scope = cur_scope();
(yyval.ll_node) = make_llnd_label(fi,LABEL_REF, p);
}
#line 6971 "gram1.tab.c" /* yacc.c:1646 */
break;
case 325:
#line 2696 "gram1.y" /* yacc.c:1646 */
{ /*PTR_LLND l;*/
/* l = make_llnd(fi, EXPR_LIST, $3, LLNULL, SMNULL);*/
(yyval.bf_node) = get_bfnd(fi,IMPL_DECL, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL);
redefine_func_arg_type();
}
#line 6982 "gram1.tab.c" /* yacc.c:1646 */
break;
case 326:
#line 2711 "gram1.y" /* yacc.c:1646 */
{ /*undeftype = YES;
setimpl(TYNULL, (int)'a', (int)'z'); FB COMMENTED---> NOT QUITE RIGHT BUT AVOID PB WITH COMMON*/
(yyval.bf_node) = get_bfnd(fi,IMPL_DECL, SMNULL, LLNULL, LLNULL, LLNULL);
}
#line 6991 "gram1.tab.c" /* yacc.c:1646 */
break;
case 327:
#line 2718 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); }
#line 6997 "gram1.tab.c" /* yacc.c:1646 */
break;
case 328:
#line 2720 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); }
#line 7003 "gram1.tab.c" /* yacc.c:1646 */
break;
case 329:
#line 2724 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi, IMPL_TYPE, (yyvsp[-1].ll_node), LLNULL, SMNULL);
(yyval.ll_node)->type = vartype;
}
#line 7013 "gram1.tab.c" /* yacc.c:1646 */
break;
case 330:
#line 2739 "gram1.y" /* yacc.c:1646 */
{ implkwd = YES; }
#line 7019 "gram1.tab.c" /* yacc.c:1646 */
break;
case 331:
#line 2740 "gram1.y" /* yacc.c:1646 */
{ vartype = (yyvsp[0].data_type); }
#line 7025 "gram1.tab.c" /* yacc.c:1646 */
break;
case 332:
#line 2744 "gram1.y" /* yacc.c:1646 */
{ (yyval.data_type) = (yyvsp[0].data_type); }
#line 7031 "gram1.tab.c" /* yacc.c:1646 */
break;
case 333:
#line 2746 "gram1.y" /* yacc.c:1646 */
{ (yyval.data_type) = (yyvsp[0].data_type);}
#line 7037 "gram1.tab.c" /* yacc.c:1646 */
break;
case 334:
#line 2758 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); }
#line 7043 "gram1.tab.c" /* yacc.c:1646 */
break;
case 335:
#line 2760 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); }
#line 7049 "gram1.tab.c" /* yacc.c:1646 */
break;
case 336:
#line 2764 "gram1.y" /* yacc.c:1646 */
{
setimpl(vartype, (int)(yyvsp[0].charv), (int)(yyvsp[0].charv));
(yyval.ll_node) = make_llnd(fi,CHAR_VAL, LLNULL, LLNULL, SMNULL);
(yyval.ll_node)->entry.cval = (yyvsp[0].charv);
}
#line 7059 "gram1.tab.c" /* yacc.c:1646 */
break;
case 337:
#line 2770 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND p,q;
setimpl(vartype, (int)(yyvsp[-2].charv), (int)(yyvsp[0].charv));
p = make_llnd(fi,CHAR_VAL, LLNULL, LLNULL, SMNULL);
p->entry.cval = (yyvsp[-2].charv);
q = make_llnd(fi,CHAR_VAL, LLNULL, LLNULL, SMNULL);
q->entry.cval = (yyvsp[0].charv);
(yyval.ll_node)= make_llnd(fi,DDOT, p, q, SMNULL);
}
#line 7073 "gram1.tab.c" /* yacc.c:1646 */
break;
case 338:
#line 2782 "gram1.y" /* yacc.c:1646 */
{
if(yyleng!=1 || yytext[0]<'a' || yytext[0]>'z')
{
err("IMPLICIT item must be single letter", 37);
(yyval.charv) = '\0';
}
else (yyval.charv) = yytext[0];
}
#line 7086 "gram1.tab.c" /* yacc.c:1646 */
break;
case 339:
#line 2793 "gram1.y" /* yacc.c:1646 */
{
if (parstate == OUTSIDE)
{ PTR_BFND p;
p = get_bfnd(fi,PROG_HEDR,
make_program(look_up_sym("_MAIN")),
LLNULL, LLNULL, LLNULL);
set_blobs(p, global_bfnd, NEW_GROUP1);
add_scope_level(p, NO);
position = IN_PROC;
parstate = INSIDE;
}
}
#line 7105 "gram1.tab.c" /* yacc.c:1646 */
break;
case 340:
#line 2810 "gram1.y" /* yacc.c:1646 */
{ switch(parstate)
{
case OUTSIDE:
{ PTR_BFND p;
p = get_bfnd(fi,PROG_HEDR,
make_program(look_up_sym("_MAIN")),
LLNULL, LLNULL, LLNULL);
set_blobs(p, global_bfnd, NEW_GROUP1);
add_scope_level(p, NO);
position = IN_PROC;
parstate = INDCL; }
break;
case INSIDE: parstate = INDCL;
case INDCL: break;
case INDATA:
/* err(
"Statement order error: declaration after DATA or function statement",
29);*/
break;
default:
err("Declaration among executables", 30);
}
}
#line 7136 "gram1.tab.c" /* yacc.c:1646 */
break;
case 343:
#line 2848 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = LLNULL; endioctl(); }
#line 7142 "gram1.tab.c" /* yacc.c:1646 */
break;
case 344:
#line 2850 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node); endioctl();}
#line 7148 "gram1.tab.c" /* yacc.c:1646 */
break;
case 345:
#line 2854 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
#line 7154 "gram1.tab.c" /* yacc.c:1646 */
break;
case 346:
#line 2856 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
#line 7160 "gram1.tab.c" /* yacc.c:1646 */
break;
case 347:
#line 2858 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND l;
l = make_llnd(fi, KEYWORD_ARG, (yyvsp[-1].ll_node), (yyvsp[0].ll_node), SMNULL);
l->type = (yyvsp[0].ll_node)->type;
(yyval.ll_node) = l;
}
#line 7170 "gram1.tab.c" /* yacc.c:1646 */
break;
case 348:
#line 2869 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST);
endioctl();
}
#line 7178 "gram1.tab.c" /* yacc.c:1646 */
break;
case 349:
#line 2873 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-3].ll_node), (yyvsp[0].ll_node), EXPR_LIST);
endioctl();
}
#line 7186 "gram1.tab.c" /* yacc.c:1646 */
break;
case 350:
#line 2879 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); }
#line 7192 "gram1.tab.c" /* yacc.c:1646 */
break;
case 351:
#line 2881 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); }
#line 7198 "gram1.tab.c" /* yacc.c:1646 */
break;
case 352:
#line 2885 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
#line 7204 "gram1.tab.c" /* yacc.c:1646 */
break;
case 353:
#line 2887 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[-1].ll_node); }
#line 7210 "gram1.tab.c" /* yacc.c:1646 */
break;
case 354:
#line 2889 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
#line 7216 "gram1.tab.c" /* yacc.c:1646 */
break;
case 355:
#line 2893 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
#line 7222 "gram1.tab.c" /* yacc.c:1646 */
break;
case 356:
#line 2895 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
#line 7228 "gram1.tab.c" /* yacc.c:1646 */
break;
case 357:
#line 2899 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
#line 7234 "gram1.tab.c" /* yacc.c:1646 */
break;
case 358:
#line 2901 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = intrinsic_op_node("+", ADD_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
#line 7240 "gram1.tab.c" /* yacc.c:1646 */
break;
case 359:
#line 2903 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = intrinsic_op_node("-", SUBT_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
#line 7246 "gram1.tab.c" /* yacc.c:1646 */
break;
case 360:
#line 2905 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = intrinsic_op_node("*", MULT_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
#line 7252 "gram1.tab.c" /* yacc.c:1646 */
break;
case 361:
#line 2907 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = intrinsic_op_node("/", DIV_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
#line 7258 "gram1.tab.c" /* yacc.c:1646 */
break;
case 362:
#line 2909 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = intrinsic_op_node("**", EXP_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
#line 7264 "gram1.tab.c" /* yacc.c:1646 */
break;
case 363:
#line 2911 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = defined_op_node((yyvsp[-1].hash_entry), (yyvsp[0].ll_node), LLNULL); }
#line 7270 "gram1.tab.c" /* yacc.c:1646 */
break;
case 364:
#line 2913 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = intrinsic_op_node("+", UNARY_ADD_OP, (yyvsp[0].ll_node), LLNULL); }
#line 7276 "gram1.tab.c" /* yacc.c:1646 */
break;
case 365:
#line 2915 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = intrinsic_op_node("-", MINUS_OP, (yyvsp[0].ll_node), LLNULL); }
#line 7282 "gram1.tab.c" /* yacc.c:1646 */
break;
case 366:
#line 2917 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = intrinsic_op_node(".eq.", EQ_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
#line 7288 "gram1.tab.c" /* yacc.c:1646 */
break;
case 367:
#line 2919 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = intrinsic_op_node(".gt.", GT_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
#line 7294 "gram1.tab.c" /* yacc.c:1646 */
break;
case 368:
#line 2921 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = intrinsic_op_node(".lt.", LT_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
#line 7300 "gram1.tab.c" /* yacc.c:1646 */
break;
case 369:
#line 2923 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = intrinsic_op_node(".ge.", GTEQL_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
#line 7306 "gram1.tab.c" /* yacc.c:1646 */
break;
case 370:
#line 2925 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = intrinsic_op_node(".ge.", LTEQL_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
#line 7312 "gram1.tab.c" /* yacc.c:1646 */
break;
case 371:
#line 2927 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = intrinsic_op_node(".ne.", NOTEQL_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
#line 7318 "gram1.tab.c" /* yacc.c:1646 */
break;
case 372:
#line 2929 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = intrinsic_op_node(".eqv.", EQV_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
#line 7324 "gram1.tab.c" /* yacc.c:1646 */
break;
case 373:
#line 2931 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = intrinsic_op_node(".neqv.", NEQV_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
#line 7330 "gram1.tab.c" /* yacc.c:1646 */
break;
case 374:
#line 2933 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = intrinsic_op_node(".xor.", XOR_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
#line 7336 "gram1.tab.c" /* yacc.c:1646 */
break;
case 375:
#line 2935 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = intrinsic_op_node(".or.", OR_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
#line 7342 "gram1.tab.c" /* yacc.c:1646 */
break;
case 376:
#line 2937 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = intrinsic_op_node(".and.", AND_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
#line 7348 "gram1.tab.c" /* yacc.c:1646 */
break;
case 377:
#line 2939 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = intrinsic_op_node(".not.", NOT_OP, (yyvsp[0].ll_node), LLNULL); }
#line 7354 "gram1.tab.c" /* yacc.c:1646 */
break;
case 378:
#line 2941 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = intrinsic_op_node("//", CONCAT_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
#line 7360 "gram1.tab.c" /* yacc.c:1646 */
break;
case 379:
#line 2943 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = defined_op_node((yyvsp[-1].hash_entry), (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
#line 7366 "gram1.tab.c" /* yacc.c:1646 */
break;
case 380:
#line 2946 "gram1.y" /* yacc.c:1646 */
{ (yyval.token) = ADD_OP; }
#line 7372 "gram1.tab.c" /* yacc.c:1646 */
break;
case 381:
#line 2947 "gram1.y" /* yacc.c:1646 */
{ (yyval.token) = SUBT_OP; }
#line 7378 "gram1.tab.c" /* yacc.c:1646 */
break;
case 382:
#line 2959 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB s;
PTR_TYPE t;
/* PTR_LLND l;*/
if (!(s = (yyvsp[0].hash_entry)->id_attr))
{
s = make_scalar((yyvsp[0].hash_entry), TYNULL, LOCAL);
s->decl = SOFT;
}
switch (s->variant)
{
case CONST_NAME:
(yyval.ll_node) = make_llnd(fi,CONST_REF,LLNULL,LLNULL, s);
t = s->type;
if ((t != TYNULL) &&
((t->variant == T_ARRAY) || (t->variant == T_STRING) ))
(yyval.ll_node)->variant = ARRAY_REF;
(yyval.ll_node)->type = t;
break;
case DEFAULT: /* if common region with same name has been
declared. */
s = make_scalar((yyvsp[0].hash_entry), TYNULL, LOCAL);
s->decl = SOFT;
case VARIABLE_NAME:
(yyval.ll_node) = make_llnd(fi,VAR_REF,LLNULL,LLNULL, s);
t = s->type;
if (t != TYNULL) {
if ((t->variant == T_ARRAY) || (t->variant == T_STRING) ||
((t->variant == T_POINTER) && (t->entry.Template.base_type->variant == T_ARRAY) ) )
(yyval.ll_node)->variant = ARRAY_REF;
/* if (t->variant == T_DERIVED_TYPE)
$$->variant = RECORD_REF; */
}
(yyval.ll_node)->type = t;
break;
case TYPE_NAME:
(yyval.ll_node) = make_llnd(fi,TYPE_REF,LLNULL,LLNULL, s);
(yyval.ll_node)->type = s->type;
break;
case INTERFACE_NAME:
(yyval.ll_node) = make_llnd(fi, INTERFACE_REF,LLNULL,LLNULL, s);
(yyval.ll_node)->type = s->type;
break;
case FUNCTION_NAME:
if(isResultVar(s)) {
(yyval.ll_node) = make_llnd(fi,VAR_REF,LLNULL,LLNULL, s);
t = s->type;
if (t != TYNULL) {
if ((t->variant == T_ARRAY) || (t->variant == T_STRING) ||
((t->variant == T_POINTER) && (t->entry.Template.base_type->variant == T_ARRAY) ) )
(yyval.ll_node)->variant = ARRAY_REF;
}
(yyval.ll_node)->type = t;
break;
}
default:
(yyval.ll_node) = make_llnd(fi,VAR_REF,LLNULL,LLNULL, s);
(yyval.ll_node)->type = s->type;
break;
}
/* if ($$->variant == T_POINTER) {
l = $$;
$$ = make_llnd(fi, DEREF_OP, l, LLNULL, SMNULL);
$$->type = l->type->entry.Template.base_type;
}
*/ /*11.02.03*/
}
#line 7454 "gram1.tab.c" /* yacc.c:1646 */
break;
case 383:
#line 3033 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB s;
(yyval.ll_node) = (yyvsp[0].ll_node);
s= (yyval.ll_node)->entry.Template.symbol;
if ((((yyvsp[0].ll_node)->variant == VAR_REF) || ((yyvsp[0].ll_node)->variant == ARRAY_REF)) && (s->scope !=cur_scope())) /*global_bfnd*/
{
if(((s->variant == FUNCTION_NAME) && (!isResultVar(s))) || (s->variant == PROCEDURE_NAME) || (s->variant == ROUTINE_NAME))
{ s = (yyval.ll_node)->entry.Template.symbol = make_scalar(s->parent, TYNULL, LOCAL);
(yyval.ll_node)->type = s->type;
}
}
}
#line 7470 "gram1.tab.c" /* yacc.c:1646 */
break;
case 384:
#line 3045 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
#line 7476 "gram1.tab.c" /* yacc.c:1646 */
break;
case 385:
#line 3047 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
#line 7482 "gram1.tab.c" /* yacc.c:1646 */
break;
case 386:
#line 3051 "gram1.y" /* yacc.c:1646 */
{ int num_triplets;
PTR_SYMB s; /*, sym;*/
/* PTR_LLND l; */
PTR_TYPE tp;
/* l = $1; */
s = (yyvsp[-4].ll_node)->entry.Template.symbol;
/* Handle variable to function conversion. */
if (((yyvsp[-4].ll_node)->variant == VAR_REF) &&
(((s->variant == VARIABLE_NAME) && (s->type) &&
(s->type->variant != T_ARRAY)) ||
(s->variant == ROUTINE_NAME))) {
s = (yyvsp[-4].ll_node)->entry.Template.symbol = make_function(s->parent, TYNULL, LOCAL);
(yyvsp[-4].ll_node)->variant = FUNC_CALL;
}
if (((yyvsp[-4].ll_node)->variant == VAR_REF) && (s->variant == FUNCTION_NAME)) {
if(isResultVar(s))
(yyvsp[-4].ll_node)->variant = ARRAY_REF;
else
(yyvsp[-4].ll_node)->variant = FUNC_CALL;
}
if (((yyvsp[-4].ll_node)->variant == VAR_REF) && (s->variant == PROGRAM_NAME)) {
errstr("The name '%s' is invalid in this context",s->ident,285);
(yyvsp[-4].ll_node)->variant = FUNC_CALL;
}
/* l = $1; */
num_triplets = is_array_section_ref((yyvsp[-1].ll_node));
switch ((yyvsp[-4].ll_node)->variant)
{
case TYPE_REF:
(yyvsp[-4].ll_node)->variant = STRUCTURE_CONSTRUCTOR;
(yyvsp[-4].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);
(yyval.ll_node) = (yyvsp[-4].ll_node);
(yyval.ll_node)->type = lookup_type(s->parent);
/* $$ = make_llnd(fi, STRUCTURE_CONSTRUCTOR, $1, $4, SMNULL);
$$->type = $1->type;*//*18.02.03*/
break;
case INTERFACE_REF:
/* sym = resolve_overloading(s, $4);
if (sym != SMNULL)
{
l = make_llnd(fi, FUNC_CALL, $4, LLNULL, sym);
l->type = sym->type;
$$ = $1; $$->variant = OVERLOADED_CALL;
$$->entry.Template.ll_ptr1 = l;
$$->type = sym->type;
}
else {
errstr("can't resolve call %s", s->ident,310);
}
break;
*/ /*podd 01.02.03*/
(yyvsp[-4].ll_node)->variant = FUNC_CALL;
case FUNC_CALL:
(yyvsp[-4].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);
(yyval.ll_node) = (yyvsp[-4].ll_node);
if(s->type)
(yyval.ll_node)->type = s->type;
else
(yyval.ll_node)->type = global_default;
/*late_bind_if_needed($$);*/ /*podd 02.02.23*/
break;
case DEREF_OP:
case ARRAY_REF:
/* array element */
if (num_triplets == 0) {
if ((yyvsp[-1].ll_node) == LLNULL) {
s = (yyvsp[-4].ll_node)->entry.Template.symbol = make_function(s->parent, TYNULL, LOCAL);
s->entry.func_decl.num_output = 1;
(yyvsp[-4].ll_node)->variant = FUNC_CALL;
(yyval.ll_node) = (yyvsp[-4].ll_node);
} else if ((yyvsp[-4].ll_node)->type->variant == T_STRING) {
PTR_LLND temp = (yyvsp[-1].ll_node);
int num_input = 0;
while (temp) {
++num_input;
temp = temp->entry.Template.ll_ptr2;
}
(yyvsp[-4].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);
s = (yyvsp[-4].ll_node)->entry.Template.symbol = make_function(s->parent, TYNULL, LOCAL);
s->entry.func_decl.num_output = 1;
s->entry.func_decl.num_input = num_input;
(yyvsp[-4].ll_node)->variant = FUNC_CALL;
(yyval.ll_node) = (yyvsp[-4].ll_node);
} else {
(yyvsp[-4].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);
(yyval.ll_node) = (yyvsp[-4].ll_node);
(yyval.ll_node)->type = (yyvsp[-4].ll_node)->type->entry.ar_decl.base_type;
}
}
/* substring */
else if ((num_triplets == 1) &&
((yyvsp[-4].ll_node)->type->variant == T_STRING)) {
/*
$1->entry.Template.ll_ptr1 = $4;
$$ = $1; $$->type = global_string;
*/
(yyval.ll_node) = make_llnd(fi,
ARRAY_OP, LLNULL, LLNULL, SMNULL);
(yyval.ll_node)->entry.Template.ll_ptr1 = (yyvsp[-4].ll_node);
(yyval.ll_node)->entry.Template.ll_ptr2 = (yyvsp[-1].ll_node)->entry.Template.ll_ptr1;
(yyval.ll_node)->type = global_string;
}
/* array section */
else {
(yyvsp[-4].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);
(yyval.ll_node) = (yyvsp[-4].ll_node); tp = make_type(fi, T_ARRAY); /**18.03.17*/
tp->entry.ar_decl.base_type = (yyvsp[-4].ll_node)->type->entry.ar_decl.base_type; /**18.03.17 $1->type */
tp->entry.ar_decl.num_dimensions = num_triplets;
(yyval.ll_node)->type = tp;
}
break;
default:
if((yyvsp[-4].ll_node)->entry.Template.symbol)
errstr("Can't subscript %s",(yyvsp[-4].ll_node)->entry.Template.symbol->ident, 44);
else
err("Can't subscript",44);
}
/*if ($$->variant == T_POINTER) {
l = $$;
$$ = make_llnd(fi, DEREF_OP, l, LLNULL, SMNULL);
$$->type = l->type->entry.Template.base_type;
}
*/ /*11.02.03*/
endioctl();
}
#line 7617 "gram1.tab.c" /* yacc.c:1646 */
break;
case 387:
#line 3182 "gram1.y" /* yacc.c:1646 */
{ int num_triplets;
PTR_SYMB s;
PTR_LLND l;
s = (yyvsp[-5].ll_node)->entry.Template.symbol;
/* if ($1->type->variant == T_POINTER) {
l = $1;
$1 = make_llnd(fi, DEREF_OP, l, LLNULL, SMNULL);
$1->type = l->type->entry.Template.base_type;
} */
if (((yyvsp[-5].ll_node)->type->variant != T_ARRAY) ||
((yyvsp[-5].ll_node)->type->entry.ar_decl.base_type->variant != T_STRING)) {
errstr("Can't take substring of %s", s->ident, 45);
}
else {
num_triplets = is_array_section_ref((yyvsp[-2].ll_node));
/* array element */
if (num_triplets == 0) {
(yyvsp[-5].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-2].ll_node);
/* $1->entry.Template.ll_ptr2 = $6;*/
/* $$ = $1;*/
l=(yyvsp[-5].ll_node);
/*$$->type = $1->type->entry.ar_decl.base_type;*/
l->type = global_string; /**18.03.17* $1->type->entry.ar_decl.base_type;*/
}
/* array section */
else {
(yyvsp[-5].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-2].ll_node);
/*$1->entry.Template.ll_ptr2 = $6;
$$ = $1; $$->type = make_type(fi, T_ARRAY);
$$->type->entry.ar_decl.base_type = $1->type;
$$->type->entry.ar_decl.num_dimensions = num_triplets;
*/
l = (yyvsp[-5].ll_node); l->type = make_type(fi, T_ARRAY);
l->type->entry.ar_decl.base_type = global_string; /**18.03.17* $1->type*/
l->type->entry.ar_decl.num_dimensions = num_triplets;
}
(yyval.ll_node) = make_llnd(fi, ARRAY_OP, l, (yyvsp[0].ll_node), SMNULL);
(yyval.ll_node)->type = l->type;
/* if ($$->variant == T_POINTER) {
l = $$;
$$ = make_llnd(fi, DEREF_OP, l, LLNULL, SMNULL);
$$->type = l->type->entry.Template.base_type;
}
*/ /*11.02.03*/
}
endioctl();
}
#line 7671 "gram1.tab.c" /* yacc.c:1646 */
break;
case 388:
#line 3232 "gram1.y" /* yacc.c:1646 */
{ int num_triplets;
PTR_LLND l,l1,l2;
PTR_TYPE tp;
/* if ($1->variant == T_POINTER) {
l = $1;
$1 = make_llnd(fi, DEREF_OP, l, LLNULL, SMNULL);
$1->type = l->type->entry.Template.base_type;
} */
num_triplets = is_array_section_ref((yyvsp[-1].ll_node));
(yyval.ll_node) = (yyvsp[-3].ll_node);
l2 = (yyvsp[-3].ll_node)->entry.Template.ll_ptr2;
l1 = (yyvsp[-3].ll_node)->entry.Template.ll_ptr1;
if(l2 && l2->type->variant == T_STRING)/*substring*/
if(num_triplets == 1){
l = make_llnd(fi, ARRAY_OP, LLNULL, LLNULL, SMNULL);
l->entry.Template.ll_ptr1 = l2;
l->entry.Template.ll_ptr2 = (yyvsp[-1].ll_node)->entry.Template.ll_ptr1;
l->type = global_string;
(yyval.ll_node)->entry.Template.ll_ptr2 = l;
} else
err("Can't subscript",44);
else if (l2 && l2->type->variant == T_ARRAY) {
if(num_triplets > 0) { /*array section*/
tp = make_type(fi,T_ARRAY);
tp->entry.ar_decl.base_type = (yyvsp[-3].ll_node)->type->entry.ar_decl.base_type;
tp->entry.ar_decl.num_dimensions = num_triplets;
(yyval.ll_node)->type = tp;
l2->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);
l2->type = (yyval.ll_node)->type;
}
else { /*array element*/
l2->type = l2->type->entry.ar_decl.base_type;
l2->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);
if(l1->type->variant != T_ARRAY)
(yyval.ll_node)->type = l2->type;
}
} else
{err("Can't subscript",44); /*fprintf(stderr,"%d %d",$1->variant,l2);*/}
/*errstr("Can't subscript %s",l2->entry.Template.symbol->ident,441);*/
}
#line 7718 "gram1.tab.c" /* yacc.c:1646 */
break;
case 389:
#line 3276 "gram1.y" /* yacc.c:1646 */
{ int num_triplets;
PTR_LLND l,q;
/* if ($1->variant == T_POINTER) {
l = $1;
$1 = make_llnd(fi, DEREF_OP, l, LLNULL, SMNULL);
$1->type = l->type->entry.Template.base_type;
} */
(yyval.ll_node) = (yyvsp[-4].ll_node);
if (((yyvsp[-4].ll_node)->type->variant != T_ARRAY) &&
((yyvsp[-4].ll_node)->type->entry.ar_decl.base_type->variant != T_STRING)) {
err("Can't take substring",45);
}
else {
num_triplets = is_array_section_ref((yyvsp[-2].ll_node));
l = (yyvsp[-4].ll_node)->entry.Template.ll_ptr2;
if(l) {
/* array element */
if (num_triplets == 0) {
l->entry.Template.ll_ptr1 = (yyvsp[-2].ll_node);
l->type = global_string;
}
/* array section */
else {
l->entry.Template.ll_ptr1 = (yyvsp[-2].ll_node);
l->type = make_type(fi, T_ARRAY);
l->type->entry.ar_decl.base_type = global_string;
l->type->entry.ar_decl.num_dimensions = num_triplets;
}
q = make_llnd(fi, ARRAY_OP, l, (yyvsp[0].ll_node), SMNULL);
q->type = l->type;
(yyval.ll_node)->entry.Template.ll_ptr2 = q;
if((yyvsp[-4].ll_node)->entry.Template.ll_ptr1->type->variant != T_ARRAY)
(yyval.ll_node)->type = q->type;
}
}
}
#line 7761 "gram1.tab.c" /* yacc.c:1646 */
break;
case 390:
#line 3318 "gram1.y" /* yacc.c:1646 */
{ PTR_TYPE t;
PTR_SYMB field;
/* PTR_BFND at_scope;*/
PTR_LLND l;
/* if ($1->variant == T_POINTER) {
l = $1;
$1 = make_llnd(fi, DEREF_OP, l, LLNULL, SMNULL);
$1->type = l->type->entry.Template.base_type;
} */
t = (yyvsp[-2].ll_node)->type;
if (( ( ((yyvsp[-2].ll_node)->variant == VAR_REF)
|| ((yyvsp[-2].ll_node)->variant == CONST_REF)
|| ((yyvsp[-2].ll_node)->variant == ARRAY_REF)
|| ((yyvsp[-2].ll_node)->variant == RECORD_REF)) && (t->variant == T_DERIVED_TYPE))
||((((yyvsp[-2].ll_node)->variant == ARRAY_REF) || ((yyvsp[-2].ll_node)->variant == RECORD_REF)) && (t->variant == T_ARRAY) &&
(t = t->entry.ar_decl.base_type) && (t->variant == T_DERIVED_TYPE)))
{
t->name = lookup_type_symbol(t->name);
if ((field = component(t->name, yytext))) {
l = make_llnd(fi, VAR_REF, LLNULL, LLNULL, field);
l->type = field->type;
if(field->type->variant == T_ARRAY || field->type->variant == T_STRING)
l->variant = ARRAY_REF;
(yyval.ll_node) = make_llnd(fi, RECORD_REF, (yyvsp[-2].ll_node), l, SMNULL);
if((yyvsp[-2].ll_node)->type->variant != T_ARRAY)
(yyval.ll_node)->type = field->type;
else {
(yyval.ll_node)->type = make_type(fi,T_ARRAY);
if(field->type->variant != T_ARRAY)
(yyval.ll_node)->type->entry.ar_decl.base_type = field->type;
else
(yyval.ll_node)->type->entry.ar_decl.base_type = field->type->entry.ar_decl.base_type;
(yyval.ll_node)->type->entry.ar_decl.num_dimensions = t->entry.ar_decl.num_dimensions;
}
}
else
errstr("Illegal component %s", yytext,311);
}
else
errstr("Can't take component %s", yytext,311);
}
#line 7811 "gram1.tab.c" /* yacc.c:1646 */
break;
case 391:
#line 3376 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
#line 7817 "gram1.tab.c" /* yacc.c:1646 */
break;
case 392:
#line 3378 "gram1.y" /* yacc.c:1646 */
{(yyval.ll_node) = (yyvsp[0].ll_node);}
#line 7823 "gram1.tab.c" /* yacc.c:1646 */
break;
case 393:
#line 3380 "gram1.y" /* yacc.c:1646 */
{ int num_triplets;
PTR_TYPE tp;
/* PTR_LLND l;*/
if ((yyvsp[-4].ll_node)->type->variant == T_ARRAY)
{
num_triplets = is_array_section_ref((yyvsp[-1].ll_node));
/* array element */
if (num_triplets == 0) {
(yyvsp[-4].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);
(yyval.ll_node) = (yyvsp[-4].ll_node);
(yyval.ll_node)->type = (yyvsp[-4].ll_node)->type->entry.ar_decl.base_type;
}
/* substring */
/* else if ((num_triplets == 1) &&
($1->type->variant == T_STRING)) {
$1->entry.Template.ll_ptr1 = $4;
$$ = $1; $$->type = global_string;
} */ /*podd*/
/* array section */
else {
(yyvsp[-4].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);
(yyval.ll_node) = (yyvsp[-4].ll_node); tp = make_type(fi, T_ARRAY);
tp->entry.ar_decl.base_type = (yyvsp[-4].ll_node)->type->entry.ar_decl.base_type; /**18.03.17* $1->type */
tp->entry.ar_decl.num_dimensions = num_triplets;
(yyval.ll_node)->type = tp;
}
}
else err("can't subscript",44);
/* if ($$->variant == T_POINTER) {
l = $$;
$$ = make_llnd(fi, DEREF_OP, l, LLNULL, SMNULL);
$$->type = l->type->entry.Template.base_type;
}
*/ /*11.02.03*/
endioctl();
}
#line 7866 "gram1.tab.c" /* yacc.c:1646 */
break;
case 394:
#line 3420 "gram1.y" /* yacc.c:1646 */
{ int num_triplets;
PTR_LLND l,l1,l2;
/* if ($1->variant == T_POINTER) {
l = $1;
$1 = make_llnd(fi, DEREF_OP, l, LLNULL, SMNULL);
$1->type = l->type->entry.Template.base_type;
} */
num_triplets = is_array_section_ref((yyvsp[-1].ll_node));
(yyval.ll_node) = (yyvsp[-3].ll_node);
l2 = (yyvsp[-3].ll_node)->entry.Template.ll_ptr2;
l1 = (yyvsp[-3].ll_node)->entry.Template.ll_ptr1;
if(l2 && l2->type->variant == T_STRING)/*substring*/
if(num_triplets == 1){
l = make_llnd(fi, ARRAY_OP, LLNULL, LLNULL, SMNULL);
l->entry.Template.ll_ptr1 = l2;
l->entry.Template.ll_ptr2 = (yyvsp[-1].ll_node)->entry.Template.ll_ptr1;
l->type = global_string;
(yyval.ll_node)->entry.Template.ll_ptr2 = l;
} else
err("Can't subscript",44);
else if (l2 && l2->type->variant == T_ARRAY) {
if(num_triplets > 0) { /*array section*/
(yyval.ll_node)->type = make_type(fi,T_ARRAY);
(yyval.ll_node)->type->entry.ar_decl.base_type = l2->type->entry.ar_decl.base_type;
(yyval.ll_node)->type->entry.ar_decl.num_dimensions = num_triplets;
l2->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);
l2->type = (yyval.ll_node)->type;
}
else { /*array element*/
l2->type = l2->type->entry.ar_decl.base_type;
l2->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);
if(l1->type->variant != T_ARRAY)
(yyval.ll_node)->type = l2->type;
}
} else
err("Can't subscript",44);
}
#line 7910 "gram1.tab.c" /* yacc.c:1646 */
break;
case 395:
#line 3462 "gram1.y" /* yacc.c:1646 */
{
if ((yyvsp[-1].ll_node)->type->variant == T_STRING) {
(yyvsp[-1].ll_node)->entry.Template.ll_ptr1 = (yyvsp[0].ll_node);
(yyval.ll_node) = (yyvsp[-1].ll_node); (yyval.ll_node)->type = global_string;
}
else errstr("can't subscript of %s", (yyvsp[-1].ll_node)->entry.Template.symbol->ident,44);
}
#line 7922 "gram1.tab.c" /* yacc.c:1646 */
break;
case 396:
#line 3472 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = LLNULL; }
#line 7928 "gram1.tab.c" /* yacc.c:1646 */
break;
case 397:
#line 3474 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
#line 7934 "gram1.tab.c" /* yacc.c:1646 */
break;
case 398:
#line 3478 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi, DDOT, (yyvsp[-3].ll_node), (yyvsp[-1].ll_node), SMNULL); }
#line 7940 "gram1.tab.c" /* yacc.c:1646 */
break;
case 399:
#line 3482 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = LLNULL; }
#line 7946 "gram1.tab.c" /* yacc.c:1646 */
break;
case 400:
#line 3484 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
#line 7952 "gram1.tab.c" /* yacc.c:1646 */
break;
case 401:
#line 3488 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
#line 7958 "gram1.tab.c" /* yacc.c:1646 */
break;
case 402:
#line 3490 "gram1.y" /* yacc.c:1646 */
{ PTR_TYPE t;
t = make_type_node((yyvsp[-2].ll_node)->type, (yyvsp[0].ll_node));
(yyval.ll_node) = (yyvsp[-2].ll_node);
(yyval.ll_node)->type = t;
}
#line 7968 "gram1.tab.c" /* yacc.c:1646 */
break;
case 403:
#line 3496 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
#line 7974 "gram1.tab.c" /* yacc.c:1646 */
break;
case 404:
#line 3498 "gram1.y" /* yacc.c:1646 */
{ PTR_TYPE t;
t = make_type_node((yyvsp[-2].ll_node)->type, (yyvsp[0].ll_node));
(yyval.ll_node) = (yyvsp[-2].ll_node);
(yyval.ll_node)->type = t;
}
#line 7984 "gram1.tab.c" /* yacc.c:1646 */
break;
case 405:
#line 3504 "gram1.y" /* yacc.c:1646 */
{
if ((yyvsp[0].ll_node) != LLNULL)
{
(yyval.ll_node) = make_llnd(fi, ARRAY_OP, (yyvsp[-1].ll_node), (yyvsp[0].ll_node), SMNULL);
(yyval.ll_node)->type = global_string;
}
else
(yyval.ll_node) = (yyvsp[-1].ll_node);
}
#line 7998 "gram1.tab.c" /* yacc.c:1646 */
break;
case 406:
#line 3517 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,BOOL_VAL, LLNULL, LLNULL, SMNULL);
(yyval.ll_node)->entry.bval = 1;
(yyval.ll_node)->type = global_bool;
}
#line 8008 "gram1.tab.c" /* yacc.c:1646 */
break;
case 407:
#line 3523 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,BOOL_VAL, LLNULL, LLNULL, SMNULL);
(yyval.ll_node)->entry.bval = 0;
(yyval.ll_node)->type = global_bool;
}
#line 8018 "gram1.tab.c" /* yacc.c:1646 */
break;
case 408:
#line 3530 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,FLOAT_VAL, LLNULL, LLNULL, SMNULL);
(yyval.ll_node)->entry.string_val = copys(yytext);
(yyval.ll_node)->type = global_float;
}
#line 8028 "gram1.tab.c" /* yacc.c:1646 */
break;
case 409:
#line 3536 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,DOUBLE_VAL, LLNULL, LLNULL, SMNULL);
(yyval.ll_node)->entry.string_val = copys(yytext);
(yyval.ll_node)->type = global_double;
}
#line 8038 "gram1.tab.c" /* yacc.c:1646 */
break;
case 410:
#line 3544 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,INT_VAL, LLNULL, LLNULL, SMNULL);
(yyval.ll_node)->entry.ival = atoi(yytext);
(yyval.ll_node)->type = global_int;
}
#line 8048 "gram1.tab.c" /* yacc.c:1646 */
break;
case 411:
#line 3552 "gram1.y" /* yacc.c:1646 */
{ PTR_TYPE t;
PTR_LLND p,q;
(yyval.ll_node) = make_llnd(fi,STRING_VAL, LLNULL, LLNULL, SMNULL);
(yyval.ll_node)->entry.string_val = copys(yytext);
if(yyquote=='\"')
t = global_string_2;
else
t = global_string;
p = make_llnd(fi,INT_VAL, LLNULL, LLNULL, SMNULL);
p->entry.ival = yyleng;
p->type = global_int;
q = make_llnd(fi, LEN_OP, p, LLNULL, SMNULL);
(yyval.ll_node)->type = make_type_node(t, q);
}
#line 8068 "gram1.tab.c" /* yacc.c:1646 */
break;
case 412:
#line 3568 "gram1.y" /* yacc.c:1646 */
{ PTR_TYPE t;
(yyval.ll_node) = make_llnd(fi,STRING_VAL, LLNULL, LLNULL, SMNULL);
(yyval.ll_node)->entry.string_val = copys(yytext);
if(yyquote=='\"')
t = global_string_2;
else
t = global_string;
(yyval.ll_node)->type = make_type_node(t, (yyvsp[-2].ll_node));
}
#line 8082 "gram1.tab.c" /* yacc.c:1646 */
break;
case 413:
#line 3578 "gram1.y" /* yacc.c:1646 */
{ PTR_TYPE t;
(yyval.ll_node) = make_llnd(fi,STRING_VAL, LLNULL, LLNULL, SMNULL);
(yyval.ll_node)->entry.string_val = copys(yytext);
if(yyquote=='\"')
t = global_string_2;
else
t = global_string;
(yyval.ll_node)->type = make_type_node(t, (yyvsp[-2].ll_node));
}
#line 8096 "gram1.tab.c" /* yacc.c:1646 */
break;
case 414:
#line 3591 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,COMPLEX_VAL, (yyvsp[-3].ll_node), (yyvsp[-1].ll_node), SMNULL);
(yyval.ll_node)->type = global_complex;
}
#line 8105 "gram1.tab.c" /* yacc.c:1646 */
break;
case 415:
#line 3598 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
#line 8111 "gram1.tab.c" /* yacc.c:1646 */
break;
case 416:
#line 3600 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
#line 8117 "gram1.tab.c" /* yacc.c:1646 */
break;
case 417:
#line 3623 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,DDOT,(yyvsp[-2].ll_node),(yyvsp[0].ll_node),SMNULL); }
#line 8123 "gram1.tab.c" /* yacc.c:1646 */
break;
case 418:
#line 3625 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,DDOT,(yyvsp[-1].ll_node),LLNULL,SMNULL); }
#line 8129 "gram1.tab.c" /* yacc.c:1646 */
break;
case 419:
#line 3627 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,DDOT,make_llnd(fi,DDOT,(yyvsp[-4].ll_node),(yyvsp[-2].ll_node),SMNULL),(yyvsp[0].ll_node),SMNULL); }
#line 8135 "gram1.tab.c" /* yacc.c:1646 */
break;
case 420:
#line 3629 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,DDOT,make_llnd(fi,DDOT,(yyvsp[-3].ll_node),LLNULL,SMNULL),(yyvsp[0].ll_node),SMNULL); }
#line 8141 "gram1.tab.c" /* yacc.c:1646 */
break;
case 421:
#line 3631 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,DDOT, make_llnd(fi,DDOT,LLNULL,(yyvsp[-2].ll_node),SMNULL),(yyvsp[0].ll_node),SMNULL); }
#line 8147 "gram1.tab.c" /* yacc.c:1646 */
break;
case 422:
#line 3633 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,DDOT,make_llnd(fi,DDOT,LLNULL,LLNULL,SMNULL),(yyvsp[0].ll_node),SMNULL); }
#line 8153 "gram1.tab.c" /* yacc.c:1646 */
break;
case 423:
#line 3635 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,DDOT,LLNULL,(yyvsp[0].ll_node),SMNULL); }
#line 8159 "gram1.tab.c" /* yacc.c:1646 */
break;
case 424:
#line 3637 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,DDOT,LLNULL,LLNULL,SMNULL); }
#line 8165 "gram1.tab.c" /* yacc.c:1646 */
break;
case 425:
#line 3640 "gram1.y" /* yacc.c:1646 */
{in_vec=YES;}
#line 8171 "gram1.tab.c" /* yacc.c:1646 */
break;
case 426:
#line 3640 "gram1.y" /* yacc.c:1646 */
{in_vec=NO;}
#line 8177 "gram1.tab.c" /* yacc.c:1646 */
break;
case 427:
#line 3641 "gram1.y" /* yacc.c:1646 */
{ PTR_TYPE array_type;
(yyval.ll_node) = make_llnd (fi,CONSTRUCTOR_REF,(yyvsp[-2].ll_node),LLNULL,SMNULL);
/*$$->type = $2->type;*/ /*28.02.03*/
array_type = make_type(fi, T_ARRAY);
array_type->entry.ar_decl.num_dimensions = 1;
if((yyvsp[-2].ll_node)->type->variant == T_ARRAY)
array_type->entry.ar_decl.base_type = (yyvsp[-2].ll_node)->type->entry.ar_decl.base_type;
else
array_type->entry.ar_decl.base_type = (yyvsp[-2].ll_node)->type;
(yyval.ll_node)->type = array_type;
}
#line 8193 "gram1.tab.c" /* yacc.c:1646 */
break;
case 428:
#line 3655 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
#line 8199 "gram1.tab.c" /* yacc.c:1646 */
break;
case 429:
#line 3657 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
#line 8205 "gram1.tab.c" /* yacc.c:1646 */
break;
case 430:
#line 3680 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); }
#line 8211 "gram1.tab.c" /* yacc.c:1646 */
break;
case 431:
#line 3682 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-3].ll_node), (yyvsp[0].ll_node), EXPR_LIST); endioctl(); }
#line 8217 "gram1.tab.c" /* yacc.c:1646 */
break;
case 432:
#line 3684 "gram1.y" /* yacc.c:1646 */
{ stat_alloc = make_llnd(fi, SPEC_PAIR, (yyvsp[-1].ll_node), (yyvsp[0].ll_node), SMNULL);
endioctl();
}
#line 8225 "gram1.tab.c" /* yacc.c:1646 */
break;
case 433:
#line 3700 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); }
#line 8231 "gram1.tab.c" /* yacc.c:1646 */
break;
case 434:
#line 3702 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-3].ll_node), (yyvsp[0].ll_node), EXPR_LIST); endioctl(); }
#line 8237 "gram1.tab.c" /* yacc.c:1646 */
break;
case 435:
#line 3704 "gram1.y" /* yacc.c:1646 */
{ stat_alloc = make_llnd(fi, SPEC_PAIR, (yyvsp[-1].ll_node), (yyvsp[0].ll_node), SMNULL);
endioctl();
}
#line 8245 "gram1.tab.c" /* yacc.c:1646 */
break;
case 436:
#line 3717 "gram1.y" /* yacc.c:1646 */
{stat_alloc = LLNULL;}
#line 8251 "gram1.tab.c" /* yacc.c:1646 */
break;
case 437:
#line 3721 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); }
#line 8257 "gram1.tab.c" /* yacc.c:1646 */
break;
case 438:
#line 3723 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); }
#line 8263 "gram1.tab.c" /* yacc.c:1646 */
break;
case 439:
#line 3731 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = (yyvsp[0].bf_node); }
#line 8269 "gram1.tab.c" /* yacc.c:1646 */
break;
case 440:
#line 3733 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = (yyvsp[0].bf_node); }
#line 8275 "gram1.tab.c" /* yacc.c:1646 */
break;
case 441:
#line 3735 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = (yyvsp[0].bf_node); }
#line 8281 "gram1.tab.c" /* yacc.c:1646 */
break;
case 442:
#line 3737 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = (yyvsp[0].bf_node);
(yyval.bf_node)->entry.Template.ll_ptr3 = (yyvsp[-1].ll_node);
}
#line 8290 "gram1.tab.c" /* yacc.c:1646 */
break;
case 443:
#line 3791 "gram1.y" /* yacc.c:1646 */
{ PTR_BFND biff;
(yyval.bf_node) = get_bfnd(fi,CONTROL_END, SMNULL, LLNULL, LLNULL, LLNULL);
bind();
biff = cur_scope();
if ((biff->variant == FUNC_HEDR) || (biff->variant == PROC_HEDR)
|| (biff->variant == PROS_HEDR)
|| (biff->variant == PROG_HEDR)
|| (biff->variant == BLOCK_DATA)) {
if(biff->control_parent == global_bfnd) position = IN_OUTSIDE;
else if(!is_interface_stat(biff->control_parent)) position++;
} else if (biff->variant == MODULE_STMT)
position = IN_OUTSIDE;
else err("Unexpected END statement read", 52);
/* FB ADDED set the control parent so the empty function unparse right*/
if ((yyval.bf_node))
(yyval.bf_node)->control_parent = biff;
delete_beyond_scope_level(pred_bfnd);
}
#line 8314 "gram1.tab.c" /* yacc.c:1646 */
break;
case 444:
#line 3813 "gram1.y" /* yacc.c:1646 */
{
make_extend((yyvsp[0].symbol));
(yyval.bf_node) = BFNULL;
/* delete_beyond_scope_level(pred_bfnd); */
}
#line 8324 "gram1.tab.c" /* yacc.c:1646 */
break;
case 445:
#line 3826 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,CONTROL_END, SMNULL, LLNULL, LLNULL, LLNULL);
bind();
delete_beyond_scope_level(pred_bfnd);
position = IN_OUTSIDE;
}
#line 8334 "gram1.tab.c" /* yacc.c:1646 */
break;
case 446:
#line 3835 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = (yyvsp[0].bf_node); }
#line 8340 "gram1.tab.c" /* yacc.c:1646 */
break;
case 447:
#line 3838 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = (yyvsp[0].bf_node);
(yyval.bf_node)->entry.Template.ll_ptr3 = (yyvsp[-1].ll_node);
}
#line 8349 "gram1.tab.c" /* yacc.c:1646 */
break;
case 448:
#line 3888 "gram1.y" /* yacc.c:1646 */
{ thiswasbranch = NO;
(yyvsp[-1].bf_node)->variant = LOGIF_NODE;
(yyval.bf_node) = make_logif((yyvsp[-1].bf_node), (yyvsp[0].bf_node));
set_blobs((yyvsp[-1].bf_node), pred_bfnd, SAME_GROUP);
}
#line 8359 "gram1.tab.c" /* yacc.c:1646 */
break;
case 449:
#line 3894 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = (yyvsp[-1].bf_node);
set_blobs((yyval.bf_node), pred_bfnd, NEW_GROUP1);
}
#line 8368 "gram1.tab.c" /* yacc.c:1646 */
break;
case 450:
#line 3899 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = (yyvsp[-1].bf_node);
(yyval.bf_node)->entry.Template.ll_ptr3 = (yyvsp[-2].ll_node);
set_blobs((yyval.bf_node), pred_bfnd, NEW_GROUP1);
}
#line 8378 "gram1.tab.c" /* yacc.c:1646 */
break;
case 451:
#line 3917 "gram1.y" /* yacc.c:1646 */
{ make_elseif((yyvsp[-3].ll_node),(yyvsp[0].symbol)); lastwasbranch = NO; (yyval.bf_node) = BFNULL;}
#line 8384 "gram1.tab.c" /* yacc.c:1646 */
break;
case 452:
#line 3919 "gram1.y" /* yacc.c:1646 */
{ make_else((yyvsp[0].symbol)); lastwasbranch = NO; (yyval.bf_node) = BFNULL; }
#line 8390 "gram1.tab.c" /* yacc.c:1646 */
break;
case 453:
#line 3921 "gram1.y" /* yacc.c:1646 */
{ make_endif((yyvsp[0].symbol)); (yyval.bf_node) = BFNULL; }
#line 8396 "gram1.tab.c" /* yacc.c:1646 */
break;
case 454:
#line 3923 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = (yyvsp[0].bf_node); }
#line 8402 "gram1.tab.c" /* yacc.c:1646 */
break;
case 455:
#line 3925 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi, CONTAINS_STMT, SMNULL, LLNULL, LLNULL, LLNULL); }
#line 8408 "gram1.tab.c" /* yacc.c:1646 */
break;
case 456:
#line 3928 "gram1.y" /* yacc.c:1646 */
{ thiswasbranch = NO;
(yyvsp[-1].bf_node)->variant = FORALL_STAT;
(yyval.bf_node) = make_logif((yyvsp[-1].bf_node), (yyvsp[0].bf_node));
set_blobs((yyvsp[-1].bf_node), pred_bfnd, SAME_GROUP);
}
#line 8418 "gram1.tab.c" /* yacc.c:1646 */
break;
case 457:
#line 3934 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = (yyvsp[0].bf_node); }
#line 8424 "gram1.tab.c" /* yacc.c:1646 */
break;
case 458:
#line 3936 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = (yyvsp[0].bf_node); (yyval.bf_node)->entry.Template.ll_ptr3 = (yyvsp[-1].ll_node);}
#line 8430 "gram1.tab.c" /* yacc.c:1646 */
break;
case 459:
#line 3938 "gram1.y" /* yacc.c:1646 */
{ make_endforall((yyvsp[0].symbol)); (yyval.bf_node) = BFNULL; }
#line 8436 "gram1.tab.c" /* yacc.c:1646 */
break;
case 460:
#line 3941 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = (yyvsp[0].bf_node); }
#line 8442 "gram1.tab.c" /* yacc.c:1646 */
break;
case 461:
#line 3943 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = (yyvsp[0].bf_node); }
#line 8448 "gram1.tab.c" /* yacc.c:1646 */
break;
case 462:
#line 3945 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = (yyvsp[0].bf_node); }
#line 8454 "gram1.tab.c" /* yacc.c:1646 */
break;
case 463:
#line 3972 "gram1.y" /* yacc.c:1646 */
{
/* if($5 && $5->labdefined)
execerr("no backward DO loops", (char *)NULL); */
(yyval.bf_node) = make_do(WHILE_NODE, LBNULL, SMNULL, (yyvsp[-1].ll_node), LLNULL, LLNULL);
/*$$->entry.Template.ll_ptr3 = $1;*/
}
#line 8465 "gram1.tab.c" /* yacc.c:1646 */
break;
case 464:
#line 3981 "gram1.y" /* yacc.c:1646 */
{
if( (yyvsp[-3].label) && (yyvsp[-3].label)->labdefined)
err("No backward DO loops", 46);
(yyval.bf_node) = make_do(WHILE_NODE, (yyvsp[-3].label), SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL);
}
#line 8475 "gram1.tab.c" /* yacc.c:1646 */
break;
case 465:
#line 3989 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = LLNULL; }
#line 8481 "gram1.tab.c" /* yacc.c:1646 */
break;
case 466:
#line 3991 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[-1].ll_node);}
#line 8487 "gram1.tab.c" /* yacc.c:1646 */
break;
case 467:
#line 3993 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[-1].ll_node);}
#line 8493 "gram1.tab.c" /* yacc.c:1646 */
break;
case 468:
#line 3998 "gram1.y" /* yacc.c:1646 */
{
if( (yyvsp[-7].label) && (yyvsp[-7].label)->labdefined)
err("No backward DO loops", 46);
(yyval.bf_node) = make_do(FOR_NODE, (yyvsp[-7].label), (yyvsp[-4].symbol), (yyvsp[-2].ll_node), (yyvsp[0].ll_node), LLNULL);
}
#line 8503 "gram1.tab.c" /* yacc.c:1646 */
break;
case 469:
#line 4005 "gram1.y" /* yacc.c:1646 */
{
if( (yyvsp[-9].label) && (yyvsp[-9].label)->labdefined)
err("No backward DO loops", 46);
(yyval.bf_node) = make_do(FOR_NODE, (yyvsp[-9].label), (yyvsp[-6].symbol), (yyvsp[-4].ll_node), (yyvsp[-2].ll_node), (yyvsp[0].ll_node));
}
#line 8513 "gram1.tab.c" /* yacc.c:1646 */
break;
case 470:
#line 4013 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi, CASE_NODE, (yyvsp[0].symbol), (yyvsp[-1].ll_node), LLNULL, LLNULL); }
#line 8519 "gram1.tab.c" /* yacc.c:1646 */
break;
case 471:
#line 4015 "gram1.y" /* yacc.c:1646 */
{ /*PTR_LLND p;*/
/* p = make_llnd(fi, DEFAULT, LLNULL, LLNULL, SMNULL); */
(yyval.bf_node) = get_bfnd(fi, DEFAULT_NODE, (yyvsp[0].symbol), LLNULL, LLNULL, LLNULL); }
#line 8527 "gram1.tab.c" /* yacc.c:1646 */
break;
case 472:
#line 4019 "gram1.y" /* yacc.c:1646 */
{ make_endselect((yyvsp[0].symbol)); (yyval.bf_node) = BFNULL; }
#line 8533 "gram1.tab.c" /* yacc.c:1646 */
break;
case 473:
#line 4022 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi, SWITCH_NODE, SMNULL, (yyvsp[-1].ll_node), LLNULL, LLNULL) ; }
#line 8539 "gram1.tab.c" /* yacc.c:1646 */
break;
case 474:
#line 4024 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi, SWITCH_NODE, SMNULL, (yyvsp[-1].ll_node), LLNULL, (yyvsp[-7].ll_node)) ; }
#line 8545 "gram1.tab.c" /* yacc.c:1646 */
break;
case 475:
#line 4028 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[-1].ll_node); }
#line 8551 "gram1.tab.c" /* yacc.c:1646 */
break;
case 476:
#line 4034 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
#line 8557 "gram1.tab.c" /* yacc.c:1646 */
break;
case 477:
#line 4036 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi, DDOT, (yyvsp[-1].ll_node), LLNULL, SMNULL); }
#line 8563 "gram1.tab.c" /* yacc.c:1646 */
break;
case 478:
#line 4038 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi, DDOT, LLNULL, (yyvsp[0].ll_node), SMNULL); }
#line 8569 "gram1.tab.c" /* yacc.c:1646 */
break;
case 479:
#line 4040 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi, DDOT, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), SMNULL); }
#line 8575 "gram1.tab.c" /* yacc.c:1646 */
break;
case 480:
#line 4044 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi, EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL); }
#line 8581 "gram1.tab.c" /* yacc.c:1646 */
break;
case 481:
#line 4046 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND p;
p = make_llnd(fi, EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
add_to_lowLevelList(p, (yyvsp[-2].ll_node));
}
#line 8591 "gram1.tab.c" /* yacc.c:1646 */
break;
case 482:
#line 4054 "gram1.y" /* yacc.c:1646 */
{ (yyval.symbol) = SMNULL; }
#line 8597 "gram1.tab.c" /* yacc.c:1646 */
break;
case 483:
#line 4056 "gram1.y" /* yacc.c:1646 */
{ (yyval.symbol) = make_local_entity((yyvsp[0].hash_entry), CONSTRUCT_NAME, global_default,
LOCAL); }
#line 8604 "gram1.tab.c" /* yacc.c:1646 */
break;
case 484:
#line 4062 "gram1.y" /* yacc.c:1646 */
{(yyval.hash_entry) = HSNULL;}
#line 8610 "gram1.tab.c" /* yacc.c:1646 */
break;
case 485:
#line 4064 "gram1.y" /* yacc.c:1646 */
{ (yyval.hash_entry) = (yyvsp[0].hash_entry);}
#line 8616 "gram1.tab.c" /* yacc.c:1646 */
break;
case 486:
#line 4068 "gram1.y" /* yacc.c:1646 */
{(yyval.hash_entry) = look_up_sym(yytext);}
#line 8622 "gram1.tab.c" /* yacc.c:1646 */
break;
case 487:
#line 4072 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB s;
s = make_local_entity( (yyvsp[-1].hash_entry), CONSTRUCT_NAME, global_default, LOCAL);
(yyval.ll_node) = make_llnd(fi, VAR_REF, LLNULL, LLNULL, s);
}
#line 8631 "gram1.tab.c" /* yacc.c:1646 */
break;
case 488:
#line 4093 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = make_if((yyvsp[-1].ll_node)); }
#line 8637 "gram1.tab.c" /* yacc.c:1646 */
break;
case 489:
#line 4096 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = make_forall((yyvsp[-2].ll_node),(yyvsp[-1].ll_node)); }
#line 8643 "gram1.tab.c" /* yacc.c:1646 */
break;
case 490:
#line 4100 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi, EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL); }
#line 8649 "gram1.tab.c" /* yacc.c:1646 */
break;
case 491:
#line 4102 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND p;
p = make_llnd(fi, EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
add_to_lowLevelList(p, (yyvsp[-2].ll_node));
}
#line 8658 "gram1.tab.c" /* yacc.c:1646 */
break;
case 492:
#line 4109 "gram1.y" /* yacc.c:1646 */
{(yyval.ll_node) = make_llnd(fi, FORALL_OP, (yyvsp[0].ll_node), LLNULL, (yyvsp[-2].symbol)); }
#line 8664 "gram1.tab.c" /* yacc.c:1646 */
break;
case 493:
#line 4113 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node)=LLNULL;}
#line 8670 "gram1.tab.c" /* yacc.c:1646 */
break;
case 494:
#line 4115 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node)=(yyvsp[0].ll_node);}
#line 8676 "gram1.tab.c" /* yacc.c:1646 */
break;
case 495:
#line 4126 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB s;
s = (yyvsp[0].hash_entry)->id_attr;
if (!s || s->variant == DEFAULT)
{
s = make_scalar((yyvsp[0].hash_entry), TYNULL, LOCAL);
s->decl = SOFT;
}
(yyval.symbol) = s;
}
#line 8690 "gram1.tab.c" /* yacc.c:1646 */
break;
case 496:
#line 4139 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB s;
PTR_LLND l;
int vrnt;
/* s = make_scalar($1, TYNULL, LOCAL);*/ /*16.02.03*/
s = (yyvsp[-4].symbol);
if (s->variant != CONST_NAME) {
if(in_vec)
vrnt=SEQ;
else
vrnt=DDOT;
l = make_llnd(fi, SEQ, make_llnd(fi, vrnt, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), SMNULL),
LLNULL, SMNULL);
(yyval.ll_node) = make_llnd(fi,IOACCESS, LLNULL, l, s);
do_name_err = NO;
}
else {
err("Symbolic constant not allowed as DO variable", 47);
do_name_err = YES;
}
}
#line 8716 "gram1.tab.c" /* yacc.c:1646 */
break;
case 497:
#line 4162 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB s;
PTR_LLND l;
int vrnt;
/*s = make_scalar($1, TYNULL, LOCAL);*/ /*16.02.03*/
s = (yyvsp[-6].symbol);
if( s->variant != CONST_NAME ) {
if(in_vec)
vrnt=SEQ;
else
vrnt=DDOT;
l = make_llnd(fi, SEQ, make_llnd(fi, vrnt, (yyvsp[-4].ll_node), (yyvsp[-2].ll_node), SMNULL), (yyvsp[0].ll_node),
SMNULL);
(yyval.ll_node) = make_llnd(fi,IOACCESS, LLNULL, l, s);
do_name_err = NO;
}
else {
err("Symbolic constant not allowed as DO variable", 47);
do_name_err = YES;
}
}
#line 8741 "gram1.tab.c" /* yacc.c:1646 */
break;
case 498:
#line 4185 "gram1.y" /* yacc.c:1646 */
{ (yyval.label) = LBNULL; }
#line 8747 "gram1.tab.c" /* yacc.c:1646 */
break;
case 499:
#line 4187 "gram1.y" /* yacc.c:1646 */
{
(yyval.label) = make_label_node(fi,convci(yyleng, yytext));
(yyval.label)->scope = cur_scope();
}
#line 8756 "gram1.tab.c" /* yacc.c:1646 */
break;
case 500:
#line 4194 "gram1.y" /* yacc.c:1646 */
{ make_endwhere((yyvsp[0].symbol)); (yyval.bf_node) = BFNULL; }
#line 8762 "gram1.tab.c" /* yacc.c:1646 */
break;
case 501:
#line 4196 "gram1.y" /* yacc.c:1646 */
{ make_elsewhere((yyvsp[0].symbol)); lastwasbranch = NO; (yyval.bf_node) = BFNULL; }
#line 8768 "gram1.tab.c" /* yacc.c:1646 */
break;
case 502:
#line 4198 "gram1.y" /* yacc.c:1646 */
{ make_elsewhere_mask((yyvsp[-2].ll_node),(yyvsp[0].symbol)); lastwasbranch = NO; (yyval.bf_node) = BFNULL; }
#line 8774 "gram1.tab.c" /* yacc.c:1646 */
break;
case 503:
#line 4200 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi, WHERE_BLOCK_STMT, SMNULL, (yyvsp[-1].ll_node), LLNULL, LLNULL); }
#line 8780 "gram1.tab.c" /* yacc.c:1646 */
break;
case 504:
#line 4202 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi, WHERE_BLOCK_STMT, SMNULL, (yyvsp[-1].ll_node), LLNULL, (yyvsp[-5].ll_node)); }
#line 8786 "gram1.tab.c" /* yacc.c:1646 */
break;
case 505:
#line 4207 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND p, r;
PTR_SYMB s1, s2 = SMNULL, s3, arg_list;
PTR_HASH hash_entry;
/* if (just_look_up_sym("=") != HSNULL) {
p = intrinsic_op_node("=", EQUAL, $2, $4);
$$ = get_bfnd(fi, OVERLOADED_ASSIGN_STAT, SMNULL, p, $2, $4);
}
else */ if ((yyvsp[-2].ll_node)->variant == FUNC_CALL) {
if(parstate==INEXEC){
err("Declaration among executables", 30);
/* $$=BFNULL;*/
(yyval.bf_node) = get_bfnd(fi,STMTFN_STAT, SMNULL, (yyvsp[-2].ll_node), LLNULL, LLNULL);
}
else {
(yyvsp[-2].ll_node)->variant = STMTFN_DECL;
/* $2->entry.Template.ll_ptr2 = $4; */
if( (yyvsp[-2].ll_node)->entry.Template.ll_ptr1) {
r = (yyvsp[-2].ll_node)->entry.Template.ll_ptr1->entry.Template.ll_ptr1;
if(r->variant != VAR_REF && r->variant != ARRAY_REF){
err("A dummy argument of a statement function must be a scalar identifier", 333);
s1 = SMNULL;
}
else
s1 = r ->entry.Template.symbol;
} else
s1 = SMNULL;
if (s1)
s1->scope = cur_scope();
(yyval.bf_node) = get_bfnd(fi,STMTFN_STAT, SMNULL, (yyvsp[-2].ll_node), LLNULL, LLNULL);
add_scope_level((yyval.bf_node), NO);
arg_list = SMNULL;
if (s1)
{
/*arg_list = SMNULL;*/
p = (yyvsp[-2].ll_node)->entry.Template.ll_ptr1;
while (p != LLNULL)
{
/* if (p->entry.Template.ll_ptr1->variant != VAR_REF) {
errstr("cftn.gram:1: illegal statement function %s.", $2->entry.Template.symbol->ident);
break;
}
*/
r = p->entry.Template.ll_ptr1;
if(r->variant != VAR_REF && r->variant != ARRAY_REF){
err("A dummy argument of a statement function must be a scalar identifier", 333);
break;
}
hash_entry = look_up_sym(r->entry.Template.symbol->parent->ident);
s3 = make_scalar(hash_entry, s1->type, IO);
replace_symbol_in_expr(s3,(yyvsp[0].ll_node));
if (arg_list == SMNULL)
s2 = arg_list = s3;
else
{
s2->id_list = s3;
s2 = s3;
}
p = p->entry.Template.ll_ptr2;
}
}
(yyvsp[-2].ll_node)->entry.Template.ll_ptr1 = (yyvsp[0].ll_node);
install_param_list((yyvsp[-2].ll_node)->entry.Template.symbol,
arg_list, LLNULL, FUNCTION_NAME);
delete_beyond_scope_level((yyval.bf_node));
/* else
errstr("cftn.gram: Illegal statement function declaration %s.", $2->entry.Template.symbol->ident); */
}
}
else {
(yyval.bf_node) = get_bfnd(fi,ASSIGN_STAT,SMNULL, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), LLNULL);
parstate = INEXEC;
}
}
#line 8866 "gram1.tab.c" /* yacc.c:1646 */
break;
case 506:
#line 4283 "gram1.y" /* yacc.c:1646 */
{ /*PTR_SYMB s;*/
/*s = make_scalar($2, TYNULL, LOCAL);*/
(yyval.bf_node) = get_bfnd(fi, POINTER_ASSIGN_STAT, SMNULL, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), LLNULL);
}
#line 8876 "gram1.tab.c" /* yacc.c:1646 */
break;
case 507:
#line 4295 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB p;
p = make_scalar((yyvsp[0].hash_entry), TYNULL, LOCAL);
p->variant = LABEL_VAR;
(yyval.bf_node) = get_bfnd(fi,ASSLAB_STAT, p, (yyvsp[-2].ll_node),LLNULL,LLNULL);
}
#line 8887 "gram1.tab.c" /* yacc.c:1646 */
break;
case 508:
#line 4302 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,CONT_STAT,SMNULL,LLNULL,LLNULL,LLNULL); }
#line 8893 "gram1.tab.c" /* yacc.c:1646 */
break;
case 510:
#line 4305 "gram1.y" /* yacc.c:1646 */
{ inioctl = NO; }
#line 8899 "gram1.tab.c" /* yacc.c:1646 */
break;
case 511:
#line 4307 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND p;
p = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
p = make_llnd(fi,EXPR_LIST, (yyvsp[-2].ll_node), p, SMNULL);
(yyval.bf_node)= get_bfnd(fi,ARITHIF_NODE, SMNULL, (yyvsp[-6].ll_node),
make_llnd(fi,EXPR_LIST, (yyvsp[-4].ll_node), p, SMNULL), LLNULL);
thiswasbranch = YES;
}
#line 8912 "gram1.tab.c" /* yacc.c:1646 */
break;
case 512:
#line 4316 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = subroutine_call((yyvsp[0].symbol), LLNULL, LLNULL, PLAIN);
/* match_parameters($1, LLNULL);
$$= get_bfnd(fi,PROC_STAT, $1, LLNULL, LLNULL, LLNULL);
*/ endioctl();
}
#line 8923 "gram1.tab.c" /* yacc.c:1646 */
break;
case 513:
#line 4323 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = subroutine_call((yyvsp[-2].symbol), LLNULL, LLNULL, PLAIN);
/* match_parameters($1, LLNULL);
$$= get_bfnd(fi,PROC_STAT,$1,LLNULL,LLNULL,LLNULL);
*/ endioctl();
}
#line 8934 "gram1.tab.c" /* yacc.c:1646 */
break;
case 514:
#line 4330 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = subroutine_call((yyvsp[-3].symbol), (yyvsp[-1].ll_node), LLNULL, PLAIN);
/* match_parameters($1, $3);
$$= get_bfnd(fi,PROC_STAT,$1,$3,LLNULL,LLNULL);
*/ endioctl();
}
#line 8945 "gram1.tab.c" /* yacc.c:1646 */
break;
case 515:
#line 4338 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = get_bfnd(fi,RETURN_STAT,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL);
thiswasbranch = YES;
}
#line 8954 "gram1.tab.c" /* yacc.c:1646 */
break;
case 516:
#line 4343 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = get_bfnd(fi,(yyvsp[-2].token),SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL);
thiswasbranch = ((yyvsp[-2].token) == STOP_STAT);
}
#line 8963 "gram1.tab.c" /* yacc.c:1646 */
break;
case 517:
#line 4348 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi, CYCLE_STMT, (yyvsp[0].symbol), LLNULL, LLNULL, LLNULL); }
#line 8969 "gram1.tab.c" /* yacc.c:1646 */
break;
case 518:
#line 4351 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi, EXIT_STMT, (yyvsp[0].symbol), LLNULL, LLNULL, LLNULL); }
#line 8975 "gram1.tab.c" /* yacc.c:1646 */
break;
case 519:
#line 4354 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi, ALLOCATE_STMT, SMNULL, (yyvsp[-1].ll_node), stat_alloc, LLNULL); }
#line 8981 "gram1.tab.c" /* yacc.c:1646 */
break;
case 520:
#line 4357 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi, DEALLOCATE_STMT, SMNULL, (yyvsp[-1].ll_node), stat_alloc , LLNULL); }
#line 8987 "gram1.tab.c" /* yacc.c:1646 */
break;
case 521:
#line 4360 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi, NULLIFY_STMT, SMNULL, (yyvsp[-1].ll_node), LLNULL, LLNULL); }
#line 8993 "gram1.tab.c" /* yacc.c:1646 */
break;
case 522:
#line 4363 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi, WHERE_NODE, SMNULL, (yyvsp[-4].ll_node), (yyvsp[-2].ll_node), (yyvsp[0].ll_node)); }
#line 8999 "gram1.tab.c" /* yacc.c:1646 */
break;
case 523:
#line 4381 "gram1.y" /* yacc.c:1646 */
{(yyval.ll_node) = LLNULL;}
#line 9005 "gram1.tab.c" /* yacc.c:1646 */
break;
case 524:
#line 4385 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node)=get_bfnd(fi,GOTO_NODE,SMNULL,LLNULL,LLNULL,(PTR_LLND)(yyvsp[0].ll_node));
thiswasbranch = YES;
}
#line 9014 "gram1.tab.c" /* yacc.c:1646 */
break;
case 525:
#line 4390 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB p;
if((yyvsp[0].hash_entry)->id_attr)
p = (yyvsp[0].hash_entry)->id_attr;
else {
p = make_scalar((yyvsp[0].hash_entry), TYNULL, LOCAL);
p->variant = LABEL_VAR;
}
if(p->variant == LABEL_VAR) {
(yyval.bf_node) = get_bfnd(fi,ASSGOTO_NODE,p,LLNULL,LLNULL,LLNULL);
thiswasbranch = YES;
}
else {
err("Must go to assigned variable", 48);
(yyval.bf_node) = BFNULL;
}
}
#line 9037 "gram1.tab.c" /* yacc.c:1646 */
break;
case 526:
#line 4409 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB p;
if((yyvsp[-4].hash_entry)->id_attr)
p = (yyvsp[-4].hash_entry)->id_attr;
else {
p = make_scalar((yyvsp[-4].hash_entry), TYNULL, LOCAL);
p->variant = LABEL_VAR;
}
if (p->variant == LABEL_VAR) {
(yyval.bf_node) = get_bfnd(fi,ASSGOTO_NODE,p,(yyvsp[-1].ll_node),LLNULL,LLNULL);
thiswasbranch = YES;
}
else {
err("Must go to assigned variable",48);
(yyval.bf_node) = BFNULL;
}
}
#line 9060 "gram1.tab.c" /* yacc.c:1646 */
break;
case 527:
#line 4428 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,COMGOTO_NODE, SMNULL, (yyvsp[-3].ll_node), (yyvsp[0].ll_node), LLNULL); }
#line 9066 "gram1.tab.c" /* yacc.c:1646 */
break;
case 530:
#line 4436 "gram1.y" /* yacc.c:1646 */
{ (yyval.symbol) = make_procedure((yyvsp[-1].hash_entry), LOCAL); }
#line 9072 "gram1.tab.c" /* yacc.c:1646 */
break;
case 531:
#line 4440 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST);
endioctl();
}
#line 9081 "gram1.tab.c" /* yacc.c:1646 */
break;
case 532:
#line 4445 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = set_ll_list((yyvsp[-3].ll_node), (yyvsp[0].ll_node), EXPR_LIST);
endioctl();
}
#line 9090 "gram1.tab.c" /* yacc.c:1646 */
break;
case 533:
#line 4452 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
#line 9096 "gram1.tab.c" /* yacc.c:1646 */
break;
case 534:
#line 4454 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi, KEYWORD_ARG, (yyvsp[-1].ll_node), (yyvsp[0].ll_node), SMNULL); }
#line 9102 "gram1.tab.c" /* yacc.c:1646 */
break;
case 535:
#line 4456 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,LABEL_ARG,(yyvsp[0].ll_node),LLNULL,SMNULL); }
#line 9108 "gram1.tab.c" /* yacc.c:1646 */
break;
case 536:
#line 4459 "gram1.y" /* yacc.c:1646 */
{ (yyval.token) = PAUSE_NODE; }
#line 9114 "gram1.tab.c" /* yacc.c:1646 */
break;
case 537:
#line 4460 "gram1.y" /* yacc.c:1646 */
{ (yyval.token) = STOP_STAT; }
#line 9120 "gram1.tab.c" /* yacc.c:1646 */
break;
case 538:
#line 4471 "gram1.y" /* yacc.c:1646 */
{ if(parstate == OUTSIDE)
{ PTR_BFND p;
p = get_bfnd(fi,PROG_HEDR, make_program(look_up_sym("_MAIN")), LLNULL, LLNULL, LLNULL);
set_blobs(p, global_bfnd, NEW_GROUP1);
add_scope_level(p, NO);
position = IN_PROC;
}
if(parstate < INDATA) enddcl();
parstate = INEXEC;
yystno = 0;
}
#line 9137 "gram1.tab.c" /* yacc.c:1646 */
break;
case 539:
#line 4486 "gram1.y" /* yacc.c:1646 */
{ intonly = YES; }
#line 9143 "gram1.tab.c" /* yacc.c:1646 */
break;
case 540:
#line 4490 "gram1.y" /* yacc.c:1646 */
{ intonly = NO; }
#line 9149 "gram1.tab.c" /* yacc.c:1646 */
break;
case 541:
#line 4498 "gram1.y" /* yacc.c:1646 */
{ (yyvsp[-1].bf_node)->entry.Template.ll_ptr2 = (yyvsp[0].ll_node);
(yyval.bf_node) = (yyvsp[-1].bf_node); }
#line 9156 "gram1.tab.c" /* yacc.c:1646 */
break;
case 542:
#line 4501 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND p, q = LLNULL;
q = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
q->entry.string_val = (char *)"unit";
q->type = global_string;
p = make_llnd(fi, SPEC_PAIR, q, (yyvsp[0].ll_node), SMNULL);
(yyvsp[-1].bf_node)->entry.Template.ll_ptr2 = p;
endioctl();
(yyval.bf_node) = (yyvsp[-1].bf_node); }
#line 9170 "gram1.tab.c" /* yacc.c:1646 */
break;
case 543:
#line 4511 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND p, q, r;
p = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
p->entry.string_val = (char *)"*";
p->type = global_string;
q = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
q->entry.string_val = (char *)"unit";
q->type = global_string;
r = make_llnd(fi, SPEC_PAIR, p, q, SMNULL);
(yyvsp[-1].bf_node)->entry.Template.ll_ptr2 = r;
endioctl();
(yyval.bf_node) = (yyvsp[-1].bf_node); }
#line 9187 "gram1.tab.c" /* yacc.c:1646 */
break;
case 544:
#line 4524 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND p, q, r;
p = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
p->entry.string_val = (char *)"**";
p->type = global_string;
q = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
q->entry.string_val = (char *)"unit";
q->type = global_string;
r = make_llnd(fi, SPEC_PAIR, p, q, SMNULL);
(yyvsp[-1].bf_node)->entry.Template.ll_ptr2 = r;
endioctl();
(yyval.bf_node) = (yyvsp[-1].bf_node); }
#line 9204 "gram1.tab.c" /* yacc.c:1646 */
break;
case 545:
#line 4537 "gram1.y" /* yacc.c:1646 */
{ (yyvsp[-1].bf_node)->entry.Template.ll_ptr2 = (yyvsp[0].ll_node);
(yyval.bf_node) = (yyvsp[-1].bf_node); }
#line 9211 "gram1.tab.c" /* yacc.c:1646 */
break;
case 546:
#line 4540 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = (yyvsp[0].bf_node); }
#line 9217 "gram1.tab.c" /* yacc.c:1646 */
break;
case 547:
#line 4542 "gram1.y" /* yacc.c:1646 */
{ (yyvsp[-1].bf_node)->entry.Template.ll_ptr2 = (yyvsp[0].ll_node);
(yyval.bf_node) = (yyvsp[-1].bf_node); }
#line 9224 "gram1.tab.c" /* yacc.c:1646 */
break;
case 548:
#line 4545 "gram1.y" /* yacc.c:1646 */
{ (yyvsp[-1].bf_node)->entry.Template.ll_ptr2 = (yyvsp[0].ll_node);
(yyval.bf_node) = (yyvsp[-1].bf_node); }
#line 9231 "gram1.tab.c" /* yacc.c:1646 */
break;
case 549:
#line 4548 "gram1.y" /* yacc.c:1646 */
{ (yyvsp[-2].bf_node)->entry.Template.ll_ptr2 = (yyvsp[-1].ll_node);
(yyvsp[-2].bf_node)->entry.Template.ll_ptr1 = (yyvsp[0].ll_node);
(yyval.bf_node) = (yyvsp[-2].bf_node); }
#line 9239 "gram1.tab.c" /* yacc.c:1646 */
break;
case 550:
#line 4552 "gram1.y" /* yacc.c:1646 */
{ (yyvsp[-3].bf_node)->entry.Template.ll_ptr2 = (yyvsp[-2].ll_node);
(yyvsp[-3].bf_node)->entry.Template.ll_ptr1 = (yyvsp[0].ll_node);
(yyval.bf_node) = (yyvsp[-3].bf_node); }
#line 9247 "gram1.tab.c" /* yacc.c:1646 */
break;
case 551:
#line 4561 "gram1.y" /* yacc.c:1646 */
{ (yyvsp[-1].bf_node)->entry.Template.ll_ptr2 = (yyvsp[0].ll_node);
(yyval.bf_node) = (yyvsp[-1].bf_node); }
#line 9254 "gram1.tab.c" /* yacc.c:1646 */
break;
case 552:
#line 4564 "gram1.y" /* yacc.c:1646 */
{ (yyvsp[-2].bf_node)->entry.Template.ll_ptr2 = (yyvsp[-1].ll_node);
(yyvsp[-2].bf_node)->entry.Template.ll_ptr1 = (yyvsp[0].ll_node);
(yyval.bf_node) = (yyvsp[-2].bf_node); }
#line 9262 "gram1.tab.c" /* yacc.c:1646 */
break;
case 553:
#line 4568 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = (yyvsp[0].bf_node); }
#line 9268 "gram1.tab.c" /* yacc.c:1646 */
break;
case 554:
#line 4570 "gram1.y" /* yacc.c:1646 */
{ (yyvsp[-2].bf_node)->entry.Template.ll_ptr1 = (yyvsp[0].ll_node);
(yyval.bf_node) = (yyvsp[-2].bf_node); }
#line 9275 "gram1.tab.c" /* yacc.c:1646 */
break;
case 555:
#line 4576 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = (yyvsp[-2].bf_node); }
#line 9281 "gram1.tab.c" /* yacc.c:1646 */
break;
case 556:
#line 4580 "gram1.y" /* yacc.c:1646 */
{(yyval.bf_node) = get_bfnd(fi, BACKSPACE_STAT, SMNULL, LLNULL, LLNULL, LLNULL);}
#line 9287 "gram1.tab.c" /* yacc.c:1646 */
break;
case 557:
#line 4582 "gram1.y" /* yacc.c:1646 */
{(yyval.bf_node) = get_bfnd(fi, REWIND_STAT, SMNULL, LLNULL, LLNULL, LLNULL);}
#line 9293 "gram1.tab.c" /* yacc.c:1646 */
break;
case 558:
#line 4584 "gram1.y" /* yacc.c:1646 */
{(yyval.bf_node) = get_bfnd(fi, ENDFILE_STAT, SMNULL, LLNULL, LLNULL, LLNULL);}
#line 9299 "gram1.tab.c" /* yacc.c:1646 */
break;
case 559:
#line 4591 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = (yyvsp[-2].bf_node); }
#line 9305 "gram1.tab.c" /* yacc.c:1646 */
break;
case 560:
#line 4595 "gram1.y" /* yacc.c:1646 */
{(yyval.bf_node) = get_bfnd(fi, OPEN_STAT, SMNULL, LLNULL, LLNULL, LLNULL);}
#line 9311 "gram1.tab.c" /* yacc.c:1646 */
break;
case 561:
#line 4597 "gram1.y" /* yacc.c:1646 */
{(yyval.bf_node) = get_bfnd(fi, CLOSE_STAT, SMNULL, LLNULL, LLNULL, LLNULL);}
#line 9317 "gram1.tab.c" /* yacc.c:1646 */
break;
case 562:
#line 4601 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi, INQUIRE_STAT, SMNULL, LLNULL, (yyvsp[0].ll_node), LLNULL);}
#line 9323 "gram1.tab.c" /* yacc.c:1646 */
break;
case 563:
#line 4603 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi, INQUIRE_STAT, SMNULL, (yyvsp[0].ll_node), (yyvsp[-1].ll_node), LLNULL);}
#line 9329 "gram1.tab.c" /* yacc.c:1646 */
break;
case 564:
#line 4607 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND p;
PTR_LLND q = LLNULL;
if ((yyvsp[0].ll_node)->variant == INT_VAL)
{
PTR_LABEL r;
r = make_label_node(fi, (long) (yyvsp[0].ll_node)->entry.ival);
r->scope = cur_scope();
p = make_llnd_label(fi, LABEL_REF, r);
}
else p = (yyvsp[0].ll_node);
q = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
q->entry.string_val = (char *)"fmt";
q->type = global_string;
(yyval.ll_node) = make_llnd(fi, SPEC_PAIR, q, p, SMNULL);
endioctl();
}
#line 9352 "gram1.tab.c" /* yacc.c:1646 */
break;
case 565:
#line 4626 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND p;
PTR_LLND q;
p = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
p->entry.string_val = (char *)"*";
p->type = global_string;
q = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
q->entry.string_val = (char *)"fmt";
q->type = global_string;
(yyval.ll_node) = make_llnd(fi, SPEC_PAIR, q, p, SMNULL);
endioctl();
}
#line 9369 "gram1.tab.c" /* yacc.c:1646 */
break;
case 566:
#line 4642 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND p;
p = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
p->entry.string_val = (char *)"unit";
p->type = global_string;
(yyval.ll_node) = make_llnd(fi, SPEC_PAIR, p, (yyvsp[-1].ll_node), SMNULL);
endioctl();
}
#line 9382 "gram1.tab.c" /* yacc.c:1646 */
break;
case 567:
#line 4653 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = (yyvsp[-1].ll_node);
endioctl();
}
#line 9391 "gram1.tab.c" /* yacc.c:1646 */
break;
case 568:
#line 4660 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node); endioctl();}
#line 9397 "gram1.tab.c" /* yacc.c:1646 */
break;
case 569:
#line 4662 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-3].ll_node), (yyvsp[0].ll_node), EXPR_LIST); endioctl();}
#line 9403 "gram1.tab.c" /* yacc.c:1646 */
break;
case 570:
#line 4666 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND p;
PTR_LLND q;
nioctl++;
if ((nioctl == 2) && ((yyvsp[0].ll_node)->variant == INT_VAL))
{
PTR_LABEL r;
r = make_label_node(fi, (long) (yyvsp[0].ll_node)->entry.ival);
r->scope = cur_scope();
p = make_llnd_label(fi, LABEL_REF, r);
}
else p = (yyvsp[0].ll_node);
q = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
if (nioctl == 1)
q->entry.string_val = (char *)"unit";
else {
if(((yyvsp[0].ll_node)->variant == VAR_REF) && (yyvsp[0].ll_node)->entry.Template.symbol->variant == NAMELIST_NAME)
q->entry.string_val = (char *)"nml";
else
q->entry.string_val = (char *)"fmt";
}
q->type = global_string;
(yyval.ll_node) = make_llnd(fi, SPEC_PAIR, q, p, SMNULL);
}
#line 9433 "gram1.tab.c" /* yacc.c:1646 */
break;
case 571:
#line 4692 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND p;
PTR_LLND q;
nioctl++;
p = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
p->entry.string_val = (char *)"*";
p->type = global_string;
q = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
if (nioctl == 1)
q->entry.string_val = (char *)"unit";
else q->entry.string_val = (char *)"fmt";
q->type = global_string;
(yyval.ll_node) = make_llnd(fi, SPEC_PAIR, q, p, SMNULL);
}
#line 9452 "gram1.tab.c" /* yacc.c:1646 */
break;
case 572:
#line 4707 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND p;
PTR_LLND q;
nioctl++;
p = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
p->entry.string_val = (char *)"**";
p->type = global_string;
q = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
if (nioctl == 1)
q->entry.string_val = (char *)"unit";
else q->entry.string_val = (char *)"fmt";
q->type = global_string;
(yyval.ll_node) = make_llnd(fi, SPEC_PAIR, q, p, SMNULL);
}
#line 9471 "gram1.tab.c" /* yacc.c:1646 */
break;
case 573:
#line 4722 "gram1.y" /* yacc.c:1646 */
{
PTR_LLND p;
char *q;
q = (yyvsp[-1].ll_node)->entry.string_val;
if ((strcmp(q, "end") == 0) || (strcmp(q, "err") == 0) || (strcmp(q, "eor") == 0) || ((strcmp(q,"fmt") == 0) && ((yyvsp[0].ll_node)->variant == INT_VAL)))
{
PTR_LABEL r;
r = make_label_node(fi, (long) (yyvsp[0].ll_node)->entry.ival);
r->scope = cur_scope();
p = make_llnd_label(fi, LABEL_REF, r);
}
else p = (yyvsp[0].ll_node);
(yyval.ll_node) = make_llnd(fi, SPEC_PAIR, (yyvsp[-1].ll_node), p, SMNULL); }
#line 9492 "gram1.tab.c" /* yacc.c:1646 */
break;
case 574:
#line 4739 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND p;
p = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
p->entry.string_val = (char *)"*";
p->type = global_string;
(yyval.ll_node) = make_llnd(fi, SPEC_PAIR, (yyvsp[-1].ll_node), p, SMNULL);
}
#line 9504 "gram1.tab.c" /* yacc.c:1646 */
break;
case 575:
#line 4747 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND p;
p = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
p->entry.string_val = (char *)"*";
p->type = global_string;
(yyval.ll_node) = make_llnd(fi, SPEC_PAIR, (yyvsp[-1].ll_node), p, SMNULL);
}
#line 9515 "gram1.tab.c" /* yacc.c:1646 */
break;
case 576:
#line 4756 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
(yyval.ll_node)->entry.string_val = copys(yytext);
(yyval.ll_node)->type = global_string;
}
#line 9524 "gram1.tab.c" /* yacc.c:1646 */
break;
case 577:
#line 4764 "gram1.y" /* yacc.c:1646 */
{(yyval.bf_node) = get_bfnd(fi, READ_STAT, SMNULL, LLNULL, LLNULL, LLNULL);}
#line 9530 "gram1.tab.c" /* yacc.c:1646 */
break;
case 578:
#line 4769 "gram1.y" /* yacc.c:1646 */
{(yyval.bf_node) = get_bfnd(fi, WRITE_STAT, SMNULL, LLNULL, LLNULL, LLNULL);}
#line 9536 "gram1.tab.c" /* yacc.c:1646 */
break;
case 579:
#line 4774 "gram1.y" /* yacc.c:1646 */
{
PTR_LLND p, q, l;
if ((yyvsp[-1].ll_node)->variant == INT_VAL)
{
PTR_LABEL r;
r = make_label_node(fi, (long) (yyvsp[-1].ll_node)->entry.ival);
r->scope = cur_scope();
p = make_llnd_label(fi, LABEL_REF, r);
}
else p = (yyvsp[-1].ll_node);
q = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
q->entry.string_val = (char *)"fmt";
q->type = global_string;
l = make_llnd(fi, SPEC_PAIR, q, p, SMNULL);
(yyval.bf_node) = get_bfnd(fi, PRINT_STAT, SMNULL, LLNULL, l, LLNULL);
endioctl();
}
#line 9562 "gram1.tab.c" /* yacc.c:1646 */
break;
case 580:
#line 4796 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND p, q, r;
p = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
p->entry.string_val = (char *)"*";
p->type = global_string;
q = make_llnd(fi, KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
q->entry.string_val = (char *)"fmt";
q->type = global_string;
r = make_llnd(fi, SPEC_PAIR, q, p, SMNULL);
(yyval.bf_node) = get_bfnd(fi, PRINT_STAT, SMNULL, LLNULL, r, LLNULL);
endioctl();
}
#line 9579 "gram1.tab.c" /* yacc.c:1646 */
break;
case 581:
#line 4812 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST);}
#line 9585 "gram1.tab.c" /* yacc.c:1646 */
break;
case 582:
#line 4814 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST);}
#line 9591 "gram1.tab.c" /* yacc.c:1646 */
break;
case 583:
#line 4818 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
#line 9597 "gram1.tab.c" /* yacc.c:1646 */
break;
case 584:
#line 4820 "gram1.y" /* yacc.c:1646 */
{
(yyvsp[-1].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-3].ll_node);
(yyval.ll_node) = (yyvsp[-1].ll_node);
}
#line 9606 "gram1.tab.c" /* yacc.c:1646 */
break;
case 585:
#line 4827 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); (yyval.ll_node)->type = (yyvsp[0].ll_node)->type;}
#line 9612 "gram1.tab.c" /* yacc.c:1646 */
break;
case 586:
#line 4829 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
#line 9618 "gram1.tab.c" /* yacc.c:1646 */
break;
case 587:
#line 4831 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
#line 9624 "gram1.tab.c" /* yacc.c:1646 */
break;
case 588:
#line 4835 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); (yyval.ll_node)->type = (yyvsp[-2].ll_node)->type;}
#line 9630 "gram1.tab.c" /* yacc.c:1646 */
break;
case 589:
#line 4837 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); (yyval.ll_node)->type = (yyvsp[-2].ll_node)->type;}
#line 9636 "gram1.tab.c" /* yacc.c:1646 */
break;
case 590:
#line 4839 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); (yyval.ll_node)->type = (yyvsp[-2].ll_node)->type;}
#line 9642 "gram1.tab.c" /* yacc.c:1646 */
break;
case 591:
#line 4841 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); (yyval.ll_node)->type = (yyvsp[-2].ll_node)->type;}
#line 9648 "gram1.tab.c" /* yacc.c:1646 */
break;
case 592:
#line 4843 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); (yyval.ll_node)->type = (yyvsp[-2].ll_node)->type;}
#line 9654 "gram1.tab.c" /* yacc.c:1646 */
break;
case 593:
#line 4845 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); (yyval.ll_node)->type = (yyvsp[-2].ll_node)->type;}
#line 9660 "gram1.tab.c" /* yacc.c:1646 */
break;
case 594:
#line 4849 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST);
(yyval.ll_node)->type = global_complex; }
#line 9667 "gram1.tab.c" /* yacc.c:1646 */
break;
case 595:
#line 4852 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node), LLNULL, EXPR_LIST);
(yyval.ll_node)->type = (yyvsp[-1].ll_node)->type; }
#line 9674 "gram1.tab.c" /* yacc.c:1646 */
break;
case 596:
#line 4855 "gram1.y" /* yacc.c:1646 */
{
(yyvsp[-1].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-3].ll_node);
(yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node), LLNULL, EXPR_LIST);
(yyval.ll_node)->type = (yyvsp[-3].ll_node)->type;
}
#line 9684 "gram1.tab.c" /* yacc.c:1646 */
break;
case 597:
#line 4861 "gram1.y" /* yacc.c:1646 */
{
(yyvsp[-1].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-3].ll_node);
(yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node), LLNULL, EXPR_LIST);
(yyval.ll_node)->type = (yyvsp[-3].ll_node)->type;
}
#line 9694 "gram1.tab.c" /* yacc.c:1646 */
break;
case 598:
#line 4867 "gram1.y" /* yacc.c:1646 */
{
(yyvsp[-1].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-3].ll_node);
(yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node), LLNULL, EXPR_LIST);
(yyval.ll_node)->type = (yyvsp[-3].ll_node)->type;
}
#line 9704 "gram1.tab.c" /* yacc.c:1646 */
break;
case 599:
#line 4875 "gram1.y" /* yacc.c:1646 */
{ inioctl = YES; }
#line 9710 "gram1.tab.c" /* yacc.c:1646 */
break;
case 600:
#line 4879 "gram1.y" /* yacc.c:1646 */
{ startioctl();}
#line 9716 "gram1.tab.c" /* yacc.c:1646 */
break;
case 601:
#line 4887 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
#line 9722 "gram1.tab.c" /* yacc.c:1646 */
break;
case 602:
#line 4889 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[-1].ll_node); }
#line 9728 "gram1.tab.c" /* yacc.c:1646 */
break;
case 603:
#line 4893 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
#line 9734 "gram1.tab.c" /* yacc.c:1646 */
break;
case 604:
#line 4895 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
#line 9740 "gram1.tab.c" /* yacc.c:1646 */
break;
case 605:
#line 4897 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,(yyvsp[-1].token), (yyvsp[-2].ll_node), (yyvsp[0].ll_node), SMNULL);
set_expr_type((yyval.ll_node));
}
#line 9749 "gram1.tab.c" /* yacc.c:1646 */
break;
case 606:
#line 4902 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,MULT_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), SMNULL);
set_expr_type((yyval.ll_node));
}
#line 9758 "gram1.tab.c" /* yacc.c:1646 */
break;
case 607:
#line 4907 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,DIV_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), SMNULL);
set_expr_type((yyval.ll_node));
}
#line 9767 "gram1.tab.c" /* yacc.c:1646 */
break;
case 608:
#line 4912 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,EXP_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), SMNULL);
set_expr_type((yyval.ll_node));
}
#line 9776 "gram1.tab.c" /* yacc.c:1646 */
break;
case 609:
#line 4917 "gram1.y" /* yacc.c:1646 */
{
if((yyvsp[-1].token) == SUBT_OP)
{
(yyval.ll_node) = make_llnd(fi,SUBT_OP, (yyvsp[0].ll_node), LLNULL, SMNULL);
set_expr_type((yyval.ll_node));
}
else (yyval.ll_node) = (yyvsp[0].ll_node);
}
#line 9789 "gram1.tab.c" /* yacc.c:1646 */
break;
case 610:
#line 4926 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,CONCAT_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), SMNULL);
set_expr_type((yyval.ll_node));
}
#line 9798 "gram1.tab.c" /* yacc.c:1646 */
break;
case 611:
#line 4931 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = LLNULL; }
#line 9804 "gram1.tab.c" /* yacc.c:1646 */
break;
case 612:
#line 4936 "gram1.y" /* yacc.c:1646 */
{ comments = cur_comment = CMNULL; }
#line 9810 "gram1.tab.c" /* yacc.c:1646 */
break;
case 613:
#line 4938 "gram1.y" /* yacc.c:1646 */
{ PTR_CMNT p;
p = make_comment(fi,*commentbuf, HALF);
if (cur_comment)
cur_comment->next = p;
else {
if ((pred_bfnd->control_parent->variant == LOGIF_NODE) ||(pred_bfnd->control_parent->variant == FORALL_STAT))
pred_bfnd->control_parent->entry.Template.cmnt_ptr = p;
else last_bfnd->entry.Template.cmnt_ptr = p;
}
comments = cur_comment = CMNULL;
}
#line 9828 "gram1.tab.c" /* yacc.c:1646 */
break;
case 677:
#line 5021 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,HPF_TEMPLATE_STAT, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL); }
#line 9834 "gram1.tab.c" /* yacc.c:1646 */
break;
case 678:
#line 5023 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB s;
if((yyvsp[-2].bf_node)->entry.Template.ll_ptr2)
{
s = (yyvsp[0].ll_node)->entry.Template.ll_ptr1->entry.Template.symbol;
s->attr = s->attr | COMMON_BIT;
}
add_to_lowLevelList((yyvsp[0].ll_node), (yyvsp[-2].bf_node)->entry.Template.ll_ptr1);
}
#line 9847 "gram1.tab.c" /* yacc.c:1646 */
break;
case 679:
#line 5034 "gram1.y" /* yacc.c:1646 */
{PTR_SYMB s;
PTR_LLND q;
/* 27.06.18
if(! explicit_shape)
err("Explicit shape specification is required", 50);
*/
s = make_array((yyvsp[-1].hash_entry), TYNULL, (yyvsp[0].ll_node), ndim, LOCAL);
if(s->attr & TEMPLATE_BIT)
errstr( "Multiple declaration of identifier %s ", s->ident, 73);
if((s->attr & PROCESSORS_BIT) || (s->attr & TASK_BIT) || (s->attr & DVM_POINTER_BIT))
errstr( "Inconsistent declaration of identifier %s ", s->ident, 16);
else
s->attr = s->attr | TEMPLATE_BIT;
if((yyvsp[0].ll_node)) s->attr = s->attr | DIMENSION_BIT;
q = make_llnd(fi,ARRAY_REF, (yyvsp[0].ll_node), LLNULL, s);
s->type->entry.ar_decl.ranges = (yyvsp[0].ll_node);
(yyval.ll_node) = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
}
#line 9870 "gram1.tab.c" /* yacc.c:1646 */
break;
case 680:
#line 5055 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,DVM_DYNAMIC_DIR, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL);}
#line 9876 "gram1.tab.c" /* yacc.c:1646 */
break;
case 681:
#line 5059 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
#line 9882 "gram1.tab.c" /* yacc.c:1646 */
break;
case 682:
#line 5061 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
#line 9888 "gram1.tab.c" /* yacc.c:1646 */
break;
case 683:
#line 5065 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB s;
s = make_array((yyvsp[0].hash_entry), TYNULL, LLNULL, 0, LOCAL);
if(s->attr & DYNAMIC_BIT)
errstr( "Multiple declaration of identifier %s ", s->ident, 73);
if((s->attr & PROCESSORS_BIT) || (s->attr & TASK_BIT) || (s->attr & HEAP_BIT))
errstr("Inconsistent declaration of identifier %s", s->ident, 16);
else
s->attr = s->attr | DYNAMIC_BIT;
(yyval.ll_node) = make_llnd(fi,ARRAY_REF, LLNULL, LLNULL, s);
}
#line 9903 "gram1.tab.c" /* yacc.c:1646 */
break;
case 684:
#line 5078 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,DVM_INHERIT_DIR, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL);}
#line 9909 "gram1.tab.c" /* yacc.c:1646 */
break;
case 685:
#line 5082 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
#line 9915 "gram1.tab.c" /* yacc.c:1646 */
break;
case 686:
#line 5084 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
#line 9921 "gram1.tab.c" /* yacc.c:1646 */
break;
case 687:
#line 5088 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB s;
s = make_array((yyvsp[0].hash_entry), TYNULL, LLNULL, 0, LOCAL);
if((s->attr & PROCESSORS_BIT) ||(s->attr & TASK_BIT) || (s->attr & TEMPLATE_BIT) || (s->attr & ALIGN_BIT) || (s->attr & DISTRIBUTE_BIT))
errstr("Inconsistent declaration of identifier %s", s->ident, 16);
else
s->attr = s->attr | INHERIT_BIT;
(yyval.ll_node) = make_llnd(fi,ARRAY_REF, LLNULL, LLNULL, s);
}
#line 9934 "gram1.tab.c" /* yacc.c:1646 */
break;
case 688:
#line 5099 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND q;
q = set_ll_list((yyvsp[-1].ll_node),LLNULL,EXPR_LIST);
/* (void)fprintf(stderr,"hpf.gram: shadow\n");*/
(yyval.bf_node) = get_bfnd(fi,DVM_SHADOW_DIR,SMNULL,q,(yyvsp[0].ll_node),LLNULL);
}
#line 9944 "gram1.tab.c" /* yacc.c:1646 */
break;
case 689:
#line 5110 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[-1].ll_node);}
#line 9950 "gram1.tab.c" /* yacc.c:1646 */
break;
case 690:
#line 5114 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
#line 9956 "gram1.tab.c" /* yacc.c:1646 */
break;
case 691:
#line 5116 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
#line 9962 "gram1.tab.c" /* yacc.c:1646 */
break;
case 692:
#line 5120 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
#line 9968 "gram1.tab.c" /* yacc.c:1646 */
break;
case 693:
#line 5122 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,DDOT, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), SMNULL);}
#line 9974 "gram1.tab.c" /* yacc.c:1646 */
break;
case 694:
#line 5124 "gram1.y" /* yacc.c:1646 */
{
if(parstate!=INEXEC)
err("Illegal shadow width specification", 56);
(yyval.ll_node) = make_llnd(fi,SHADOW_NAMES_OP, (yyvsp[-1].ll_node), LLNULL, SMNULL);
}
#line 9984 "gram1.tab.c" /* yacc.c:1646 */
break;
case 695:
#line 5139 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB s;
s = make_array((yyvsp[0].hash_entry), TYNULL, LLNULL, 0, LOCAL);
if(s->attr & SHADOW_BIT)
errstr( "Multiple declaration of identifier %s ", s->ident, 73);
if((s->attr & PROCESSORS_BIT) ||(s->attr & TASK_BIT) || (s->attr & TEMPLATE_BIT) || (s->attr & HEAP_BIT))
errstr( "Inconsistent declaration of identifier %s", s->ident, 16);
else
s->attr = s->attr | SHADOW_BIT;
(yyval.ll_node) = make_llnd(fi,ARRAY_REF, LLNULL, LLNULL, s);
}
#line 9999 "gram1.tab.c" /* yacc.c:1646 */
break;
case 696:
#line 5151 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB s;
PTR_LLND q, r;
if(! explicit_shape) {
err("Explicit shape specification is required", 50);
/* $$ = BFNULL;*/
}
s = make_array((yyvsp[-1].hash_entry), TYNULL, (yyvsp[0].ll_node), ndim, LOCAL);
if(s->attr & PROCESSORS_BIT)
errstr( "Multiple declaration of identifier %s ", s->ident, 73);
if((s->attr & ALIGN_BIT) ||(s->attr & DISTRIBUTE_BIT) ||(s->attr & TEMPLATE_BIT) || (s->attr & DYNAMIC_BIT) ||(s->attr & SHADOW_BIT) || (s->attr & TASK_BIT) || (s->attr & DVM_POINTER_BIT) || (s->attr & INHERIT_BIT))
errstr("Inconsistent declaration of identifier %s", s->ident, 16);
else
s->attr = s->attr | PROCESSORS_BIT;
if((yyvsp[0].ll_node)) s->attr = s->attr | DIMENSION_BIT;
q = make_llnd(fi,ARRAY_REF, (yyvsp[0].ll_node), LLNULL, s);
s->type->entry.ar_decl.ranges = (yyvsp[0].ll_node);
r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
(yyval.bf_node) = get_bfnd(fi,HPF_PROCESSORS_STAT, SMNULL, r, LLNULL, LLNULL);
}
#line 10023 "gram1.tab.c" /* yacc.c:1646 */
break;
case 697:
#line 5171 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB s;
PTR_LLND q, r;
if(! explicit_shape) {
err("Explicit shape specification is required", 50);
/* $$ = BFNULL;*/
}
s = make_array((yyvsp[-1].hash_entry), TYNULL, (yyvsp[0].ll_node), ndim, LOCAL);
if(s->attr & PROCESSORS_BIT)
errstr( "Multiple declaration of identifier %s ", s->ident, 73);
if((s->attr & ALIGN_BIT) ||(s->attr & DISTRIBUTE_BIT) ||(s->attr & TEMPLATE_BIT) || (s->attr & DYNAMIC_BIT) ||(s->attr & SHADOW_BIT) || (s->attr & TASK_BIT) || (s->attr & DVM_POINTER_BIT) || (s->attr & INHERIT_BIT))
errstr("Inconsistent declaration of identifier %s", s->ident, 16);
else
s->attr = s->attr | PROCESSORS_BIT;
if((yyvsp[0].ll_node)) s->attr = s->attr | DIMENSION_BIT;
q = make_llnd(fi,ARRAY_REF, (yyvsp[0].ll_node), LLNULL, s);
s->type->entry.ar_decl.ranges = (yyvsp[0].ll_node);
r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
(yyval.bf_node) = get_bfnd(fi,HPF_PROCESSORS_STAT, SMNULL, r, LLNULL, LLNULL);
}
#line 10047 "gram1.tab.c" /* yacc.c:1646 */
break;
case 698:
#line 5191 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB s;
PTR_LLND q, r;
if(! explicit_shape) {
err("Explicit shape specification is required", 50);
/*$$ = BFNULL;*/
}
s = make_array((yyvsp[-1].hash_entry), TYNULL, (yyvsp[0].ll_node), ndim, LOCAL);
if(s->attr & PROCESSORS_BIT)
errstr( "Multiple declaration of identifier %s ", s->ident, 73);
if((s->attr & ALIGN_BIT) ||(s->attr & DISTRIBUTE_BIT) ||(s->attr & TEMPLATE_BIT) || (s->attr & DYNAMIC_BIT) ||(s->attr & SHADOW_BIT) || (s->attr & TASK_BIT) || (s->attr & DVM_POINTER_BIT) || (s->attr & INHERIT_BIT) )
errstr("Inconsistent declaration of identifier %s", s->ident, 16);
else
s->attr = s->attr | PROCESSORS_BIT;
if((yyvsp[0].ll_node)) s->attr = s->attr | DIMENSION_BIT;
q = make_llnd(fi,ARRAY_REF, (yyvsp[0].ll_node), LLNULL, s);
s->type->entry.ar_decl.ranges = (yyvsp[0].ll_node);
r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
add_to_lowLevelList(r, (yyvsp[-3].bf_node)->entry.Template.ll_ptr1);
}
#line 10071 "gram1.tab.c" /* yacc.c:1646 */
break;
case 699:
#line 5213 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND q,r;
q = make_llnd(fi,VAR_REF, LLNULL, LLNULL, (yyvsp[0].symbol));
r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
(yyval.bf_node) = get_bfnd(fi,DVM_INDIRECT_GROUP_DIR, SMNULL, r, LLNULL, LLNULL);
}
#line 10081 "gram1.tab.c" /* yacc.c:1646 */
break;
case 700:
#line 5219 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND q,r;
q = make_llnd(fi,VAR_REF, LLNULL, LLNULL, (yyvsp[0].symbol));
r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
add_to_lowLevelList(r, (yyvsp[-2].bf_node)->entry.Template.ll_ptr1);
;
}
#line 10092 "gram1.tab.c" /* yacc.c:1646 */
break;
case 701:
#line 5228 "gram1.y" /* yacc.c:1646 */
{(yyval.symbol) = make_local_entity((yyvsp[0].hash_entry), REF_GROUP_NAME,global_default,LOCAL);
if((yyval.symbol)->attr & INDIRECT_BIT)
errstr( "Multiple declaration of identifier %s ", (yyval.symbol)->ident, 73);
(yyval.symbol)->attr = (yyval.symbol)->attr | INDIRECT_BIT;
}
#line 10102 "gram1.tab.c" /* yacc.c:1646 */
break;
case 702:
#line 5236 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND q,r;
q = make_llnd(fi,VAR_REF, LLNULL, LLNULL, (yyvsp[0].symbol));
r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
(yyval.bf_node) = get_bfnd(fi,DVM_REMOTE_GROUP_DIR, SMNULL, r, LLNULL, LLNULL);
}
#line 10112 "gram1.tab.c" /* yacc.c:1646 */
break;
case 703:
#line 5242 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND q,r;
q = make_llnd(fi,VAR_REF, LLNULL, LLNULL, (yyvsp[0].symbol));
r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
add_to_lowLevelList(r, (yyvsp[-2].bf_node)->entry.Template.ll_ptr1);
}
#line 10122 "gram1.tab.c" /* yacc.c:1646 */
break;
case 704:
#line 5250 "gram1.y" /* yacc.c:1646 */
{(yyval.symbol) = make_local_entity((yyvsp[0].hash_entry), REF_GROUP_NAME,global_default,LOCAL);
if((yyval.symbol)->attr & INDIRECT_BIT)
errstr( "Inconsistent declaration of identifier %s ", (yyval.symbol)->ident, 16);
}
#line 10131 "gram1.tab.c" /* yacc.c:1646 */
break;
case 705:
#line 5257 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND q,r;
q = make_llnd(fi,VAR_REF, LLNULL, LLNULL, (yyvsp[0].symbol));
r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
(yyval.bf_node) = get_bfnd(fi,DVM_REDUCTION_GROUP_DIR, SMNULL, r, LLNULL, LLNULL);
}
#line 10141 "gram1.tab.c" /* yacc.c:1646 */
break;
case 706:
#line 5263 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND q,r;
q = make_llnd(fi,VAR_REF, LLNULL, LLNULL, (yyvsp[0].symbol));
r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
add_to_lowLevelList(r, (yyvsp[-2].bf_node)->entry.Template.ll_ptr1);
;
}
#line 10152 "gram1.tab.c" /* yacc.c:1646 */
break;
case 707:
#line 5272 "gram1.y" /* yacc.c:1646 */
{(yyval.symbol) = make_local_entity((yyvsp[0].hash_entry), REDUCTION_GROUP_NAME,global_default,LOCAL);}
#line 10158 "gram1.tab.c" /* yacc.c:1646 */
break;
case 708:
#line 5276 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND q,r;
q = make_llnd(fi,VAR_REF, LLNULL, LLNULL, (yyvsp[0].symbol));
r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
(yyval.bf_node) = get_bfnd(fi,DVM_CONSISTENT_GROUP_DIR, SMNULL, r, LLNULL, LLNULL);
}
#line 10168 "gram1.tab.c" /* yacc.c:1646 */
break;
case 709:
#line 5282 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND q,r;
q = make_llnd(fi,VAR_REF, LLNULL, LLNULL, (yyvsp[0].symbol));
r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
add_to_lowLevelList(r, (yyvsp[-2].bf_node)->entry.Template.ll_ptr1);
}
#line 10178 "gram1.tab.c" /* yacc.c:1646 */
break;
case 710:
#line 5290 "gram1.y" /* yacc.c:1646 */
{(yyval.symbol) = make_local_entity((yyvsp[0].hash_entry), CONSISTENT_GROUP_NAME,global_default,LOCAL);}
#line 10184 "gram1.tab.c" /* yacc.c:1646 */
break;
case 711:
#line 5304 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB s;
if(parstate == INEXEC){
if (!(s = (yyvsp[-1].hash_entry)->id_attr))
{
s = make_array((yyvsp[-1].hash_entry), TYNULL, LLNULL, 0, LOCAL);
s->decl = SOFT;
}
} else
s = make_array((yyvsp[-1].hash_entry), TYNULL, LLNULL, 0, LOCAL);
(yyval.ll_node) = make_llnd(fi,ARRAY_REF, (yyvsp[0].ll_node), LLNULL, s);
}
#line 10201 "gram1.tab.c" /* yacc.c:1646 */
break;
case 712:
#line 5317 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = LLNULL; opt_kwd_ = NO;}
#line 10207 "gram1.tab.c" /* yacc.c:1646 */
break;
case 713:
#line 5323 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND q;
if(!(yyvsp[-1].ll_node))
err("Distribution format list is omitted", 51);
/* if($6)
err("NEW_VALUE specification in DISTRIBUTE directive");*/
q = set_ll_list((yyvsp[-2].ll_node),LLNULL,EXPR_LIST);
(yyval.bf_node) = get_bfnd(fi,DVM_DISTRIBUTE_DIR,SMNULL,q,(yyvsp[-1].ll_node),(yyvsp[0].ll_node));
}
#line 10220 "gram1.tab.c" /* yacc.c:1646 */
break;
case 714:
#line 5339 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND q;
/* if(!$4)
{err("Distribution format is omitted", 51); errcnt--;}
*/
q = set_ll_list((yyvsp[-3].ll_node),LLNULL,EXPR_LIST);
/* r = LLNULL;
if($6){
r = set_ll_list($6,LLNULL,EXPR_LIST);
if($7) r = set_ll_list(r,$7,EXPR_LIST);
} else
if($7) r = set_ll_list(r,$7,EXPR_LIST);
*/
(yyval.bf_node) = get_bfnd(fi,DVM_REDISTRIBUTE_DIR,SMNULL,q,(yyvsp[-2].ll_node),(yyvsp[0].ll_node));}
#line 10238 "gram1.tab.c" /* yacc.c:1646 */
break;
case 715:
#line 5354 "gram1.y" /* yacc.c:1646 */
{
/* r = LLNULL;
if($5){
r = set_ll_list($5,LLNULL,EXPR_LIST);
if($6) r = set_ll_list(r,$6,EXPR_LIST);
} else
if($6) r = set_ll_list(r,$6,EXPR_LIST);
*/
(yyval.bf_node) = get_bfnd(fi,DVM_REDISTRIBUTE_DIR,SMNULL,(yyvsp[0].ll_node) ,(yyvsp[-5].ll_node),(yyvsp[-3].ll_node) );
}
#line 10253 "gram1.tab.c" /* yacc.c:1646 */
break;
case 716:
#line 5382 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
#line 10259 "gram1.tab.c" /* yacc.c:1646 */
break;
case 717:
#line 5384 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
#line 10265 "gram1.tab.c" /* yacc.c:1646 */
break;
case 718:
#line 5388 "gram1.y" /* yacc.c:1646 */
{(yyval.ll_node) = (yyvsp[0].ll_node);}
#line 10271 "gram1.tab.c" /* yacc.c:1646 */
break;
case 719:
#line 5390 "gram1.y" /* yacc.c:1646 */
{(yyval.ll_node) = (yyvsp[0].ll_node);}
#line 10277 "gram1.tab.c" /* yacc.c:1646 */
break;
case 720:
#line 5394 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB s;
if(parstate == INEXEC){
if (!(s = (yyvsp[0].hash_entry)->id_attr))
{
s = make_array((yyvsp[0].hash_entry), TYNULL, LLNULL, 0, LOCAL);
s->decl = SOFT;
}
if(s->attr & PROCESSORS_BIT)
errstr( "Illegal use of PROCESSORS name %s ", s->ident, 53);
if(s->attr & TASK_BIT)
errstr( "Illegal use of task array name %s ", s->ident, 71);
} else {
s = make_array((yyvsp[0].hash_entry), TYNULL, LLNULL, 0, LOCAL);
if(s->attr & DISTRIBUTE_BIT)
errstr( "Multiple declaration of identifier %s ", s->ident, 73);
else if( (s->attr & PROCESSORS_BIT) || (s->attr & TASK_BIT) || (s->attr & INHERIT_BIT))
errstr("Inconsistent declaration of identifier %s",s->ident, 16);
else
s->attr = s->attr | DISTRIBUTE_BIT;
}
if(s->attr & ALIGN_BIT)
errstr("A distributee may not have the ALIGN attribute:%s",s->ident, 54);
(yyval.ll_node) = make_llnd(fi,ARRAY_REF, LLNULL, LLNULL, s);
}
#line 10308 "gram1.tab.c" /* yacc.c:1646 */
break;
case 721:
#line 5423 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB s;
s = make_array((yyvsp[-3].hash_entry), TYNULL, LLNULL, 0, LOCAL);
if(parstate != INEXEC)
errstr( "Illegal distributee:%s", s->ident, 312);
else {
if(s->attr & PROCESSORS_BIT)
errstr( "Illegal use of PROCESSORS name %s ", s->ident, 53);
if(s->attr & TASK_BIT)
errstr( "Illegal use of task array name %s ", s->ident, 71);
if(s->attr & ALIGN_BIT)
errstr("A distributee may not have the ALIGN attribute:%s",s->ident, 54);
if(!(s->attr & DVM_POINTER_BIT))
errstr("Illegal distributee:%s", s->ident, 312);
/*s->attr = s->attr | DISTRIBUTE_BIT;*/
(yyval.ll_node) = make_llnd(fi,ARRAY_REF, (yyvsp[-1].ll_node), LLNULL, s);
}
}
#line 10332 "gram1.tab.c" /* yacc.c:1646 */
break;
case 722:
#line 5446 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB s;
if((s=(yyvsp[0].hash_entry)->id_attr) == SMNULL)
s = make_array((yyvsp[0].hash_entry), TYNULL, LLNULL, 0, LOCAL);
if((parstate == INEXEC) && !(s->attr & PROCESSORS_BIT))
errstr( "'%s' is not processor array ", s->ident, 67);
(yyval.symbol) = s;
}
#line 10344 "gram1.tab.c" /* yacc.c:1646 */
break;
case 723:
#line 5466 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = LLNULL; }
#line 10350 "gram1.tab.c" /* yacc.c:1646 */
break;
case 724:
#line 5468 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[-1].ll_node);}
#line 10356 "gram1.tab.c" /* yacc.c:1646 */
break;
case 725:
#line 5472 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[-1].ll_node);}
#line 10362 "gram1.tab.c" /* yacc.c:1646 */
break;
case 726:
#line 5493 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
#line 10368 "gram1.tab.c" /* yacc.c:1646 */
break;
case 727:
#line 5495 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-3].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
#line 10374 "gram1.tab.c" /* yacc.c:1646 */
break;
case 728:
#line 5498 "gram1.y" /* yacc.c:1646 */
{ opt_kwd_ = YES; }
#line 10380 "gram1.tab.c" /* yacc.c:1646 */
break;
case 729:
#line 5507 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,BLOCK_OP, LLNULL, LLNULL, SMNULL);
}
#line 10388 "gram1.tab.c" /* yacc.c:1646 */
break;
case 730:
#line 5511 "gram1.y" /* yacc.c:1646 */
{ err("Distribution format BLOCK(n) is not permitted in FDVM", 55);
(yyval.ll_node) = make_llnd(fi,BLOCK_OP, (yyvsp[-1].ll_node), LLNULL, SMNULL);
endioctl();
}
#line 10397 "gram1.tab.c" /* yacc.c:1646 */
break;
case 731:
#line 5516 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,BLOCK_OP, LLNULL, LLNULL, (yyvsp[-1].symbol)); }
#line 10403 "gram1.tab.c" /* yacc.c:1646 */
break;
case 732:
#line 5518 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,BLOCK_OP, (yyvsp[-1].ll_node), LLNULL, (yyvsp[-3].symbol)); }
#line 10409 "gram1.tab.c" /* yacc.c:1646 */
break;
case 733:
#line 5520 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,BLOCK_OP, LLNULL, (yyvsp[-1].ll_node), SMNULL); }
#line 10415 "gram1.tab.c" /* yacc.c:1646 */
break;
case 734:
#line 5522 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
(yyval.ll_node)->entry.string_val = (char *) "*";
(yyval.ll_node)->type = global_string;
}
#line 10425 "gram1.tab.c" /* yacc.c:1646 */
break;
case 735:
#line 5528 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,INDIRECT_OP, LLNULL, LLNULL, (yyvsp[-1].symbol)); }
#line 10431 "gram1.tab.c" /* yacc.c:1646 */
break;
case 736:
#line 5530 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,INDIRECT_OP, (yyvsp[-1].ll_node), LLNULL, SMNULL); }
#line 10437 "gram1.tab.c" /* yacc.c:1646 */
break;
case 737:
#line 5534 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB s;
s = make_array((yyvsp[0].hash_entry), TYNULL, LLNULL, 0, LOCAL);
if((s->attr & PROCESSORS_BIT) ||(s->attr & TASK_BIT) || (s->attr & TEMPLATE_BIT))
errstr("Inconsistent declaration of identifier %s", s->ident, 16);
(yyval.symbol) = s;
}
#line 10449 "gram1.tab.c" /* yacc.c:1646 */
break;
case 738:
#line 5544 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,DERIVED_OP, (yyvsp[-4].ll_node), (yyvsp[0].ll_node), SMNULL); }
#line 10455 "gram1.tab.c" /* yacc.c:1646 */
break;
case 739:
#line 5548 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
#line 10461 "gram1.tab.c" /* yacc.c:1646 */
break;
case 740:
#line 5550 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
#line 10467 "gram1.tab.c" /* yacc.c:1646 */
break;
case 741:
#line 5555 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
#line 10473 "gram1.tab.c" /* yacc.c:1646 */
break;
case 742:
#line 5557 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,DDOT, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), SMNULL);}
#line 10479 "gram1.tab.c" /* yacc.c:1646 */
break;
case 743:
#line 5561 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,ARRAY_REF, LLNULL, LLNULL, (yyvsp[0].symbol));
}
#line 10487 "gram1.tab.c" /* yacc.c:1646 */
break;
case 744:
#line 5565 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,ARRAY_REF, (yyvsp[-1].ll_node), LLNULL, (yyvsp[-3].symbol));
}
#line 10495 "gram1.tab.c" /* yacc.c:1646 */
break;
case 745:
#line 5571 "gram1.y" /* yacc.c:1646 */
{
if (!((yyval.symbol) = (yyvsp[0].hash_entry)->id_attr))
{
(yyval.symbol) = make_array((yyvsp[0].hash_entry), TYNULL, LLNULL,0,LOCAL);
(yyval.symbol)->decl = SOFT;
}
}
#line 10507 "gram1.tab.c" /* yacc.c:1646 */
break;
case 746:
#line 5581 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
#line 10513 "gram1.tab.c" /* yacc.c:1646 */
break;
case 747:
#line 5583 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
#line 10519 "gram1.tab.c" /* yacc.c:1646 */
break;
case 748:
#line 5587 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
#line 10525 "gram1.tab.c" /* yacc.c:1646 */
break;
case 749:
#line 5589 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
#line 10531 "gram1.tab.c" /* yacc.c:1646 */
break;
case 750:
#line 5591 "gram1.y" /* yacc.c:1646 */
{
(yyvsp[-1].ll_node)->entry.Template.ll_ptr1 = (yyvsp[0].ll_node);
(yyval.ll_node) = (yyvsp[-1].ll_node);
}
#line 10540 "gram1.tab.c" /* yacc.c:1646 */
break;
case 751:
#line 5598 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB s;
s = make_scalar((yyvsp[0].hash_entry),TYNULL,LOCAL);
(yyval.ll_node) = make_llnd(fi,DUMMY_REF, LLNULL, LLNULL, s);
/*$$->type = global_int;*/
}
#line 10550 "gram1.tab.c" /* yacc.c:1646 */
break;
case 752:
#line 5615 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = LLNULL; }
#line 10556 "gram1.tab.c" /* yacc.c:1646 */
break;
case 753:
#line 5617 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
#line 10562 "gram1.tab.c" /* yacc.c:1646 */
break;
case 754:
#line 5621 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
#line 10568 "gram1.tab.c" /* yacc.c:1646 */
break;
case 755:
#line 5623 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
#line 10574 "gram1.tab.c" /* yacc.c:1646 */
break;
case 756:
#line 5627 "gram1.y" /* yacc.c:1646 */
{ if((yyvsp[0].ll_node)->type->variant != T_STRING)
errstr( "Illegal type of shadow_name", 627);
(yyval.ll_node) = (yyvsp[0].ll_node);
}
#line 10583 "gram1.tab.c" /* yacc.c:1646 */
break;
case 757:
#line 5634 "gram1.y" /* yacc.c:1646 */
{ char *q;
nioctl = 1;
q = (yyvsp[-1].ll_node)->entry.string_val;
if((!strcmp(q,"shadow")) && ((yyvsp[0].ll_node)->variant == INT_VAL)) (yyval.ll_node) = make_llnd(fi,SPEC_PAIR, (yyvsp[-1].ll_node), (yyvsp[0].ll_node), SMNULL);
else
{ err("Illegal shadow width specification", 56);
(yyval.ll_node) = LLNULL;
}
}
#line 10597 "gram1.tab.c" /* yacc.c:1646 */
break;
case 758:
#line 5644 "gram1.y" /* yacc.c:1646 */
{ char *ql, *qh;
PTR_LLND p1, p2;
nioctl = 2;
ql = (yyvsp[-4].ll_node)->entry.string_val;
qh = (yyvsp[-1].ll_node)->entry.string_val;
if((!strcmp(ql,"low_shadow")) && ((yyvsp[-3].ll_node)->variant == INT_VAL) && (!strcmp(qh,"high_shadow")) && ((yyvsp[0].ll_node)->variant == INT_VAL))
{
p1 = make_llnd(fi,SPEC_PAIR, (yyvsp[-4].ll_node), (yyvsp[-3].ll_node), SMNULL);
p2 = make_llnd(fi,SPEC_PAIR, (yyvsp[-1].ll_node), (yyvsp[0].ll_node), SMNULL);
(yyval.ll_node) = make_llnd(fi,CONS, p1, p2, SMNULL);
}
else
{ err("Illegal shadow width specification", 56);
(yyval.ll_node) = LLNULL;
}
}
#line 10618 "gram1.tab.c" /* yacc.c:1646 */
break;
case 759:
#line 5673 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND q;
q = set_ll_list((yyvsp[-1].ll_node),LLNULL,EXPR_LIST);
(yyval.bf_node) = (yyvsp[0].bf_node);
(yyval.bf_node)->entry.Template.ll_ptr1 = q;
}
#line 10628 "gram1.tab.c" /* yacc.c:1646 */
break;
case 760:
#line 5688 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND q;
q = set_ll_list((yyvsp[-1].ll_node),LLNULL,EXPR_LIST);
(yyval.bf_node) = (yyvsp[0].bf_node);
(yyval.bf_node)->variant = DVM_REALIGN_DIR;
(yyval.bf_node)->entry.Template.ll_ptr1 = q;
}
#line 10639 "gram1.tab.c" /* yacc.c:1646 */
break;
case 761:
#line 5695 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = (yyvsp[-3].bf_node);
(yyval.bf_node)->variant = DVM_REALIGN_DIR;
(yyval.bf_node)->entry.Template.ll_ptr1 = (yyvsp[0].ll_node);
}
#line 10649 "gram1.tab.c" /* yacc.c:1646 */
break;
case 762:
#line 5713 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
#line 10655 "gram1.tab.c" /* yacc.c:1646 */
break;
case 763:
#line 5715 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
#line 10661 "gram1.tab.c" /* yacc.c:1646 */
break;
case 764:
#line 5719 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB s;
s = make_array((yyvsp[0].hash_entry), TYNULL, LLNULL, 0, LOCAL);
if((s->attr & ALIGN_BIT))
errstr( "Multiple declaration of identifier %s ", s->ident, 73);
if((s->attr & PROCESSORS_BIT) || (s->attr & TASK_BIT) || (s->attr & INHERIT_BIT))
errstr( "Inconsistent declaration of identifier %s", s->ident, 16);
else if(s->attr & DISTRIBUTE_BIT)
errstr( "An alignee may not have the DISTRIBUTE attribute:'%s'", s->ident,57); else
s->attr = s->attr | ALIGN_BIT;
(yyval.ll_node) = make_llnd(fi,ARRAY_REF, LLNULL, LLNULL, s);
}
#line 10677 "gram1.tab.c" /* yacc.c:1646 */
break;
case 765:
#line 5733 "gram1.y" /* yacc.c:1646 */
{PTR_SYMB s;
s = (yyvsp[0].ll_node)->entry.Template.symbol;
if(s->attr & PROCESSORS_BIT)
errstr( "Illegal use of PROCESSORS name %s ", s->ident, 53);
else if(s->attr & TASK_BIT)
errstr( "Illegal use of task array name %s ", s->ident, 71);
else if( !(s->attr & DIMENSION_BIT) && !(s->attr & DVM_POINTER_BIT))
errstr("The alignee %s isn't an array", s->ident, 58);
else {
/* if(!(s->attr & DYNAMIC_BIT))
errstr("'%s' hasn't the DYNAMIC attribute", s->ident, 59);
*/
if(!(s->attr & ALIGN_BIT) && !(s->attr & INHERIT_BIT))
errstr("'%s' hasn't the ALIGN attribute", s->ident, 60);
if(s->attr & DISTRIBUTE_BIT)
errstr("An alignee may not have the DISTRIBUTE attribute: %s", s->ident, 57);
/* if(s->entry.var_decl.local == IO)
* errstr("An alignee may not be the dummy argument");
*/
}
(yyval.ll_node) = make_llnd(fi,ARRAY_REF, LLNULL, LLNULL, s);
}
#line 10705 "gram1.tab.c" /* yacc.c:1646 */
break;
case 766:
#line 5759 "gram1.y" /* yacc.c:1646 */
{ /* PTR_LLND r;
if($7) {
r = set_ll_list($6,LLNULL,EXPR_LIST);
r = set_ll_list(r,$7,EXPR_LIST);
}
else
r = $6;
*/
(yyval.bf_node) = get_bfnd(fi,DVM_ALIGN_DIR,SMNULL,LLNULL,(yyvsp[-4].ll_node),(yyvsp[0].ll_node));
}
#line 10720 "gram1.tab.c" /* yacc.c:1646 */
break;
case 767:
#line 5772 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,ARRAY_REF, (yyvsp[-1].ll_node), LLNULL, (yyvsp[-3].symbol));
}
#line 10728 "gram1.tab.c" /* yacc.c:1646 */
break;
case 768:
#line 5788 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
#line 10734 "gram1.tab.c" /* yacc.c:1646 */
break;
case 769:
#line 5790 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
#line 10740 "gram1.tab.c" /* yacc.c:1646 */
break;
case 770:
#line 5793 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
#line 10746 "gram1.tab.c" /* yacc.c:1646 */
break;
case 771:
#line 5795 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
(yyval.ll_node)->entry.string_val = (char *) "*";
(yyval.ll_node)->type = global_string;
}
#line 10756 "gram1.tab.c" /* yacc.c:1646 */
break;
case 772:
#line 5801 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
#line 10762 "gram1.tab.c" /* yacc.c:1646 */
break;
case 773:
#line 5805 "gram1.y" /* yacc.c:1646 */
{
/* if(parstate == INEXEC){ *for REALIGN directive*
if (!($$ = $1->id_attr))
{
$$ = make_array($1, TYNULL, LLNULL,0,LOCAL);
$$->decl = SOFT;
}
} else
$$ = make_array($1, TYNULL, LLNULL, 0, LOCAL);
*/
if (!((yyval.symbol) = (yyvsp[0].hash_entry)->id_attr))
{
(yyval.symbol) = make_array((yyvsp[0].hash_entry), TYNULL, LLNULL,0,LOCAL);
(yyval.symbol)->decl = SOFT;
}
(yyval.symbol)->attr = (yyval.symbol)->attr | ALIGN_BASE_BIT;
if((yyval.symbol)->attr & PROCESSORS_BIT)
errstr( "Illegal use of PROCESSORS name %s ", (yyval.symbol)->ident, 53);
else if((yyval.symbol)->attr & TASK_BIT)
errstr( "Illegal use of task array name %s ", (yyval.symbol)->ident, 71);
else
if((parstate == INEXEC) /* for REALIGN directive */
&& !((yyval.symbol)->attr & DIMENSION_BIT) && !((yyval.symbol)->attr & DVM_POINTER_BIT))
errstr("The align-target %s isn't declared as array", (yyval.symbol)->ident, 61);
}
#line 10792 "gram1.tab.c" /* yacc.c:1646 */
break;
case 774:
#line 5833 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
#line 10798 "gram1.tab.c" /* yacc.c:1646 */
break;
case 775:
#line 5835 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
#line 10804 "gram1.tab.c" /* yacc.c:1646 */
break;
case 776:
#line 5839 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB s;
s = make_scalar((yyvsp[0].hash_entry),TYNULL,LOCAL);
if(s->type->variant != T_INT || s->attr & PARAMETER_BIT)
errstr("The align-dummy %s isn't a scalar integer variable", s->ident, 62);
(yyval.ll_node) = make_llnd(fi,VAR_REF, LLNULL, LLNULL, s);
(yyval.ll_node)->type = global_int;
}
#line 10816 "gram1.tab.c" /* yacc.c:1646 */
break;
case 777:
#line 5847 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
(yyval.ll_node)->entry.string_val = (char *) "*";
(yyval.ll_node)->type = global_string;
}
#line 10826 "gram1.tab.c" /* yacc.c:1646 */
break;
case 778:
#line 5853 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,DDOT, LLNULL, LLNULL, SMNULL); }
#line 10832 "gram1.tab.c" /* yacc.c:1646 */
break;
case 779:
#line 5856 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB s;
PTR_LLND q, r, p;
int numdim;
if(type_options & PROCESSORS_BIT) { /* 27.06.18 || (type_options & TEMPLATE_BIT)){ */
if(! explicit_shape) {
err("Explicit shape specification is required", 50);
/*$$ = BFNULL;*/
}
}
/* else {
if($6)
err("Shape specification is not permitted", 263);
} */
if(type_options & DIMENSION_BIT)
{ p = attr_dims; numdim = attr_ndim;}
else
{ p = LLNULL; numdim = 0; }
if((yyvsp[0].ll_node)) /*dimension information after the object name*/
{ p = (yyvsp[0].ll_node); numdim = ndim;} /*overrides the DIMENSION attribute */
s = make_array((yyvsp[-1].hash_entry), TYNULL, p, numdim, LOCAL);
if((type_options & COMMON_BIT) && !(type_options & TEMPLATE_BIT))
{
err("Illegal combination of attributes", 63);
type_options = type_options & (~COMMON_BIT);
}
if((type_options & PROCESSORS_BIT) &&((type_options & ALIGN_BIT) ||(type_options & DISTRIBUTE_BIT) ||(type_options & TEMPLATE_BIT) || (type_options & DYNAMIC_BIT) ||(type_options & SHADOW_BIT) ))
err("Illegal combination of attributes", 63);
else if((type_options & PROCESSORS_BIT) && ((s->attr & ALIGN_BIT) ||(s->attr & DISTRIBUTE_BIT) ||(s->attr & TEMPLATE_BIT) || (s->attr & DYNAMIC_BIT) ||(s->attr & SHADOW_BIT)) )
{ errstr("Inconsistent declaration of %s", s->ident, 16);
type_options = type_options & (~PROCESSORS_BIT);
}
else if ((s->attr & PROCESSORS_BIT) && ((type_options & ALIGN_BIT) ||(type_options & DISTRIBUTE_BIT) ||(type_options & TEMPLATE_BIT) || (type_options & DYNAMIC_BIT) ||(type_options & SHADOW_BIT)))
errstr("Inconsistent declaration of %s", s->ident, 16);
else if ((s->attr & INHERIT_BIT) && ((type_options & ALIGN_BIT) ||(type_options & DISTRIBUTE_BIT)))
errstr("Inconsistent declaration of %s", s->ident, 16);
if(( s->attr & DISTRIBUTE_BIT) && (type_options & DISTRIBUTE_BIT))
errstr( "Multiple declaration of identifier %s ", s->ident, 73);
if(( s->attr & ALIGN_BIT) && (type_options & ALIGN_BIT))
errstr( "Multiple declaration of identifier %s ", s->ident, 73);
if(( s->attr & SHADOW_BIT) && (type_options & SHADOW_BIT))
errstr( "Multiple declaration of identifier %s ", s->ident, 73);
if(( s->attr & TEMPLATE_BIT) && (type_options & TEMPLATE_BIT))
errstr( "Multiple declaration of identifier %s ", s->ident, 73);
if(( s->attr & PROCESSORS_BIT) && (type_options & PROCESSORS_BIT))
errstr( "Multiple declaration of identifier %s ", s->ident, 73);
s->attr = s->attr | type_options;
if((yyvsp[0].ll_node)) s->attr = s->attr | DIMENSION_BIT;
if((s->attr & DISTRIBUTE_BIT) && (s->attr & ALIGN_BIT))
errstr("%s has the DISTRIBUTE and ALIGN attribute",s->ident, 64);
q = make_llnd(fi,ARRAY_REF, (yyvsp[0].ll_node), LLNULL, s);
if(p) s->type->entry.ar_decl.ranges = p;
r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
(yyval.bf_node) = get_bfnd(fi,DVM_VAR_DECL, SMNULL, r, LLNULL,(yyvsp[-5].ll_node));
}
#line 10894 "gram1.tab.c" /* yacc.c:1646 */
break;
case 780:
#line 5914 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB s;
PTR_LLND q, r, p;
int numdim;
if(type_options & PROCESSORS_BIT) { /*23.10.18 || (type_options & TEMPLATE_BIT)){ */
if(! explicit_shape) {
err("Explicit shape specification is required", 50);
/*$$ = BFNULL;*/
}
}
/* else {
if($4)
err("Shape specification is not permitted", 263);
} */
if(type_options & DIMENSION_BIT)
{ p = attr_dims; numdim = attr_ndim;}
else
{ p = LLNULL; numdim = 0; }
if((yyvsp[0].ll_node)) /*dimension information after the object name*/
{ p = (yyvsp[0].ll_node); numdim = ndim;}/*overrides the DIMENSION attribute */
s = make_array((yyvsp[-1].hash_entry), TYNULL, p, numdim, LOCAL);
if((type_options & COMMON_BIT) && !(type_options & TEMPLATE_BIT))
{
err("Illegal combination of attributes", 63);
type_options = type_options & (~COMMON_BIT);
}
if((type_options & PROCESSORS_BIT) &&((type_options & ALIGN_BIT) ||(type_options & DISTRIBUTE_BIT) ||(type_options & TEMPLATE_BIT) || (type_options & DYNAMIC_BIT) ||(type_options & SHADOW_BIT) ))
err("Illegal combination of attributes", 63);
else if((type_options & PROCESSORS_BIT) && ((s->attr & ALIGN_BIT) ||(s->attr & DISTRIBUTE_BIT) ||(s->attr & TEMPLATE_BIT) || (s->attr & DYNAMIC_BIT) ||(s->attr & SHADOW_BIT)) )
{ errstr("Inconsistent declaration of identifier %s", s->ident, 16);
type_options = type_options & (~PROCESSORS_BIT);
}
else if ((s->attr & PROCESSORS_BIT) && ((type_options & ALIGN_BIT) ||(type_options & DISTRIBUTE_BIT) ||(type_options & TEMPLATE_BIT) || (type_options & DYNAMIC_BIT) ||(type_options & SHADOW_BIT)))
errstr("Inconsistent declaration of identifier %s", s->ident,16);
else if ((s->attr & INHERIT_BIT) && ((type_options & ALIGN_BIT) ||(type_options & DISTRIBUTE_BIT)))
errstr("Inconsistent declaration of identifier %s", s->ident, 16);
if(( s->attr & DISTRIBUTE_BIT) && (type_options & DISTRIBUTE_BIT))
errstr( "Multiple declaration of identifier %s ", s->ident, 73);
if(( s->attr & ALIGN_BIT) && (type_options & ALIGN_BIT))
errstr( "Multiple declaration of identifier %s ", s->ident, 73);
if(( s->attr & SHADOW_BIT) && (type_options & SHADOW_BIT))
errstr( "Multiple declaration of identifier %s ", s->ident, 73);
if(( s->attr & TEMPLATE_BIT) && (type_options & TEMPLATE_BIT))
errstr( "Multiple declaration of identifier %s ", s->ident, 73);
if(( s->attr & PROCESSORS_BIT) && (type_options & PROCESSORS_BIT))
errstr( "Multiple declaration of identifier %s ", s->ident, 73);
s->attr = s->attr | type_options;
if((yyvsp[0].ll_node)) s->attr = s->attr | DIMENSION_BIT;
if((s->attr & DISTRIBUTE_BIT) && (s->attr & ALIGN_BIT))
errstr("%s has the DISTRIBUTE and ALIGN attribute",s->ident, 64);
q = make_llnd(fi,ARRAY_REF, (yyvsp[0].ll_node), LLNULL, s);
if(p) s->type->entry.ar_decl.ranges = p;
r = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);
add_to_lowLevelList(r, (yyvsp[-3].bf_node)->entry.Template.ll_ptr1);
}
#line 10954 "gram1.tab.c" /* yacc.c:1646 */
break;
case 781:
#line 5978 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); type_options = type_opt; }
#line 10960 "gram1.tab.c" /* yacc.c:1646 */
break;
case 782:
#line 5980 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-3].ll_node),(yyvsp[0].ll_node),EXPR_LIST); type_options = type_options | type_opt;}
#line 10966 "gram1.tab.c" /* yacc.c:1646 */
break;
case 783:
#line 5983 "gram1.y" /* yacc.c:1646 */
{ type_opt = TEMPLATE_BIT;
(yyval.ll_node) = make_llnd(fi,TEMPLATE_OP,LLNULL,LLNULL,SMNULL);
}
#line 10974 "gram1.tab.c" /* yacc.c:1646 */
break;
case 784:
#line 5987 "gram1.y" /* yacc.c:1646 */
{ type_opt = PROCESSORS_BIT;
(yyval.ll_node) = make_llnd(fi,PROCESSORS_OP,LLNULL,LLNULL,SMNULL);
}
#line 10982 "gram1.tab.c" /* yacc.c:1646 */
break;
case 785:
#line 5991 "gram1.y" /* yacc.c:1646 */
{ type_opt = PROCESSORS_BIT;
(yyval.ll_node) = make_llnd(fi,PROCESSORS_OP,LLNULL,LLNULL,SMNULL);
}
#line 10990 "gram1.tab.c" /* yacc.c:1646 */
break;
case 786:
#line 5995 "gram1.y" /* yacc.c:1646 */
{ type_opt = DYNAMIC_BIT;
(yyval.ll_node) = make_llnd(fi,DYNAMIC_OP,LLNULL,LLNULL,SMNULL);
}
#line 10998 "gram1.tab.c" /* yacc.c:1646 */
break;
case 787:
#line 6012 "gram1.y" /* yacc.c:1646 */
{
if(! explicit_shape) {
err("Explicit shape specification is required", 50);
}
if(! (yyvsp[-1].ll_node)) {
err("No shape specification", 65);
}
type_opt = DIMENSION_BIT;
attr_ndim = ndim; attr_dims = (yyvsp[-1].ll_node);
(yyval.ll_node) = make_llnd(fi,DIMENSION_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);
}
#line 11014 "gram1.tab.c" /* yacc.c:1646 */
break;
case 788:
#line 6024 "gram1.y" /* yacc.c:1646 */
{ type_opt = SHADOW_BIT;
(yyval.ll_node) = make_llnd(fi,SHADOW_OP,(yyvsp[0].ll_node),LLNULL,SMNULL);
}
#line 11022 "gram1.tab.c" /* yacc.c:1646 */
break;
case 789:
#line 6028 "gram1.y" /* yacc.c:1646 */
{ type_opt = ALIGN_BIT;
(yyval.ll_node) = make_llnd(fi,ALIGN_OP,(yyvsp[-4].ll_node),(yyvsp[0].ll_node),SMNULL);
}
#line 11030 "gram1.tab.c" /* yacc.c:1646 */
break;
case 790:
#line 6032 "gram1.y" /* yacc.c:1646 */
{ type_opt = ALIGN_BIT;
(yyval.ll_node) = make_llnd(fi,ALIGN_OP,LLNULL,SMNULL,SMNULL);
}
#line 11038 "gram1.tab.c" /* yacc.c:1646 */
break;
case 791:
#line 6042 "gram1.y" /* yacc.c:1646 */
{
type_opt = DISTRIBUTE_BIT;
(yyval.ll_node) = make_llnd(fi,DISTRIBUTE_OP,(yyvsp[-2].ll_node),(yyvsp[0].ll_node),SMNULL);
}
#line 11047 "gram1.tab.c" /* yacc.c:1646 */
break;
case 792:
#line 6047 "gram1.y" /* yacc.c:1646 */
{
type_opt = DISTRIBUTE_BIT;
(yyval.ll_node) = make_llnd(fi,DISTRIBUTE_OP,LLNULL,LLNULL,SMNULL);
}
#line 11056 "gram1.tab.c" /* yacc.c:1646 */
break;
case 793:
#line 6052 "gram1.y" /* yacc.c:1646 */
{
type_opt = COMMON_BIT;
(yyval.ll_node) = make_llnd(fi,COMMON_OP, LLNULL, LLNULL, SMNULL);
}
#line 11065 "gram1.tab.c" /* yacc.c:1646 */
break;
case 794:
#line 6059 "gram1.y" /* yacc.c:1646 */
{
PTR_LLND l;
l = make_llnd(fi, TYPE_OP, LLNULL, LLNULL, SMNULL);
l->type = (yyvsp[-10].data_type);
(yyval.bf_node) = get_bfnd(fi,DVM_POINTER_DIR, SMNULL, (yyvsp[0].ll_node),(yyvsp[-4].ll_node), l);
}
#line 11076 "gram1.tab.c" /* yacc.c:1646 */
break;
case 795:
#line 6067 "gram1.y" /* yacc.c:1646 */
{ndim = 0;}
#line 11082 "gram1.tab.c" /* yacc.c:1646 */
break;
case 796:
#line 6068 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND q;
if(ndim == maxdim)
err("Too many dimensions", 43);
else if(ndim < maxdim)
q = make_llnd(fi,DDOT,LLNULL,LLNULL,SMNULL);
++ndim;
(yyval.ll_node) = set_ll_list(q, LLNULL, EXPR_LIST);
/*$$ = make_llnd(fi,EXPR_LIST, q, LLNULL, SMNULL);*/
/*$$->type = global_default;*/
}
#line 11097 "gram1.tab.c" /* yacc.c:1646 */
break;
case 797:
#line 6079 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND q;
if(ndim == maxdim)
err("Too many dimensions", 43);
else if(ndim < maxdim)
q = make_llnd(fi,DDOT,LLNULL,LLNULL,SMNULL);
++ndim;
(yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), q, EXPR_LIST);
}
#line 11110 "gram1.tab.c" /* yacc.c:1646 */
break;
case 798:
#line 6090 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
#line 11116 "gram1.tab.c" /* yacc.c:1646 */
break;
case 799:
#line 6092 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
#line 11122 "gram1.tab.c" /* yacc.c:1646 */
break;
case 800:
#line 6096 "gram1.y" /* yacc.c:1646 */
{PTR_SYMB s;
/* s = make_scalar($1,TYNULL,LOCAL);*/
s = make_array((yyvsp[0].hash_entry),TYNULL,LLNULL,0,LOCAL);
s->attr = s->attr | DVM_POINTER_BIT;
if((s->attr & PROCESSORS_BIT) || (s->attr & TASK_BIT) || (s->attr & INHERIT_BIT))
errstr( "Inconsistent declaration of identifier %s", s->ident, 16);
(yyval.ll_node) = make_llnd(fi,VAR_REF,LLNULL,LLNULL,s);
}
#line 11135 "gram1.tab.c" /* yacc.c:1646 */
break;
case 801:
#line 6107 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,DVM_HEAP_DIR, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL);}
#line 11141 "gram1.tab.c" /* yacc.c:1646 */
break;
case 802:
#line 6111 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
#line 11147 "gram1.tab.c" /* yacc.c:1646 */
break;
case 803:
#line 6113 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
#line 11153 "gram1.tab.c" /* yacc.c:1646 */
break;
case 804:
#line 6117 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB s;
s = make_array((yyvsp[0].hash_entry), TYNULL, LLNULL, 0, LOCAL);
s->attr = s->attr | HEAP_BIT;
if((s->attr & PROCESSORS_BIT) ||(s->attr & TASK_BIT) || (s->attr & TEMPLATE_BIT) || (s->attr & ALIGN_BIT) || (s->attr & DISTRIBUTE_BIT) || (s->attr & INHERIT_BIT) || (s->attr & DYNAMIC_BIT) || (s->attr & SHADOW_BIT) || (s->attr & DVM_POINTER_BIT))
errstr("Inconsistent declaration of identifier %s", s->ident, 16);
(yyval.ll_node) = make_llnd(fi,ARRAY_REF, LLNULL, LLNULL, s);
}
#line 11166 "gram1.tab.c" /* yacc.c:1646 */
break;
case 805:
#line 6128 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,DVM_CONSISTENT_DIR, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL);}
#line 11172 "gram1.tab.c" /* yacc.c:1646 */
break;
case 806:
#line 6132 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
#line 11178 "gram1.tab.c" /* yacc.c:1646 */
break;
case 807:
#line 6134 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
#line 11184 "gram1.tab.c" /* yacc.c:1646 */
break;
case 808:
#line 6138 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB s;
s = make_array((yyvsp[0].hash_entry), TYNULL, LLNULL, 0, LOCAL);
s->attr = s->attr | CONSISTENT_BIT;
if((s->attr & PROCESSORS_BIT) ||(s->attr & TASK_BIT) || (s->attr & TEMPLATE_BIT) || (s->attr & ALIGN_BIT) || (s->attr & DISTRIBUTE_BIT) || (s->attr & INHERIT_BIT) || (s->attr & DYNAMIC_BIT) || (s->attr & SHADOW_BIT) || (s->attr & DVM_POINTER_BIT))
errstr("Inconsistent declaration of identifier %s", s->ident, 16);
(yyval.ll_node) = make_llnd(fi,ARRAY_REF, LLNULL, LLNULL, s);
}
#line 11197 "gram1.tab.c" /* yacc.c:1646 */
break;
case 809:
#line 6150 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,DVM_ASYNCID_DIR, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL);}
#line 11203 "gram1.tab.c" /* yacc.c:1646 */
break;
case 810:
#line 6152 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND p;
p = make_llnd(fi,COMM_LIST, LLNULL, LLNULL, SMNULL);
(yyval.bf_node) = get_bfnd(fi,DVM_ASYNCID_DIR, SMNULL, (yyvsp[0].ll_node), p, LLNULL);
}
#line 11212 "gram1.tab.c" /* yacc.c:1646 */
break;
case 811:
#line 6159 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
#line 11218 "gram1.tab.c" /* yacc.c:1646 */
break;
case 812:
#line 6161 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
#line 11224 "gram1.tab.c" /* yacc.c:1646 */
break;
case 813:
#line 6165 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB s;
if((yyvsp[0].ll_node)){
s = make_array((yyvsp[-1].hash_entry), global_default, (yyvsp[0].ll_node), ndim, LOCAL);
s->variant = ASYNC_ID;
s->attr = s->attr | DIMENSION_BIT;
s->type->entry.ar_decl.ranges = (yyvsp[0].ll_node);
(yyval.ll_node) = make_llnd(fi,ARRAY_REF, (yyvsp[0].ll_node), LLNULL, s);
} else {
s = make_local_entity((yyvsp[-1].hash_entry), ASYNC_ID, global_default, LOCAL);
(yyval.ll_node) = make_llnd(fi,VAR_REF, LLNULL, LLNULL, s);
}
}
#line 11241 "gram1.tab.c" /* yacc.c:1646 */
break;
case 814:
#line 6181 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,DVM_NEW_VALUE_DIR,SMNULL, LLNULL, LLNULL,LLNULL);}
#line 11247 "gram1.tab.c" /* yacc.c:1646 */
break;
case 815:
#line 6191 "gram1.y" /* yacc.c:1646 */
{ if((yyvsp[-1].ll_node) && (yyvsp[-1].ll_node)->entry.Template.symbol->attr & TASK_BIT)
(yyval.bf_node) = get_bfnd(fi,DVM_PARALLEL_TASK_DIR,SMNULL,(yyvsp[-1].ll_node),(yyvsp[0].ll_node),(yyvsp[-3].ll_node));
else
(yyval.bf_node) = get_bfnd(fi,DVM_PARALLEL_ON_DIR,SMNULL,(yyvsp[-1].ll_node),(yyvsp[0].ll_node),(yyvsp[-3].ll_node));
}
#line 11257 "gram1.tab.c" /* yacc.c:1646 */
break;
case 816:
#line 6200 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
#line 11263 "gram1.tab.c" /* yacc.c:1646 */
break;
case 817:
#line 6202 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
#line 11269 "gram1.tab.c" /* yacc.c:1646 */
break;
case 818:
#line 6206 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
#line 11275 "gram1.tab.c" /* yacc.c:1646 */
break;
case 819:
#line 6209 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = LLNULL; opt_kwd_ = NO;}
#line 11281 "gram1.tab.c" /* yacc.c:1646 */
break;
case 820:
#line 6214 "gram1.y" /* yacc.c:1646 */
{
if((yyvsp[-3].ll_node)->type->variant != T_ARRAY)
errstr("'%s' isn't array", (yyvsp[-3].ll_node)->entry.Template.symbol->ident, 66);
(yyvsp[-3].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);
(yyval.ll_node) = (yyvsp[-3].ll_node);
(yyval.ll_node)->type = (yyvsp[-3].ll_node)->type->entry.ar_decl.base_type;
}
#line 11293 "gram1.tab.c" /* yacc.c:1646 */
break;
case 821:
#line 6224 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
#line 11299 "gram1.tab.c" /* yacc.c:1646 */
break;
case 822:
#line 6226 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
#line 11305 "gram1.tab.c" /* yacc.c:1646 */
break;
case 823:
#line 6230 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
#line 11311 "gram1.tab.c" /* yacc.c:1646 */
break;
case 824:
#line 6232 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
(yyval.ll_node)->entry.string_val = (char *) "*";
(yyval.ll_node)->type = global_string;
}
#line 11321 "gram1.tab.c" /* yacc.c:1646 */
break;
case 825:
#line 6240 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = LLNULL;}
#line 11327 "gram1.tab.c" /* yacc.c:1646 */
break;
case 826:
#line 6242 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
#line 11333 "gram1.tab.c" /* yacc.c:1646 */
break;
case 827:
#line 6246 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
#line 11339 "gram1.tab.c" /* yacc.c:1646 */
break;
case 828:
#line 6248 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
#line 11345 "gram1.tab.c" /* yacc.c:1646 */
break;
case 840:
#line 6266 "gram1.y" /* yacc.c:1646 */
{ if((yyvsp[-3].symbol)->attr & INDIRECT_BIT)
errstr("'%s' is not remote group name", (yyvsp[-3].symbol)->ident, 68);
(yyval.ll_node) = make_llnd(fi,REMOTE_ACCESS_OP,(yyvsp[-1].ll_node),LLNULL,(yyvsp[-3].symbol));
}
#line 11354 "gram1.tab.c" /* yacc.c:1646 */
break;
case 841:
#line 6271 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,REMOTE_ACCESS_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
#line 11360 "gram1.tab.c" /* yacc.c:1646 */
break;
case 842:
#line 6275 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,CONSISTENT_OP,(yyvsp[-1].ll_node),LLNULL,(yyvsp[-3].symbol));
}
#line 11368 "gram1.tab.c" /* yacc.c:1646 */
break;
case 843:
#line 6279 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,CONSISTENT_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
#line 11374 "gram1.tab.c" /* yacc.c:1646 */
break;
case 844:
#line 6283 "gram1.y" /* yacc.c:1646 */
{
if(((yyval.symbol)=(yyvsp[0].hash_entry)->id_attr) == SMNULL){
errstr("'%s' is not declared as group", (yyvsp[0].hash_entry)->ident, 74);
(yyval.symbol) = make_local_entity((yyvsp[0].hash_entry),CONSISTENT_GROUP_NAME,global_default,LOCAL);
} else {
if((yyval.symbol)->variant != CONSISTENT_GROUP_NAME)
errstr("'%s' is not declared as group", (yyvsp[0].hash_entry)->ident, 74);
}
}
#line 11388 "gram1.tab.c" /* yacc.c:1646 */
break;
case 845:
#line 6296 "gram1.y" /* yacc.c:1646 */
{(yyval.ll_node) = make_llnd(fi,NEW_SPEC_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
#line 11394 "gram1.tab.c" /* yacc.c:1646 */
break;
case 846:
#line 6300 "gram1.y" /* yacc.c:1646 */
{(yyval.ll_node) = make_llnd(fi,NEW_SPEC_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
#line 11400 "gram1.tab.c" /* yacc.c:1646 */
break;
case 847:
#line 6304 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,ACC_PRIVATE_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
#line 11406 "gram1.tab.c" /* yacc.c:1646 */
break;
case 848:
#line 6308 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,ACC_CUDA_BLOCK_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
#line 11412 "gram1.tab.c" /* yacc.c:1646 */
break;
case 849:
#line 6311 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST);}
#line 11418 "gram1.tab.c" /* yacc.c:1646 */
break;
case 850:
#line 6313 "gram1.y" /* yacc.c:1646 */
{(yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST);}
#line 11424 "gram1.tab.c" /* yacc.c:1646 */
break;
case 851:
#line 6315 "gram1.y" /* yacc.c:1646 */
{(yyval.ll_node) = set_ll_list((yyvsp[-4].ll_node),(yyvsp[-2].ll_node),EXPR_LIST); (yyval.ll_node) = set_ll_list((yyval.ll_node),(yyvsp[0].ll_node),EXPR_LIST);}
#line 11430 "gram1.tab.c" /* yacc.c:1646 */
break;
case 852:
#line 6319 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST);}
#line 11436 "gram1.tab.c" /* yacc.c:1646 */
break;
case 853:
#line 6321 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST);}
#line 11442 "gram1.tab.c" /* yacc.c:1646 */
break;
case 854:
#line 6325 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,ACC_TIE_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
#line 11448 "gram1.tab.c" /* yacc.c:1646 */
break;
case 855:
#line 6329 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST);}
#line 11454 "gram1.tab.c" /* yacc.c:1646 */
break;
case 856:
#line 6331 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST);}
#line 11460 "gram1.tab.c" /* yacc.c:1646 */
break;
case 857:
#line 6335 "gram1.y" /* yacc.c:1646 */
{ if(!((yyvsp[-3].symbol)->attr & INDIRECT_BIT))
errstr("'%s' is not indirect group name", (yyvsp[-3].symbol)->ident, 313);
(yyval.ll_node) = make_llnd(fi,INDIRECT_ACCESS_OP,(yyvsp[-1].ll_node),LLNULL,(yyvsp[-3].symbol));
}
#line 11469 "gram1.tab.c" /* yacc.c:1646 */
break;
case 858:
#line 6340 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,INDIRECT_ACCESS_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
#line 11475 "gram1.tab.c" /* yacc.c:1646 */
break;
case 859:
#line 6344 "gram1.y" /* yacc.c:1646 */
{(yyval.ll_node) = make_llnd(fi,STAGE_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
#line 11481 "gram1.tab.c" /* yacc.c:1646 */
break;
case 860:
#line 6348 "gram1.y" /* yacc.c:1646 */
{(yyval.ll_node) = make_llnd(fi,ACROSS_OP,(yyvsp[0].ll_node),LLNULL,SMNULL);}
#line 11487 "gram1.tab.c" /* yacc.c:1646 */
break;
case 861:
#line 6350 "gram1.y" /* yacc.c:1646 */
{(yyval.ll_node) = make_llnd(fi,ACROSS_OP,(yyvsp[-1].ll_node),(yyvsp[0].ll_node),SMNULL);}
#line 11493 "gram1.tab.c" /* yacc.c:1646 */
break;
case 862:
#line 6354 "gram1.y" /* yacc.c:1646 */
{ if((yyvsp[-2].ll_node))
(yyval.ll_node) = make_llnd(fi,DDOT,(yyvsp[-2].ll_node),(yyvsp[-1].ll_node),SMNULL);
else
(yyval.ll_node) = (yyvsp[-1].ll_node);
}
#line 11503 "gram1.tab.c" /* yacc.c:1646 */
break;
case 863:
#line 6362 "gram1.y" /* yacc.c:1646 */
{ opt_in_out = YES; }
#line 11509 "gram1.tab.c" /* yacc.c:1646 */
break;
case 864:
#line 6366 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
(yyval.ll_node)->entry.string_val = (char *) "in";
(yyval.ll_node)->type = global_string;
}
#line 11519 "gram1.tab.c" /* yacc.c:1646 */
break;
case 865:
#line 6372 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
(yyval.ll_node)->entry.string_val = (char *) "out";
(yyval.ll_node)->type = global_string;
}
#line 11529 "gram1.tab.c" /* yacc.c:1646 */
break;
case 866:
#line 6378 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = LLNULL; opt_in_out = NO;}
#line 11535 "gram1.tab.c" /* yacc.c:1646 */
break;
case 867:
#line 6382 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST);}
#line 11541 "gram1.tab.c" /* yacc.c:1646 */
break;
case 868:
#line 6384 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST);}
#line 11547 "gram1.tab.c" /* yacc.c:1646 */
break;
case 869:
#line 6388 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
#line 11553 "gram1.tab.c" /* yacc.c:1646 */
break;
case 870:
#line 6390 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[-3].ll_node);
(yyval.ll_node)-> entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);
}
#line 11561 "gram1.tab.c" /* yacc.c:1646 */
break;
case 871:
#line 6394 "gram1.y" /* yacc.c:1646 */
{ /* PTR_LLND p;
p = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
p->entry.string_val = (char *) "corner";
p->type = global_string;
*/
(yyvsp[-6].ll_node)-> entry.Template.ll_ptr1 = (yyvsp[-4].ll_node);
(yyval.ll_node) = make_llnd(fi,ARRAY_OP,(yyvsp[-6].ll_node),(yyvsp[-1].ll_node),SMNULL);
}
#line 11574 "gram1.tab.c" /* yacc.c:1646 */
break;
case 872:
#line 6406 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST);}
#line 11580 "gram1.tab.c" /* yacc.c:1646 */
break;
case 873:
#line 6408 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST);}
#line 11586 "gram1.tab.c" /* yacc.c:1646 */
break;
case 874:
#line 6412 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,DDOT, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), SMNULL);}
#line 11592 "gram1.tab.c" /* yacc.c:1646 */
break;
case 875:
#line 6416 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST);}
#line 11598 "gram1.tab.c" /* yacc.c:1646 */
break;
case 876:
#line 6418 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST);}
#line 11604 "gram1.tab.c" /* yacc.c:1646 */
break;
case 877:
#line 6422 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,DDOT,(yyvsp[-4].ll_node),make_llnd(fi,DDOT,(yyvsp[-2].ll_node),(yyvsp[0].ll_node),SMNULL),SMNULL); }
#line 11610 "gram1.tab.c" /* yacc.c:1646 */
break;
case 878:
#line 6424 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,DDOT,(yyvsp[-2].ll_node),make_llnd(fi,DDOT,(yyvsp[0].ll_node),LLNULL,SMNULL),SMNULL); }
#line 11616 "gram1.tab.c" /* yacc.c:1646 */
break;
case 879:
#line 6426 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,DDOT,(yyvsp[-2].ll_node),make_llnd(fi,DDOT,LLNULL,(yyvsp[0].ll_node),SMNULL),SMNULL); }
#line 11622 "gram1.tab.c" /* yacc.c:1646 */
break;
case 880:
#line 6428 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,DDOT,(yyvsp[0].ll_node),LLNULL,SMNULL); }
#line 11628 "gram1.tab.c" /* yacc.c:1646 */
break;
case 881:
#line 6430 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,DDOT,LLNULL,make_llnd(fi,DDOT,(yyvsp[-2].ll_node),(yyvsp[0].ll_node),SMNULL),SMNULL); }
#line 11634 "gram1.tab.c" /* yacc.c:1646 */
break;
case 882:
#line 6432 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,DDOT,LLNULL,make_llnd(fi,DDOT,(yyvsp[0].ll_node),LLNULL,SMNULL),SMNULL); }
#line 11640 "gram1.tab.c" /* yacc.c:1646 */
break;
case 883:
#line 6434 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,DDOT,LLNULL,make_llnd(fi,DDOT,LLNULL,(yyvsp[0].ll_node),SMNULL),SMNULL); }
#line 11646 "gram1.tab.c" /* yacc.c:1646 */
break;
case 884:
#line 6438 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
#line 11652 "gram1.tab.c" /* yacc.c:1646 */
break;
case 885:
#line 6442 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
#line 11658 "gram1.tab.c" /* yacc.c:1646 */
break;
case 886:
#line 6446 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
#line 11664 "gram1.tab.c" /* yacc.c:1646 */
break;
case 887:
#line 6450 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[-1].ll_node);}
#line 11670 "gram1.tab.c" /* yacc.c:1646 */
break;
case 888:
#line 6454 "gram1.y" /* yacc.c:1646 */
{PTR_LLND q;
/* q = set_ll_list($9,$6,EXPR_LIST); */
q = set_ll_list((yyvsp[-4].ll_node),LLNULL,EXPR_LIST); /*podd 11.10.01*/
q = add_to_lowLevelList((yyvsp[-1].ll_node),q); /*podd 11.10.01*/
(yyval.ll_node) = make_llnd(fi,REDUCTION_OP,q,LLNULL,SMNULL);
}
#line 11681 "gram1.tab.c" /* yacc.c:1646 */
break;
case 889:
#line 6461 "gram1.y" /* yacc.c:1646 */
{PTR_LLND q;
q = set_ll_list((yyvsp[-2].ll_node),LLNULL,EXPR_LIST);
(yyval.ll_node) = make_llnd(fi,REDUCTION_OP,q,LLNULL,SMNULL);
}
#line 11690 "gram1.tab.c" /* yacc.c:1646 */
break;
case 890:
#line 6467 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,REDUCTION_OP,(yyvsp[-1].ll_node),LLNULL,(yyvsp[-4].symbol)); }
#line 11696 "gram1.tab.c" /* yacc.c:1646 */
break;
case 891:
#line 6471 "gram1.y" /* yacc.c:1646 */
{ opt_kwd_r = YES; }
#line 11702 "gram1.tab.c" /* yacc.c:1646 */
break;
case 892:
#line 6474 "gram1.y" /* yacc.c:1646 */
{ opt_kwd_r = NO; }
#line 11708 "gram1.tab.c" /* yacc.c:1646 */
break;
case 893:
#line 6478 "gram1.y" /* yacc.c:1646 */
{
if(((yyval.symbol)=(yyvsp[0].hash_entry)->id_attr) == SMNULL) {
errstr("'%s' is not declared as reduction group", (yyvsp[0].hash_entry)->ident, 69);
(yyval.symbol) = make_local_entity((yyvsp[0].hash_entry),REDUCTION_GROUP_NAME,global_default,LOCAL);
} else {
if((yyval.symbol)->variant != REDUCTION_GROUP_NAME)
errstr("'%s' is not declared as reduction group", (yyvsp[0].hash_entry)->ident, 69);
}
}
#line 11722 "gram1.tab.c" /* yacc.c:1646 */
break;
case 894:
#line 6491 "gram1.y" /* yacc.c:1646 */
{(yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST);}
#line 11728 "gram1.tab.c" /* yacc.c:1646 */
break;
case 895:
#line 6493 "gram1.y" /* yacc.c:1646 */
{(yyval.ll_node) = set_ll_list((yyvsp[-3].ll_node),(yyvsp[0].ll_node),EXPR_LIST);}
#line 11734 "gram1.tab.c" /* yacc.c:1646 */
break;
case 896:
#line 6497 "gram1.y" /* yacc.c:1646 */
{(yyval.ll_node) = make_llnd(fi,ARRAY_OP,(yyvsp[-3].ll_node),(yyvsp[-1].ll_node),SMNULL);}
#line 11740 "gram1.tab.c" /* yacc.c:1646 */
break;
case 897:
#line 6499 "gram1.y" /* yacc.c:1646 */
{(yyvsp[-3].ll_node) = set_ll_list((yyvsp[-3].ll_node),(yyvsp[-1].ll_node),EXPR_LIST);
(yyval.ll_node) = make_llnd(fi,ARRAY_OP,(yyvsp[-5].ll_node),(yyvsp[-3].ll_node),SMNULL);}
#line 11747 "gram1.tab.c" /* yacc.c:1646 */
break;
case 898:
#line 6504 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
(yyval.ll_node)->entry.string_val = (char *) "sum";
(yyval.ll_node)->type = global_string;
}
#line 11757 "gram1.tab.c" /* yacc.c:1646 */
break;
case 899:
#line 6510 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
(yyval.ll_node)->entry.string_val = (char *) "product";
(yyval.ll_node)->type = global_string;
}
#line 11767 "gram1.tab.c" /* yacc.c:1646 */
break;
case 900:
#line 6516 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
(yyval.ll_node)->entry.string_val = (char *) "min";
(yyval.ll_node)->type = global_string;
}
#line 11777 "gram1.tab.c" /* yacc.c:1646 */
break;
case 901:
#line 6522 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
(yyval.ll_node)->entry.string_val = (char *) "max";
(yyval.ll_node)->type = global_string;
}
#line 11787 "gram1.tab.c" /* yacc.c:1646 */
break;
case 902:
#line 6528 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
(yyval.ll_node)->entry.string_val = (char *) "or";
(yyval.ll_node)->type = global_string;
}
#line 11797 "gram1.tab.c" /* yacc.c:1646 */
break;
case 903:
#line 6534 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
(yyval.ll_node)->entry.string_val = (char *) "and";
(yyval.ll_node)->type = global_string;
}
#line 11807 "gram1.tab.c" /* yacc.c:1646 */
break;
case 904:
#line 6540 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
(yyval.ll_node)->entry.string_val = (char *) "eqv";
(yyval.ll_node)->type = global_string;
}
#line 11817 "gram1.tab.c" /* yacc.c:1646 */
break;
case 905:
#line 6546 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
(yyval.ll_node)->entry.string_val = (char *) "neqv";
(yyval.ll_node)->type = global_string;
}
#line 11827 "gram1.tab.c" /* yacc.c:1646 */
break;
case 906:
#line 6552 "gram1.y" /* yacc.c:1646 */
{ err("Illegal reduction operation name", 70);
errcnt--;
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
(yyval.ll_node)->entry.string_val = (char *) "unknown";
(yyval.ll_node)->type = global_string;
}
#line 11838 "gram1.tab.c" /* yacc.c:1646 */
break;
case 907:
#line 6561 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
(yyval.ll_node)->entry.string_val = (char *) "maxloc";
(yyval.ll_node)->type = global_string;
}
#line 11848 "gram1.tab.c" /* yacc.c:1646 */
break;
case 908:
#line 6567 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
(yyval.ll_node)->entry.string_val = (char *) "minloc";
(yyval.ll_node)->type = global_string;
}
#line 11858 "gram1.tab.c" /* yacc.c:1646 */
break;
case 909:
#line 6584 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,SHADOW_RENEW_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
#line 11864 "gram1.tab.c" /* yacc.c:1646 */
break;
case 910:
#line 6592 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,SHADOW_START_OP,LLNULL,LLNULL,(yyvsp[0].symbol));}
#line 11870 "gram1.tab.c" /* yacc.c:1646 */
break;
case 911:
#line 6600 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,SHADOW_WAIT_OP,LLNULL,LLNULL,(yyvsp[0].symbol));}
#line 11876 "gram1.tab.c" /* yacc.c:1646 */
break;
case 912:
#line 6602 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,SHADOW_COMP_OP,LLNULL,LLNULL,SMNULL);}
#line 11882 "gram1.tab.c" /* yacc.c:1646 */
break;
case 913:
#line 6604 "gram1.y" /* yacc.c:1646 */
{ (yyvsp[-4].ll_node)-> entry.Template.ll_ptr1 = (yyvsp[-2].ll_node); (yyval.ll_node) = make_llnd(fi,SHADOW_COMP_OP,(yyvsp[-4].ll_node),LLNULL,SMNULL);}
#line 11888 "gram1.tab.c" /* yacc.c:1646 */
break;
case 914:
#line 6608 "gram1.y" /* yacc.c:1646 */
{(yyval.symbol) = make_local_entity((yyvsp[0].hash_entry), SHADOW_GROUP_NAME,global_default,LOCAL);}
#line 11894 "gram1.tab.c" /* yacc.c:1646 */
break;
case 915:
#line 6612 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST);}
#line 11900 "gram1.tab.c" /* yacc.c:1646 */
break;
case 916:
#line 6614 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST);}
#line 11906 "gram1.tab.c" /* yacc.c:1646 */
break;
case 917:
#line 6618 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
#line 11912 "gram1.tab.c" /* yacc.c:1646 */
break;
case 918:
#line 6620 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND p;
p = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
p->entry.string_val = (char *) "corner";
p->type = global_string;
(yyval.ll_node) = make_llnd(fi,ARRAY_OP,(yyvsp[-4].ll_node),p,SMNULL);
}
#line 11923 "gram1.tab.c" /* yacc.c:1646 */
break;
case 919:
#line 6628 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[-4].ll_node);
(yyval.ll_node)-> entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);
}
#line 11931 "gram1.tab.c" /* yacc.c:1646 */
break;
case 920:
#line 6632 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND p;
p = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
p->entry.string_val = (char *) "corner";
p->type = global_string;
(yyvsp[-8].ll_node)-> entry.Template.ll_ptr1 = (yyvsp[-5].ll_node);
(yyval.ll_node) = make_llnd(fi,ARRAY_OP,(yyvsp[-8].ll_node),p,SMNULL);
}
#line 11943 "gram1.tab.c" /* yacc.c:1646 */
break;
case 921:
#line 6643 "gram1.y" /* yacc.c:1646 */
{ optcorner = YES; }
#line 11949 "gram1.tab.c" /* yacc.c:1646 */
break;
case 922:
#line 6647 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB s;
s = (yyvsp[0].ll_node)->entry.Template.symbol;
if(s->attr & PROCESSORS_BIT)
errstr( "Illegal use of PROCESSORS name %s ", s->ident, 53);
else if(s->attr & TASK_BIT)
errstr( "Illegal use of task array name %s ", s->ident, 71);
else
if(s->type->variant != T_ARRAY)
errstr("'%s' isn't array", s->ident, 66);
else
if((!(s->attr & DISTRIBUTE_BIT)) && (!(s->attr & ALIGN_BIT)))
; /*errstr("hpf.gram: %s is not distributed array", s->ident);*/
(yyval.ll_node) = (yyvsp[0].ll_node);
}
#line 11969 "gram1.tab.c" /* yacc.c:1646 */
break;
case 923:
#line 6665 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
#line 11975 "gram1.tab.c" /* yacc.c:1646 */
break;
case 924:
#line 6667 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
#line 11981 "gram1.tab.c" /* yacc.c:1646 */
break;
case 925:
#line 6671 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,DVM_SHADOW_START_DIR,(yyvsp[0].symbol),LLNULL,LLNULL,LLNULL);}
#line 11987 "gram1.tab.c" /* yacc.c:1646 */
break;
case 926:
#line 6673 "gram1.y" /* yacc.c:1646 */
{errstr("Missing DVM directive prefix", 49);}
#line 11993 "gram1.tab.c" /* yacc.c:1646 */
break;
case 927:
#line 6677 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,DVM_SHADOW_WAIT_DIR,(yyvsp[0].symbol),LLNULL,LLNULL,LLNULL);}
#line 11999 "gram1.tab.c" /* yacc.c:1646 */
break;
case 928:
#line 6679 "gram1.y" /* yacc.c:1646 */
{errstr("Missing DVM directive prefix", 49);}
#line 12005 "gram1.tab.c" /* yacc.c:1646 */
break;
case 929:
#line 6683 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,DVM_SHADOW_GROUP_DIR,(yyvsp[-3].symbol),(yyvsp[-1].ll_node),LLNULL,LLNULL);}
#line 12011 "gram1.tab.c" /* yacc.c:1646 */
break;
case 930:
#line 6687 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,DVM_REDUCTION_START_DIR,(yyvsp[0].symbol),LLNULL,LLNULL,LLNULL);}
#line 12017 "gram1.tab.c" /* yacc.c:1646 */
break;
case 931:
#line 6691 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,DVM_REDUCTION_WAIT_DIR,(yyvsp[0].symbol),LLNULL,LLNULL,LLNULL);}
#line 12023 "gram1.tab.c" /* yacc.c:1646 */
break;
case 932:
#line 6700 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,DVM_CONSISTENT_START_DIR,(yyvsp[0].symbol),LLNULL,LLNULL,LLNULL);}
#line 12029 "gram1.tab.c" /* yacc.c:1646 */
break;
case 933:
#line 6704 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,DVM_CONSISTENT_WAIT_DIR,(yyvsp[0].symbol),LLNULL,LLNULL,LLNULL);}
#line 12035 "gram1.tab.c" /* yacc.c:1646 */
break;
case 934:
#line 6708 "gram1.y" /* yacc.c:1646 */
{ if(((yyvsp[-3].symbol)->attr & INDIRECT_BIT))
errstr("'%s' is not remote group name", (yyvsp[-3].symbol)->ident, 68);
(yyval.bf_node) = get_bfnd(fi,DVM_REMOTE_ACCESS_DIR,(yyvsp[-3].symbol),(yyvsp[-1].ll_node),LLNULL,LLNULL);
}
#line 12044 "gram1.tab.c" /* yacc.c:1646 */
break;
case 935:
#line 6713 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,DVM_REMOTE_ACCESS_DIR,SMNULL,(yyvsp[-1].ll_node),LLNULL,LLNULL);}
#line 12050 "gram1.tab.c" /* yacc.c:1646 */
break;
case 936:
#line 6717 "gram1.y" /* yacc.c:1646 */
{
if(((yyval.symbol)=(yyvsp[0].hash_entry)->id_attr) == SMNULL){
errstr("'%s' is not declared as group", (yyvsp[0].hash_entry)->ident, 74);
(yyval.symbol) = make_local_entity((yyvsp[0].hash_entry),REF_GROUP_NAME,global_default,LOCAL);
} else {
if((yyval.symbol)->variant != REF_GROUP_NAME)
errstr("'%s' is not declared as group", (yyvsp[0].hash_entry)->ident, 74);
}
}
#line 12064 "gram1.tab.c" /* yacc.c:1646 */
break;
case 937:
#line 6729 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
#line 12070 "gram1.tab.c" /* yacc.c:1646 */
break;
case 938:
#line 6731 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
#line 12076 "gram1.tab.c" /* yacc.c:1646 */
break;
case 939:
#line 6735 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = (yyvsp[-3].ll_node);
(yyval.ll_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);
}
#line 12085 "gram1.tab.c" /* yacc.c:1646 */
break;
case 940:
#line 6740 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
#line 12091 "gram1.tab.c" /* yacc.c:1646 */
break;
case 941:
#line 6744 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
#line 12097 "gram1.tab.c" /* yacc.c:1646 */
break;
case 942:
#line 6746 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
#line 12103 "gram1.tab.c" /* yacc.c:1646 */
break;
case 943:
#line 6750 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
#line 12109 "gram1.tab.c" /* yacc.c:1646 */
break;
case 944:
#line 6752 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,DDOT, LLNULL, LLNULL, SMNULL);}
#line 12115 "gram1.tab.c" /* yacc.c:1646 */
break;
case 945:
#line 6756 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND q;
q = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
(yyval.bf_node) = get_bfnd(fi,DVM_TASK_DIR,SMNULL,q,LLNULL,LLNULL);
}
#line 12124 "gram1.tab.c" /* yacc.c:1646 */
break;
case 946:
#line 6761 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND q;
q = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL);
add_to_lowLevelList(q, (yyvsp[-2].bf_node)->entry.Template.ll_ptr1);
}
#line 12133 "gram1.tab.c" /* yacc.c:1646 */
break;
case 947:
#line 6768 "gram1.y" /* yacc.c:1646 */
{
PTR_SYMB s;
s = make_array((yyvsp[-1].hash_entry), global_int, (yyvsp[0].ll_node), ndim, LOCAL);
if((yyvsp[0].ll_node)){
s->attr = s->attr | DIMENSION_BIT;
s->type->entry.ar_decl.ranges = (yyvsp[0].ll_node);
}
else
err("No dimensions in TASK directive", 75);
if(ndim > 1)
errstr("Illegal rank of '%s'", s->ident, 76);
if(s->attr & TASK_BIT)
errstr( "Multiple declaration of identifier %s ", s->ident, 73);
if((s->attr & ALIGN_BIT) ||(s->attr & DISTRIBUTE_BIT) ||(s->attr & TEMPLATE_BIT) || (s->attr & DYNAMIC_BIT) ||(s->attr & SHADOW_BIT) || (s->attr & PROCESSORS_BIT) || (s->attr & DVM_POINTER_BIT) || (s->attr & INHERIT_BIT))
errstr("Inconsistent declaration of identifier %s", s->ident, 16);
else
s->attr = s->attr | TASK_BIT;
(yyval.ll_node) = make_llnd(fi,ARRAY_REF, (yyvsp[0].ll_node), LLNULL, s);
}
#line 12158 "gram1.tab.c" /* yacc.c:1646 */
break;
case 948:
#line 6791 "gram1.y" /* yacc.c:1646 */
{(yyval.bf_node) = get_bfnd(fi,DVM_TASK_REGION_DIR,(yyvsp[0].symbol),LLNULL,LLNULL,LLNULL);}
#line 12164 "gram1.tab.c" /* yacc.c:1646 */
break;
case 949:
#line 6793 "gram1.y" /* yacc.c:1646 */
{(yyval.bf_node) = get_bfnd(fi,DVM_TASK_REGION_DIR,(yyvsp[-1].symbol),(yyvsp[0].ll_node),LLNULL,LLNULL);}
#line 12170 "gram1.tab.c" /* yacc.c:1646 */
break;
case 950:
#line 6795 "gram1.y" /* yacc.c:1646 */
{(yyval.bf_node) = get_bfnd(fi,DVM_TASK_REGION_DIR,(yyvsp[-1].symbol),LLNULL,(yyvsp[0].ll_node),LLNULL);}
#line 12176 "gram1.tab.c" /* yacc.c:1646 */
break;
case 951:
#line 6797 "gram1.y" /* yacc.c:1646 */
{(yyval.bf_node) = get_bfnd(fi,DVM_TASK_REGION_DIR,(yyvsp[-2].symbol),(yyvsp[-1].ll_node),(yyvsp[0].ll_node),LLNULL);}
#line 12182 "gram1.tab.c" /* yacc.c:1646 */
break;
case 952:
#line 6799 "gram1.y" /* yacc.c:1646 */
{(yyval.bf_node) = get_bfnd(fi,DVM_TASK_REGION_DIR,(yyvsp[-2].symbol),(yyvsp[0].ll_node),(yyvsp[-1].ll_node),LLNULL);}
#line 12188 "gram1.tab.c" /* yacc.c:1646 */
break;
case 953:
#line 6803 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB s;
if((s=(yyvsp[0].hash_entry)->id_attr) == SMNULL)
s = make_array((yyvsp[0].hash_entry), TYNULL, LLNULL, 0, LOCAL);
if(!(s->attr & TASK_BIT))
errstr("'%s' is not task array", s->ident, 77);
(yyval.symbol) = s;
}
#line 12201 "gram1.tab.c" /* yacc.c:1646 */
break;
case 954:
#line 6814 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,DVM_END_TASK_REGION_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
#line 12207 "gram1.tab.c" /* yacc.c:1646 */
break;
case 955:
#line 6818 "gram1.y" /* yacc.c:1646 */
{ PTR_SYMB s;
PTR_LLND q;
/*
s = make_array($1, TYNULL, LLNULL, 0, LOCAL);
if((parstate == INEXEC) && !(s->attr & TASK_BIT))
errstr("'%s' is not task array", s->ident, 77);
q = set_ll_list($3,LLNULL,EXPR_LIST);
$$ = make_llnd(fi,ARRAY_REF, q, LLNULL, s);
*/
s = (yyvsp[-3].symbol);
q = set_ll_list((yyvsp[-1].ll_node),LLNULL,EXPR_LIST);
(yyval.ll_node) = make_llnd(fi,ARRAY_REF, q, LLNULL, s);
}
#line 12226 "gram1.tab.c" /* yacc.c:1646 */
break;
case 956:
#line 6833 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND q;
q = set_ll_list((yyvsp[-1].ll_node),LLNULL,EXPR_LIST);
(yyval.ll_node) = make_llnd(fi,ARRAY_REF, q, LLNULL, (yyvsp[-3].symbol));
}
#line 12235 "gram1.tab.c" /* yacc.c:1646 */
break;
case 957:
#line 6840 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = get_bfnd(fi,DVM_ON_DIR,SMNULL,(yyvsp[-1].ll_node),(yyvsp[0].ll_node),LLNULL);
}
#line 12243 "gram1.tab.c" /* yacc.c:1646 */
break;
case 958:
#line 6846 "gram1.y" /* yacc.c:1646 */
{(yyval.ll_node) = LLNULL;}
#line 12249 "gram1.tab.c" /* yacc.c:1646 */
break;
case 959:
#line 6848 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
#line 12255 "gram1.tab.c" /* yacc.c:1646 */
break;
case 960:
#line 6852 "gram1.y" /* yacc.c:1646 */
{(yyval.bf_node) = get_bfnd(fi,DVM_END_ON_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
#line 12261 "gram1.tab.c" /* yacc.c:1646 */
break;
case 961:
#line 6856 "gram1.y" /* yacc.c:1646 */
{ PTR_LLND q;
/* if(!($6->attr & PROCESSORS_BIT))
errstr("'%s' is not processor array", $6->ident, 67);
*/
q = make_llnd(fi,ARRAY_REF, (yyvsp[0].ll_node), LLNULL, (yyvsp[-1].symbol));
(yyval.bf_node) = get_bfnd(fi,DVM_MAP_DIR,SMNULL,(yyvsp[-4].ll_node),q,LLNULL);
}
#line 12273 "gram1.tab.c" /* yacc.c:1646 */
break;
case 962:
#line 6864 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,DVM_MAP_DIR,SMNULL,(yyvsp[-3].ll_node),LLNULL,(yyvsp[0].ll_node)); }
#line 12279 "gram1.tab.c" /* yacc.c:1646 */
break;
case 963:
#line 6868 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,DVM_PREFETCH_DIR,(yyvsp[0].symbol),LLNULL,LLNULL,LLNULL);}
#line 12285 "gram1.tab.c" /* yacc.c:1646 */
break;
case 964:
#line 6872 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,DVM_RESET_DIR,(yyvsp[0].symbol),LLNULL,LLNULL,LLNULL);}
#line 12291 "gram1.tab.c" /* yacc.c:1646 */
break;
case 965:
#line 6880 "gram1.y" /* yacc.c:1646 */
{ if(!((yyvsp[-3].symbol)->attr & INDIRECT_BIT))
errstr("'%s' is not indirect group name", (yyvsp[-3].symbol)->ident, 313);
(yyval.bf_node) = get_bfnd(fi,DVM_INDIRECT_ACCESS_DIR,(yyvsp[-3].symbol),(yyvsp[-1].ll_node),LLNULL,LLNULL);
}
#line 12300 "gram1.tab.c" /* yacc.c:1646 */
break;
case 966:
#line 6885 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,DVM_INDIRECT_ACCESS_DIR,SMNULL,(yyvsp[-1].ll_node),LLNULL,LLNULL);}
#line 12306 "gram1.tab.c" /* yacc.c:1646 */
break;
case 967:
#line 6899 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
#line 12312 "gram1.tab.c" /* yacc.c:1646 */
break;
case 968:
#line 6901 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
#line 12318 "gram1.tab.c" /* yacc.c:1646 */
break;
case 969:
#line 6905 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
#line 12324 "gram1.tab.c" /* yacc.c:1646 */
break;
case 970:
#line 6907 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[-3].ll_node); (yyval.ll_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);}
#line 12330 "gram1.tab.c" /* yacc.c:1646 */
break;
case 971:
#line 6916 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,HPF_INDEPENDENT_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
#line 12336 "gram1.tab.c" /* yacc.c:1646 */
break;
case 972:
#line 6918 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,HPF_INDEPENDENT_DIR,SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL);}
#line 12342 "gram1.tab.c" /* yacc.c:1646 */
break;
case 973:
#line 6920 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,HPF_INDEPENDENT_DIR,SMNULL, LLNULL, (yyvsp[0].ll_node), LLNULL);}
#line 12348 "gram1.tab.c" /* yacc.c:1646 */
break;
case 974:
#line 6922 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,HPF_INDEPENDENT_DIR,SMNULL, (yyvsp[-1].ll_node), (yyvsp[0].ll_node),LLNULL);}
#line 12354 "gram1.tab.c" /* yacc.c:1646 */
break;
case 975:
#line 6958 "gram1.y" /* yacc.c:1646 */
{(yyval.ll_node) = make_llnd(fi,REDUCTION_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
#line 12360 "gram1.tab.c" /* yacc.c:1646 */
break;
case 976:
#line 6962 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,DVM_ASYNCHRONOUS_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL);}
#line 12366 "gram1.tab.c" /* yacc.c:1646 */
break;
case 977:
#line 6966 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,DVM_ENDASYNCHRONOUS_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
#line 12372 "gram1.tab.c" /* yacc.c:1646 */
break;
case 978:
#line 6970 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,DVM_ASYNCWAIT_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL);}
#line 12378 "gram1.tab.c" /* yacc.c:1646 */
break;
case 979:
#line 6974 "gram1.y" /* yacc.c:1646 */
{
if(((yyval.symbol)=(yyvsp[0].hash_entry)->id_attr) == SMNULL) {
errstr("'%s' is not declared as ASYNCID", (yyvsp[0].hash_entry)->ident, 115);
(yyval.symbol) = make_local_entity((yyvsp[0].hash_entry),ASYNC_ID,global_default,LOCAL);
} else {
if((yyval.symbol)->variant != ASYNC_ID)
errstr("'%s' is not declared as ASYNCID", (yyvsp[0].hash_entry)->ident, 115);
}
}
#line 12392 "gram1.tab.c" /* yacc.c:1646 */
break;
case 980:
#line 6986 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,VAR_REF, LLNULL, LLNULL, (yyvsp[0].symbol));}
#line 12398 "gram1.tab.c" /* yacc.c:1646 */
break;
case 981:
#line 6988 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,ARRAY_REF, (yyvsp[-1].ll_node), LLNULL, (yyvsp[-3].symbol));}
#line 12404 "gram1.tab.c" /* yacc.c:1646 */
break;
case 982:
#line 6992 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,DVM_F90_DIR,SMNULL,(yyvsp[-2].ll_node),(yyvsp[0].ll_node),LLNULL);}
#line 12410 "gram1.tab.c" /* yacc.c:1646 */
break;
case 983:
#line 6995 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,DVM_DEBUG_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL);}
#line 12416 "gram1.tab.c" /* yacc.c:1646 */
break;
case 984:
#line 6997 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,DVM_DEBUG_DIR,SMNULL,(yyvsp[-3].ll_node),(yyvsp[-1].ll_node),LLNULL);}
#line 12422 "gram1.tab.c" /* yacc.c:1646 */
break;
case 985:
#line 7001 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST);
endioctl();
}
#line 12431 "gram1.tab.c" /* yacc.c:1646 */
break;
case 986:
#line 7006 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = set_ll_list((yyvsp[-3].ll_node), (yyvsp[0].ll_node), EXPR_LIST);
endioctl();
}
#line 12440 "gram1.tab.c" /* yacc.c:1646 */
break;
case 987:
#line 7013 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi, KEYWORD_ARG, (yyvsp[-1].ll_node), (yyvsp[0].ll_node), SMNULL); }
#line 12446 "gram1.tab.c" /* yacc.c:1646 */
break;
case 988:
#line 7016 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,INT_VAL, LLNULL, LLNULL, SMNULL);
(yyval.ll_node)->entry.ival = atoi(yytext);
(yyval.ll_node)->type = global_int;
}
#line 12456 "gram1.tab.c" /* yacc.c:1646 */
break;
case 989:
#line 7024 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,DVM_ENDDEBUG_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL);}
#line 12462 "gram1.tab.c" /* yacc.c:1646 */
break;
case 990:
#line 7028 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,DVM_INTERVAL_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL);}
#line 12468 "gram1.tab.c" /* yacc.c:1646 */
break;
case 991:
#line 7032 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = LLNULL;}
#line 12474 "gram1.tab.c" /* yacc.c:1646 */
break;
case 992:
#line 7035 "gram1.y" /* yacc.c:1646 */
{ if((yyvsp[0].ll_node)->type->variant != T_INT)
err("Illegal interval number", 78);
(yyval.ll_node) = (yyvsp[0].ll_node);
}
#line 12483 "gram1.tab.c" /* yacc.c:1646 */
break;
case 993:
#line 7043 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,DVM_EXIT_INTERVAL_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL);}
#line 12489 "gram1.tab.c" /* yacc.c:1646 */
break;
case 994:
#line 7047 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,DVM_ENDINTERVAL_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
#line 12495 "gram1.tab.c" /* yacc.c:1646 */
break;
case 995:
#line 7051 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,DVM_TRACEON_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
#line 12501 "gram1.tab.c" /* yacc.c:1646 */
break;
case 996:
#line 7055 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,DVM_TRACEOFF_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
#line 12507 "gram1.tab.c" /* yacc.c:1646 */
break;
case 997:
#line 7059 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,DVM_BARRIER_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
#line 12513 "gram1.tab.c" /* yacc.c:1646 */
break;
case 998:
#line 7063 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,DVM_CHECK_DIR,SMNULL,(yyvsp[0].ll_node),(yyvsp[-4].ll_node),LLNULL); }
#line 12519 "gram1.tab.c" /* yacc.c:1646 */
break;
case 999:
#line 7067 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,DVM_IO_MODE_DIR,SMNULL,(yyvsp[-1].ll_node),LLNULL,LLNULL);}
#line 12525 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1000:
#line 7070 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
#line 12531 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1001:
#line 7072 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
#line 12537 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1002:
#line 7076 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,ACC_ASYNC_OP,LLNULL,LLNULL,SMNULL);}
#line 12543 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1003:
#line 7078 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,ACC_LOCAL_OP, LLNULL,LLNULL,SMNULL);}
#line 12549 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1004:
#line 7080 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,PARALLEL_OP, LLNULL,LLNULL,SMNULL);}
#line 12555 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1005:
#line 7084 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,DVM_SHADOW_ADD_DIR,SMNULL,(yyvsp[-5].ll_node),(yyvsp[-3].ll_node),(yyvsp[0].ll_node)); }
#line 12561 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1006:
#line 7088 "gram1.y" /* yacc.c:1646 */
{
if((yyvsp[-3].ll_node)->type->variant != T_ARRAY)
errstr("'%s' isn't array", (yyvsp[-3].ll_node)->entry.Template.symbol->ident, 66);
if(!((yyvsp[-3].ll_node)->entry.Template.symbol->attr & TEMPLATE_BIT))
errstr("'%s' isn't TEMPLATE", (yyvsp[-3].ll_node)->entry.Template.symbol->ident, 628);
(yyvsp[-3].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);
(yyval.ll_node) = (yyvsp[-3].ll_node);
/*$$->type = $1->type->entry.ar_decl.base_type;*/
}
#line 12575 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1007:
#line 7100 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
#line 12581 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1008:
#line 7102 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
#line 12587 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1009:
#line 7106 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
#line 12593 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1010:
#line 7108 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
#line 12599 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1011:
#line 7112 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
#line 12605 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1012:
#line 7114 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = LLNULL; opt_kwd_ = NO;}
#line 12611 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1013:
#line 7118 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,DVM_LOCALIZE_DIR,SMNULL,(yyvsp[-3].ll_node),(yyvsp[-1].ll_node),LLNULL); }
#line 12617 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1014:
#line 7122 "gram1.y" /* yacc.c:1646 */
{
if((yyvsp[0].ll_node)->type->variant != T_ARRAY)
errstr("'%s' isn't array", (yyvsp[0].ll_node)->entry.Template.symbol->ident, 66);
(yyval.ll_node) = (yyvsp[0].ll_node);
}
#line 12627 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1015:
#line 7128 "gram1.y" /* yacc.c:1646 */
{
if((yyvsp[-3].ll_node)->type->variant != T_ARRAY)
errstr("'%s' isn't array", (yyvsp[-3].ll_node)->entry.Template.symbol->ident, 66);
(yyvsp[-3].ll_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);
(yyval.ll_node) = (yyvsp[-3].ll_node);
(yyval.ll_node)->type = (yyvsp[-3].ll_node)->type->entry.ar_decl.base_type;
}
#line 12640 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1016:
#line 7140 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
#line 12646 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1017:
#line 7142 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
#line 12652 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1018:
#line 7146 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
#line 12658 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1019:
#line 7148 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,DDOT, LLNULL, LLNULL, SMNULL);}
#line 12664 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1020:
#line 7152 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL, LLNULL, LLNULL, SMNULL);
(yyval.ll_node)->entry.string_val = (char *) "*";
(yyval.ll_node)->type = global_string;
}
#line 12674 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1021:
#line 7160 "gram1.y" /* yacc.c:1646 */
{
PTR_LLND q;
if((yyvsp[0].ll_node))
q = make_llnd(fi,ARRAY_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), SMNULL);
else
q = (yyvsp[-2].ll_node);
(yyval.bf_node) = get_bfnd(fi,DVM_CP_CREATE_DIR,SMNULL,(yyvsp[-13].ll_node),(yyvsp[-8].ll_node),q);
}
#line 12687 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1022:
#line 7171 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = LLNULL; }
#line 12693 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1023:
#line 7173 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi, PARALLEL_OP, LLNULL, LLNULL, SMNULL); }
#line 12699 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1024:
#line 7175 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,ACC_LOCAL_OP, LLNULL, LLNULL, SMNULL); }
#line 12705 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1025:
#line 7179 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,DVM_CP_LOAD_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL); }
#line 12711 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1026:
#line 7183 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,DVM_CP_SAVE_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL); }
#line 12717 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1027:
#line 7185 "gram1.y" /* yacc.c:1646 */
{
PTR_LLND q;
q = make_llnd(fi,ACC_ASYNC_OP,LLNULL,LLNULL,SMNULL);
(yyval.bf_node) = get_bfnd(fi,DVM_CP_SAVE_DIR,SMNULL,(yyvsp[-3].ll_node),q,LLNULL);
}
#line 12727 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1028:
#line 7193 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,DVM_CP_WAIT_DIR,SMNULL,(yyvsp[-6].ll_node),(yyvsp[-1].ll_node),LLNULL); }
#line 12733 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1029:
#line 7197 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,DVM_TEMPLATE_CREATE_DIR,SMNULL,(yyvsp[-1].ll_node),LLNULL,LLNULL); }
#line 12739 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1030:
#line 7200 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); }
#line 12745 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1031:
#line 7202 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); }
#line 12751 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1032:
#line 7206 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,DVM_TEMPLATE_DELETE_DIR,SMNULL,(yyvsp[-1].ll_node),LLNULL,LLNULL); }
#line 12757 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1060:
#line 7240 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = get_bfnd(fi,OMP_ONETHREAD_DIR,SMNULL,LLNULL,LLNULL,LLNULL);
}
#line 12765 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1061:
#line 7246 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = make_endparallel();
}
#line 12773 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1062:
#line 7252 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = make_parallel();
(yyval.bf_node)->entry.Template.ll_ptr1 = (yyvsp[0].ll_node);
opt_kwd_ = NO;
}
#line 12783 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1063:
#line 7258 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = make_parallel();
opt_kwd_ = NO;
}
#line 12792 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1064:
#line 7264 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node),LLNULL,EXPR_LIST);
}
#line 12800 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1065:
#line 7268 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = set_ll_list((yyvsp[-4].ll_node),(yyvsp[-1].ll_node),EXPR_LIST);
}
#line 12808 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1075:
#line 7285 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = (yyvsp[-1].ll_node);
}
#line 12816 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1076:
#line 7290 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,OMP_PRIVATE,(yyvsp[0].ll_node),LLNULL,SMNULL);
}
#line 12824 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1077:
#line 7295 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,OMP_FIRSTPRIVATE,(yyvsp[0].ll_node),LLNULL,SMNULL);
}
#line 12832 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1078:
#line 7301 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,OMP_LASTPRIVATE,(yyvsp[0].ll_node),LLNULL,SMNULL);
}
#line 12840 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1079:
#line 7307 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,OMP_COPYIN,(yyvsp[0].ll_node),LLNULL,SMNULL);
}
#line 12848 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1080:
#line 7313 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,OMP_SHARED,(yyvsp[0].ll_node),LLNULL,SMNULL);
}
#line 12856 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1081:
#line 7318 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,OMP_DEFAULT,(yyvsp[-1].ll_node),LLNULL,SMNULL);
}
#line 12864 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1082:
#line 7324 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
(yyval.ll_node)->entry.string_val = (char *) "private";
(yyval.ll_node)->type = global_string;
}
#line 12874 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1083:
#line 7330 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
(yyval.ll_node)->entry.string_val = (char *) "shared";
(yyval.ll_node)->type = global_string;
}
#line 12884 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1084:
#line 7336 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
(yyval.ll_node)->entry.string_val = (char *) "none";
(yyval.ll_node)->type = global_string;
}
#line 12894 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1085:
#line 7343 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,OMP_IF,(yyvsp[-1].ll_node),LLNULL,SMNULL);
}
#line 12902 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1086:
#line 7349 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,OMP_NUM_THREADS,(yyvsp[-1].ll_node),LLNULL,SMNULL);
}
#line 12910 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1087:
#line 7355 "gram1.y" /* yacc.c:1646 */
{
PTR_LLND q;
q = set_ll_list((yyvsp[-1].ll_node),LLNULL,EXPR_LIST);
(yyval.ll_node) = make_llnd(fi,OMP_REDUCTION,q,LLNULL,SMNULL);
}
#line 12920 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1088:
#line 7362 "gram1.y" /* yacc.c:1646 */
{(yyval.ll_node) = make_llnd(fi,DDOT,(yyvsp[-2].ll_node),(yyvsp[0].ll_node),SMNULL);}
#line 12926 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1090:
#line 7368 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
(yyval.ll_node)->entry.string_val = (char *) "+";
(yyval.ll_node)->type = global_string;
}
#line 12936 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1091:
#line 7374 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
(yyval.ll_node)->entry.string_val = (char *) "-";
(yyval.ll_node)->type = global_string;
}
#line 12946 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1092:
#line 7381 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
(yyval.ll_node)->entry.string_val = (char *) "*";
(yyval.ll_node)->type = global_string;
}
#line 12956 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1093:
#line 7387 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
(yyval.ll_node)->entry.string_val = (char *) "/";
(yyval.ll_node)->type = global_string;
}
#line 12966 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1094:
#line 7393 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
(yyval.ll_node)->entry.string_val = (char *) "min";
(yyval.ll_node)->type = global_string;
}
#line 12976 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1095:
#line 7399 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
(yyval.ll_node)->entry.string_val = (char *) "max";
(yyval.ll_node)->type = global_string;
}
#line 12986 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1096:
#line 7405 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
(yyval.ll_node)->entry.string_val = (char *) ".or.";
(yyval.ll_node)->type = global_string;
}
#line 12996 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1097:
#line 7411 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
(yyval.ll_node)->entry.string_val = (char *) ".and.";
(yyval.ll_node)->type = global_string;
}
#line 13006 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1098:
#line 7417 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
(yyval.ll_node)->entry.string_val = (char *) ".eqv.";
(yyval.ll_node)->type = global_string;
}
#line 13016 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1099:
#line 7423 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
(yyval.ll_node)->entry.string_val = (char *) ".neqv.";
(yyval.ll_node)->type = global_string;
}
#line 13026 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1100:
#line 7429 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
(yyval.ll_node)->entry.string_val = (char *) "iand";
(yyval.ll_node)->type = global_string;
}
#line 13036 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1101:
#line 7435 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
(yyval.ll_node)->entry.string_val = (char *) "ieor";
(yyval.ll_node)->type = global_string;
}
#line 13046 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1102:
#line 7441 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
(yyval.ll_node)->entry.string_val = (char *) "ior";
(yyval.ll_node)->type = global_string;
}
#line 13056 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1103:
#line 7447 "gram1.y" /* yacc.c:1646 */
{ err("Illegal reduction operation name", 70);
errcnt--;
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
(yyval.ll_node)->entry.string_val = (char *) "unknown";
(yyval.ll_node)->type = global_string;
}
#line 13067 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1104:
#line 7457 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = make_sections((yyvsp[0].ll_node));
opt_kwd_ = NO;
}
#line 13076 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1105:
#line 7462 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = make_sections(LLNULL);
opt_kwd_ = NO;
}
#line 13085 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1106:
#line 7468 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node),LLNULL,EXPR_LIST);
}
#line 13093 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1107:
#line 7472 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = set_ll_list((yyvsp[-4].ll_node),(yyvsp[-1].ll_node),EXPR_LIST);
}
#line 13101 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1112:
#line 7484 "gram1.y" /* yacc.c:1646 */
{
PTR_LLND q;
(yyval.bf_node) = make_endsections();
q = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST);
(yyval.bf_node)->entry.Template.ll_ptr1 = q;
opt_kwd_ = NO;
}
#line 13113 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1113:
#line 7492 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = make_endsections();
opt_kwd_ = NO;
}
#line 13122 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1114:
#line 7498 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = make_ompsection();
}
#line 13130 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1115:
#line 7504 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = get_bfnd(fi,OMP_DO_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL);
opt_kwd_ = NO;
}
#line 13139 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1116:
#line 7509 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = get_bfnd(fi,OMP_DO_DIR,SMNULL,LLNULL,LLNULL,LLNULL);
opt_kwd_ = NO;
}
#line 13148 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1117:
#line 7515 "gram1.y" /* yacc.c:1646 */
{
PTR_LLND q;
q = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST);
(yyval.bf_node) = get_bfnd(fi,OMP_END_DO_DIR,SMNULL,q,LLNULL,LLNULL);
opt_kwd_ = NO;
}
#line 13159 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1118:
#line 7522 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = get_bfnd(fi,OMP_END_DO_DIR,SMNULL,LLNULL,LLNULL,LLNULL);
opt_kwd_ = NO;
}
#line 13168 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1119:
#line 7528 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node),LLNULL,EXPR_LIST);
}
#line 13176 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1120:
#line 7532 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = set_ll_list((yyvsp[-4].ll_node),(yyvsp[-1].ll_node),EXPR_LIST);
}
#line 13184 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1127:
#line 7546 "gram1.y" /* yacc.c:1646 */
{
/*$$ = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
$$->entry.string_val = (char *) "ORDERED";
$$->type = global_string;*/
(yyval.ll_node) = make_llnd(fi,OMP_ORDERED,LLNULL,LLNULL,SMNULL);
}
#line 13195 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1128:
#line 7555 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,OMP_SCHEDULE,(yyvsp[-3].ll_node),(yyvsp[-1].ll_node),SMNULL);
}
#line 13203 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1129:
#line 7559 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,OMP_SCHEDULE,(yyvsp[-1].ll_node),LLNULL,SMNULL);
}
#line 13211 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1130:
#line 7565 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
(yyval.ll_node)->entry.string_val = (char *) "STATIC";
(yyval.ll_node)->type = global_string;
}
#line 13222 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1131:
#line 7572 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
(yyval.ll_node)->entry.string_val = (char *) "DYNAMIC";
(yyval.ll_node)->type = global_string;
}
#line 13233 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1132:
#line 7579 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
(yyval.ll_node)->entry.string_val = (char *) "GUIDED";
(yyval.ll_node)->type = global_string;
}
#line 13244 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1133:
#line 7586 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,KEYWORD_VAL,LLNULL,LLNULL,SMNULL);
(yyval.ll_node)->entry.string_val = (char *) "RUNTIME";
(yyval.ll_node)->type = global_string;
}
#line 13255 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1134:
#line 7595 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = make_single();
(yyval.bf_node)->entry.Template.ll_ptr1 = (yyvsp[0].ll_node);
opt_kwd_ = NO;
}
#line 13265 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1135:
#line 7601 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = make_single();
opt_kwd_ = NO;
}
#line 13274 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1136:
#line 7607 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node),LLNULL,EXPR_LIST);
}
#line 13282 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1137:
#line 7611 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = set_ll_list((yyvsp[-4].ll_node),(yyvsp[-1].ll_node),EXPR_LIST);
}
#line 13290 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1140:
#line 7621 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = make_endsingle();
(yyval.bf_node)->entry.Template.ll_ptr1 = (yyvsp[0].ll_node);
opt_kwd_ = NO;
}
#line 13300 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1141:
#line 7627 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = make_endsingle();
opt_kwd_ = NO;
}
#line 13309 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1142:
#line 7633 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node),LLNULL,EXPR_LIST);
}
#line 13317 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1143:
#line 7637 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = set_ll_list((yyvsp[-4].ll_node),(yyvsp[-1].ll_node),EXPR_LIST);
}
#line 13325 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1146:
#line 7648 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,OMP_COPYPRIVATE,(yyvsp[0].ll_node),LLNULL,SMNULL);
}
#line 13333 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1147:
#line 7654 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = make_llnd(fi,OMP_NOWAIT,LLNULL,LLNULL,SMNULL);
}
#line 13341 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1148:
#line 7660 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = make_workshare();
}
#line 13349 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1149:
#line 7665 "gram1.y" /* yacc.c:1646 */
{
PTR_LLND q;
(yyval.bf_node) = make_endworkshare();
q = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST);
(yyval.bf_node)->entry.Template.ll_ptr1 = q;
opt_kwd_ = NO;
}
#line 13361 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1150:
#line 7673 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = make_endworkshare();
opt_kwd_ = NO;
}
#line 13370 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1151:
#line 7679 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = get_bfnd(fi,OMP_PARALLEL_DO_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL);
opt_kwd_ = NO;
}
#line 13379 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1152:
#line 7684 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = get_bfnd(fi,OMP_PARALLEL_DO_DIR,SMNULL,LLNULL,LLNULL,LLNULL);
opt_kwd_ = NO;
}
#line 13388 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1153:
#line 7691 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node),LLNULL,EXPR_LIST);
}
#line 13396 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1154:
#line 7695 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = set_ll_list((yyvsp[-4].ll_node),(yyvsp[-1].ll_node),EXPR_LIST);
}
#line 13404 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1166:
#line 7715 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = get_bfnd(fi,OMP_END_PARALLEL_DO_DIR,SMNULL,LLNULL,LLNULL,LLNULL);
}
#line 13412 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1167:
#line 7720 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = make_parallelsections((yyvsp[0].ll_node));
opt_kwd_ = NO;
}
#line 13421 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1168:
#line 7725 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = make_parallelsections(LLNULL);
opt_kwd_ = NO;
}
#line 13430 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1169:
#line 7732 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = make_endparallelsections();
}
#line 13438 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1170:
#line 7737 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = make_parallelworkshare();
(yyval.bf_node)->entry.Template.ll_ptr1 = (yyvsp[0].ll_node);
opt_kwd_ = NO;
}
#line 13448 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1171:
#line 7743 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = make_parallelworkshare();
opt_kwd_ = NO;
}
#line 13457 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1172:
#line 7749 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = make_endparallelworkshare();
}
#line 13465 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1173:
#line 7754 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = get_bfnd(fi,OMP_THREADPRIVATE_DIR, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL);
}
#line 13473 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1174:
#line 7759 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = make_master();
}
#line 13481 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1175:
#line 7764 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = make_endmaster();
}
#line 13489 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1176:
#line 7768 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = make_ordered();
}
#line 13497 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1177:
#line 7773 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = make_endordered();
}
#line 13505 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1178:
#line 7778 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = get_bfnd(fi,OMP_BARRIER_DIR,SMNULL,LLNULL,LLNULL,LLNULL);
}
#line 13513 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1179:
#line 7782 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = get_bfnd(fi,OMP_ATOMIC_DIR,SMNULL,LLNULL,LLNULL,LLNULL);
}
#line 13521 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1180:
#line 7787 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = get_bfnd(fi,OMP_FLUSH_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL);
}
#line 13529 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1181:
#line 7791 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = get_bfnd(fi,OMP_FLUSH_DIR,SMNULL,LLNULL,LLNULL,LLNULL);
}
#line 13537 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1182:
#line 7797 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = make_critical();
(yyval.bf_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);
}
#line 13546 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1183:
#line 7802 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = make_critical();
}
#line 13554 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1184:
#line 7808 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = make_endcritical();
(yyval.bf_node)->entry.Template.ll_ptr1 = (yyvsp[-1].ll_node);
}
#line 13563 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1185:
#line 7813 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = make_endcritical();
}
#line 13571 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1186:
#line 7819 "gram1.y" /* yacc.c:1646 */
{
PTR_SYMB s;
PTR_LLND l;
s = make_common((yyvsp[-3].hash_entry));
l = make_llnd(fi,VAR_REF, LLNULL, LLNULL, s);
(yyval.ll_node) = make_llnd(fi,OMP_THREADPRIVATE, l, LLNULL, SMNULL);
}
#line 13583 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1187:
#line 7829 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST);
}
#line 13591 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1188:
#line 7833 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST);
}
#line 13599 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1189:
#line 7837 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST);
}
#line 13607 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1190:
#line 7841 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST);
}
#line 13615 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1191:
#line 7846 "gram1.y" /* yacc.c:1646 */
{
operator_slash = 1;
}
#line 13623 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1192:
#line 7849 "gram1.y" /* yacc.c:1646 */
{
operator_slash = 0;
}
#line 13631 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1201:
#line 7865 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,ACC_REGION_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL);}
#line 13637 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1202:
#line 7869 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,ACC_CHECKSECTION_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
#line 13643 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1203:
#line 7873 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,ACC_GET_ACTUAL_DIR,SMNULL,(yyvsp[-1].ll_node),LLNULL,LLNULL);}
#line 13649 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1204:
#line 7875 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,ACC_GET_ACTUAL_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
#line 13655 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1205:
#line 7877 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,ACC_GET_ACTUAL_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
#line 13661 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1206:
#line 7881 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,ACC_ACTUAL_DIR,SMNULL,(yyvsp[-1].ll_node),LLNULL,LLNULL);}
#line 13667 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1207:
#line 7883 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,ACC_ACTUAL_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
#line 13673 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1208:
#line 7885 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,ACC_ACTUAL_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
#line 13679 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1209:
#line 7889 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = LLNULL;}
#line 13685 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1210:
#line 7891 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node); }
#line 13691 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1211:
#line 7895 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
#line 13697 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1212:
#line 7897 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
#line 13703 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1213:
#line 7901 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
#line 13709 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1214:
#line 7904 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
#line 13715 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1215:
#line 7907 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
#line 13721 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1216:
#line 7912 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,ACC_INOUT_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
#line 13727 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1217:
#line 7914 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,ACC_IN_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
#line 13733 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1218:
#line 7916 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,ACC_OUT_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
#line 13739 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1219:
#line 7918 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,ACC_LOCAL_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
#line 13745 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1220:
#line 7920 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,ACC_INLOCAL_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
#line 13751 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1221:
#line 7924 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,ACC_TARGETS_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
#line 13757 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1222:
#line 7928 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,ACC_ASYNC_OP,LLNULL,LLNULL,SMNULL);}
#line 13763 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1223:
#line 7933 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
#line 13769 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1224:
#line 7937 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
#line 13775 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1225:
#line 7939 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
#line 13781 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1226:
#line 7943 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,ACC_HOST_OP, LLNULL,LLNULL,SMNULL);}
#line 13787 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1227:
#line 7945 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,ACC_CUDA_OP, LLNULL,LLNULL,SMNULL);}
#line 13793 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1228:
#line 7949 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,ACC_END_REGION_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
#line 13799 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1229:
#line 7953 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,ACC_END_CHECKSECTION_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
#line 13805 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1230:
#line 7957 "gram1.y" /* yacc.c:1646 */
{
(yyval.bf_node) = get_bfnd(fi,ACC_DECLARE_DIR, SMNULL, (yyvsp[0].ll_node), LLNULL, LLNULL);
}
#line 13813 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1231:
#line 7962 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,EXPR_LIST, (yyvsp[0].ll_node), LLNULL, SMNULL); }
#line 13819 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1232:
#line 7964 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); }
#line 13825 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1233:
#line 7968 "gram1.y" /* yacc.c:1646 */
{
PTR_SYMB s;
s = make_scalar((yyvsp[0].hash_entry),TYNULL,LOCAL);
if((s->attr & PROCESSORS_BIT) ||(s->attr & TASK_BIT) || (s->attr & TEMPLATE_BIT) || (s->attr & ALIGN_BIT) || (s->attr & DISTRIBUTE_BIT) || (s->attr & DYNAMIC_BIT) || (s->attr & HEAP_BIT)|| (s->attr & DVM_POINTER_BIT) || (s->attr & INHERIT_BIT) ||(s->attr & SHADOW_BIT))
errstr("Inconsistent declaration of identifier %s", s->ident, 16);
(yyval.ll_node) = make_llnd(fi,VAR_REF, LLNULL, LLNULL, s);
}
#line 13837 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1234:
#line 7978 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,ACC_ROUTINE_DIR,SMNULL,(yyvsp[0].ll_node),LLNULL,LLNULL);}
#line 13843 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1235:
#line 7982 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = LLNULL;}
#line 13849 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1236:
#line 7984 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
#line 13855 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1237:
#line 7988 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
#line 13861 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1238:
#line 7990 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-1].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
#line 13867 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1239:
#line 7994 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,ACC_PRIVATE_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
#line 13873 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1240:
#line 7996 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[0].ll_node);}
#line 13879 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1247:
#line 8007 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,SPF_ANALYSIS_DIR,SMNULL,(yyvsp[-1].ll_node),LLNULL,LLNULL);}
#line 13885 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1248:
#line 8011 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,SPF_PARALLEL_DIR,SMNULL,(yyvsp[-1].ll_node),LLNULL,LLNULL);}
#line 13891 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1249:
#line 8015 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,SPF_TRANSFORM_DIR,SMNULL,(yyvsp[-1].ll_node),LLNULL,LLNULL);}
#line 13897 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1250:
#line 8019 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,SPF_PARALLEL_REG_DIR,(yyvsp[0].symbol),LLNULL,LLNULL,LLNULL);}
#line 13903 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1251:
#line 8021 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,SPF_PARALLEL_REG_DIR,(yyvsp[-7].symbol),(yyvsp[-2].ll_node),(yyvsp[0].ll_node),LLNULL);}
#line 13909 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1252:
#line 8023 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,SPF_PARALLEL_REG_DIR,(yyvsp[-7].symbol),(yyvsp[0].ll_node),(yyvsp[-2].ll_node),LLNULL);}
#line 13915 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1253:
#line 8027 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
#line 13921 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1254:
#line 8029 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
#line 13927 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1255:
#line 8033 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,SPF_CODE_COVERAGE_OP,LLNULL,LLNULL,SMNULL);}
#line 13933 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1256:
#line 8035 "gram1.y" /* yacc.c:1646 */
{
PTR_LLND w;
w = make_llnd(fi,DOUBLE_VAL, LLNULL, LLNULL, SMNULL);
w->entry.string_val = copys(yytext);
w->type = global_double;
(yyval.ll_node) = make_llnd(fi,SPF_WEIGHT_OP,w,LLNULL,SMNULL);
}
#line 13945 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1257:
#line 8045 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = LLNULL;}
#line 13951 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1258:
#line 8047 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[-1].ll_node);}
#line 13957 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1259:
#line 8051 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = LLNULL;}
#line 13963 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1260:
#line 8053 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = (yyvsp[-1].ll_node);}
#line 13969 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1261:
#line 8057 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,SPF_END_PARALLEL_REG_DIR,SMNULL,LLNULL,LLNULL,LLNULL);}
#line 13975 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1262:
#line 8061 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
#line 13981 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1263:
#line 8063 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
#line 13987 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1269:
#line 8074 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,REDUCTION_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL); }
#line 13993 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1270:
#line 8078 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,ACC_PRIVATE_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
#line 13999 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1271:
#line 8082 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,SPF_PROCESS_PRIVATE_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
#line 14005 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1272:
#line 8086 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,SPF_COVER_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
#line 14011 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1273:
#line 8090 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,SPF_PARAMETER_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
#line 14017 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1274:
#line 8093 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); }
#line 14023 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1275:
#line 8095 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); }
#line 14029 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1276:
#line 8099 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi, ASSGN_OP, (yyvsp[-2].ll_node), (yyvsp[0].ll_node), SMNULL); }
#line 14035 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1277:
#line 8103 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
#line 14041 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1278:
#line 8105 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
#line 14047 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1282:
#line 8114 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,SHADOW_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
#line 14053 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1283:
#line 8118 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,ACROSS_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
#line 14059 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1284:
#line 8122 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,REMOTE_ACCESS_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
#line 14065 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1285:
#line 8126 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
#line 14071 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1286:
#line 8128 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
#line 14077 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1287:
#line 8132 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,SPF_NOINLINE_OP,LLNULL,LLNULL,SMNULL);}
#line 14083 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1288:
#line 8134 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,SPF_FISSION_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
#line 14089 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1289:
#line 8136 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,SPF_EXPAND_OP,LLNULL,LLNULL,SMNULL);}
#line 14095 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1290:
#line 8138 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,SPF_EXPAND_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
#line 14101 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1291:
#line 8141 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,SPF_SHRINK_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
#line 14107 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1292:
#line 8143 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,SPF_UNROLL_OP,LLNULL,LLNULL,SMNULL);}
#line 14113 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1293:
#line 8145 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,SPF_UNROLL_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
#line 14119 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1294:
#line 8147 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,SPF_MERGE_OP,LLNULL,LLNULL,SMNULL);}
#line 14125 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1295:
#line 8151 "gram1.y" /* yacc.c:1646 */
{
(yyval.ll_node) = set_ll_list((yyvsp[-4].ll_node), (yyvsp[-2].ll_node), EXPR_LIST);
(yyval.ll_node) = set_ll_list((yyval.ll_node), (yyvsp[0].ll_node), EXPR_LIST);
}
#line 14134 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1296:
#line 8158 "gram1.y" /* yacc.c:1646 */
{ (yyval.symbol) = make_parallel_region((yyvsp[0].hash_entry));}
#line 14140 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1297:
#line 8162 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node), LLNULL, EXPR_LIST); }
#line 14146 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1298:
#line 8164 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node), (yyvsp[0].ll_node), EXPR_LIST); }
#line 14152 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1299:
#line 8168 "gram1.y" /* yacc.c:1646 */
{ (yyval.bf_node) = get_bfnd(fi,SPF_CHECKPOINT_DIR,SMNULL,(yyvsp[-1].ll_node),LLNULL,LLNULL);}
#line 14158 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1300:
#line 8172 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
#line 14164 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1301:
#line 8174 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
#line 14170 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1302:
#line 8178 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,SPF_TYPE_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
#line 14176 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1303:
#line 8180 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,SPF_VARLIST_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
#line 14182 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1304:
#line 8182 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,SPF_EXCEPT_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
#line 14188 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1305:
#line 8184 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,SPF_FILES_COUNT_OP,(yyvsp[-1].ll_node),LLNULL,SMNULL);}
#line 14194 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1306:
#line 8186 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,SPF_INTERVAL_OP,(yyvsp[-3].ll_node),(yyvsp[-1].ll_node),SMNULL);}
#line 14200 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1307:
#line 8190 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[0].ll_node),LLNULL,EXPR_LIST); }
#line 14206 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1308:
#line 8192 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = set_ll_list((yyvsp[-2].ll_node),(yyvsp[0].ll_node),EXPR_LIST); }
#line 14212 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1309:
#line 8196 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,ACC_ASYNC_OP, LLNULL,LLNULL,SMNULL);}
#line 14218 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1310:
#line 8198 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,SPF_FLEXIBLE_OP, LLNULL,LLNULL,SMNULL);}
#line 14224 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1311:
#line 8202 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,SPF_TIME_OP, LLNULL,LLNULL,SMNULL);}
#line 14230 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1312:
#line 8204 "gram1.y" /* yacc.c:1646 */
{ (yyval.ll_node) = make_llnd(fi,SPF_ITER_OP, LLNULL,LLNULL,SMNULL);}
#line 14236 "gram1.tab.c" /* yacc.c:1646 */
break;
case 1313:
#line 8208 "gram1.y" /* yacc.c:1646 */
{ if(position==IN_OUTSIDE)
err("Misplaced SPF-directive",103);
}
#line 14244 "gram1.tab.c" /* yacc.c:1646 */
break;
#line 14248 "gram1.tab.c" /* yacc.c:1646 */
default: break;
}
/* User semantic actions sometimes alter yychar, and that requires
that yytoken be updated with the new translation. We take the
approach of translating immediately before every use of yytoken.
One alternative is translating here after every semantic action,
but that translation would be missed if the semantic action invokes
YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
incorrect destructor might then be invoked immediately. In the
case of YYERROR or YYBACKUP, subsequent parser actions might lead
to an incorrect destructor call or verbose syntax error message
before the lookahead is translated. */
YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
YYPOPSTACK (yylen);
yylen = 0;
YY_STACK_PRINT (yyss, yyssp);
*++yyvsp = yyval;
/* Now 'shift' the result of the reduction. Determine what state
that goes to, based on the state we popped back to and the rule
number reduced by. */
yyn = yyr1[yyn];
yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
yystate = yytable[yystate];
else
yystate = yydefgoto[yyn - YYNTOKENS];
goto yynewstate;
/*--------------------------------------.
| yyerrlab -- here on detecting error. |
`--------------------------------------*/
yyerrlab:
/* Make sure we have latest lookahead translation. See comments at
user semantic actions for why this is necessary. */
yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
/* If not already recovering from an error, report this error. */
if (!yyerrstatus)
{
++yynerrs;
#if ! YYERROR_VERBOSE
yyerror (YY_("syntax error"));
#else
# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
yyssp, yytoken)
{
char const *yymsgp = YY_("syntax error");
int yysyntax_error_status;
yysyntax_error_status = YYSYNTAX_ERROR;
if (yysyntax_error_status == 0)
yymsgp = yymsg;
else if (yysyntax_error_status == 1)
{
if (yymsg != yymsgbuf)
YYSTACK_FREE (yymsg);
yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
if (!yymsg)
{
yymsg = yymsgbuf;
yymsg_alloc = sizeof yymsgbuf;
yysyntax_error_status = 2;
}
else
{
yysyntax_error_status = YYSYNTAX_ERROR;
yymsgp = yymsg;
}
}
yyerror (yymsgp);
if (yysyntax_error_status == 2)
goto yyexhaustedlab;
}
# undef YYSYNTAX_ERROR
#endif
}
if (yyerrstatus == 3)
{
/* If just tried and failed to reuse lookahead token after an
error, discard it. */
if (yychar <= YYEOF)
{
/* Return failure if at end of input. */
if (yychar == YYEOF)
YYABORT;
}
else
{
yydestruct ("Error: discarding",
yytoken, &yylval);
yychar = YYEMPTY;
}
}
/* Else will try to reuse lookahead token after shifting the error
token. */
goto yyerrlab1;
/*---------------------------------------------------.
| yyerrorlab -- error raised explicitly by YYERROR. |
`---------------------------------------------------*/
yyerrorlab:
/* Pacify compilers like GCC when the user code never invokes
YYERROR and the label yyerrorlab therefore never appears in user
code. */
if (/*CONSTCOND*/ 0)
goto yyerrorlab;
/* Do not reclaim the symbols of the rule whose action triggered
this YYERROR. */
YYPOPSTACK (yylen);
yylen = 0;
YY_STACK_PRINT (yyss, yyssp);
yystate = *yyssp;
goto yyerrlab1;
/*-------------------------------------------------------------.
| yyerrlab1 -- common code for both syntax error and YYERROR. |
`-------------------------------------------------------------*/
yyerrlab1:
yyerrstatus = 3; /* Each real token shifted decrements this. */
for (;;)
{
yyn = yypact[yystate];
if (!yypact_value_is_default (yyn))
{
yyn += YYTERROR;
if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
{
yyn = yytable[yyn];
if (0 < yyn)
break;
}
}
/* Pop the current state because it cannot handle the error token. */
if (yyssp == yyss)
YYABORT;
yydestruct ("Error: popping",
yystos[yystate], yyvsp);
YYPOPSTACK (1);
yystate = *yyssp;
YY_STACK_PRINT (yyss, yyssp);
}
YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
*++yyvsp = yylval;
YY_IGNORE_MAYBE_UNINITIALIZED_END
/* Shift the error token. */
YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
yystate = yyn;
goto yynewstate;
/*-------------------------------------.
| yyacceptlab -- YYACCEPT comes here. |
`-------------------------------------*/
yyacceptlab:
yyresult = 0;
goto yyreturn;
/*-----------------------------------.
| yyabortlab -- YYABORT comes here. |
`-----------------------------------*/
yyabortlab:
yyresult = 1;
goto yyreturn;
#if !defined yyoverflow || YYERROR_VERBOSE
/*-------------------------------------------------.
| yyexhaustedlab -- memory exhaustion comes here. |
`-------------------------------------------------*/
yyexhaustedlab:
yyerror (YY_("memory exhausted"));
yyresult = 2;
/* Fall through. */
#endif
yyreturn:
if (yychar != YYEMPTY)
{
/* Make sure we have latest lookahead translation. See comments at
user semantic actions for why this is necessary. */
yytoken = YYTRANSLATE (yychar);
yydestruct ("Cleanup: discarding lookahead",
yytoken, &yylval);
}
/* Do not reclaim the symbols of the rule whose action triggered
this YYABORT or YYACCEPT. */
YYPOPSTACK (yylen);
YY_STACK_PRINT (yyss, yyssp);
while (yyssp != yyss)
{
yydestruct ("Cleanup: popping",
yystos[*yyssp], yyvsp);
YYPOPSTACK (1);
}
#ifndef yyoverflow
if (yyss != yyssa)
YYSTACK_FREE (yyss);
#endif
#if YYERROR_VERBOSE
if (yymsg != yymsgbuf)
YYSTACK_FREE (yymsg);
#endif
return yyresult;
}
Reference in New Issue View Git Blame Copy Permalink