Changeset 2715 for trunk/NEMOGCM/EXTERNAL/AGRIF/LIB/main.c
- Timestamp:
- 2011-03-30T17:58:35+02:00 (13 years ago)
- File:
-
- 1 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/NEMOGCM/EXTERNAL/AGRIF/LIB/main.c
r2528 r2715 1 #ifndef lint 2 static char yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93"; 3 #endif 4 #define YYBYACC 1 5 #define YYMAJOR 1 6 #define YYMINOR 9 7 #define yyclearin (yychar=(-1)) 8 #define yyerrok (yyerrflag=0) 9 #define YYRECOVERING (yyerrflag!=0) 10 #define YYPREFIX "yy" 11 #line 36 "convert.y" 1 /* A Bison parser, made by GNU Bison 2.3. */ 2 3 /* Skeleton implementation for Bison's Yacc-like parsers in C 4 5 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 6 Free Software Foundation, Inc. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 2, or (at your option) 11 any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program; if not, write to the Free Software 20 Foundation, Inc., 51 Franklin Street, Fifth Floor, 21 Boston, MA 02110-1301, USA. */ 22 23 /* As a special exception, you may create a larger work that contains 24 part or all of the Bison parser skeleton and distribute that work 25 under terms of your choice, so long as that work isn't itself a 26 parser generator using the skeleton or a modified version thereof 27 as a parser skeleton. Alternatively, if you modify or redistribute 28 the parser skeleton itself, you may (at your option) remove this 29 special exception, which will cause the skeleton and the resulting 30 Bison output files to be licensed under the GNU General Public 31 License without this special exception. 32 33 This special exception was added by the Free Software Foundation in 34 version 2.2 of Bison. */ 35 36 /* C LALR(1) parser skeleton written by Richard Stallman, by 37 simplifying the original so-called "semantic" parser. */ 38 39 /* All symbols defined below should begin with yy or YY, to avoid 40 infringing on user name space. This should be done even for local 41 variables, as they might otherwise be expanded by user macros. 42 There are some unavoidable exceptions within include files to 43 define necessary library symbols; they are noted "INFRINGES ON 44 USER NAME SPACE" below. */ 45 46 /* Identify Bison output. */ 47 #define YYBISON 1 48 49 /* Bison version. */ 50 #define YYBISON_VERSION "2.3" 51 52 /* Skeleton name. */ 53 #define YYSKELETON_NAME "yacc.c" 54 55 /* Pure parsers. */ 56 #define YYPURE 0 57 58 /* Using locations. */ 59 #define YYLSP_NEEDED 0 60 61 62 63 /* Tokens. */ 64 #ifndef YYTOKENTYPE 65 # define YYTOKENTYPE 66 /* Put the tokens into the symbol table, so that GDB and other debuggers 67 know about them. */ 68 enum yytokentype { 69 TOK_SEP = 258, 70 TOK_USE = 259, 71 TOK_MODULEMAIN = 260, 72 TOK_NOTGRIDDEP = 261, 73 TOK_USEITEM = 262, 74 TOK_NAME = 263, 75 TOK_PROBTYPE = 264 76 }; 77 #endif 78 /* Tokens. */ 79 #define TOK_SEP 258 80 #define TOK_USE 259 81 #define TOK_MODULEMAIN 260 82 #define TOK_NOTGRIDDEP 261 83 #define TOK_USEITEM 262 84 #define TOK_NAME 263 85 #define TOK_PROBTYPE 264 86 87 88 89 90 /* Copy the first part of user declarations. */ 91 #line 35 "convert.y" 92 12 93 #include <stdlib.h> 13 94 #include <stdio.h> 14 95 #include <string.h> 15 96 #include "decl.h" 97 98 99 /* Enabling traces. */ 100 #ifndef YYDEBUG 101 # define YYDEBUG 1 102 #endif 103 104 /* Enabling verbose error messages. */ 105 #ifdef YYERROR_VERBOSE 106 # undef YYERROR_VERBOSE 107 # define YYERROR_VERBOSE 1 108 #else 109 # define YYERROR_VERBOSE 0 110 #endif 111 112 /* Enabling the token table. */ 113 #ifndef YYTOKEN_TABLE 114 # define YYTOKEN_TABLE 0 115 #endif 116 117 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 118 typedef union YYSTYPE 16 119 #line 42 "convert.y" 17 typedef union{120 { 18 121 int ival; 19 122 char na[LONG_C]; 20 123 listnom * ln; 21 } YYSTYPE; 22 #line 23 "y.tab.c" 23 #define TOK_SEP 257 24 #define TOK_USE 258 25 #define TOK_MODULEMAIN 259 26 #define TOK_NOTGRIDDEP 260 27 #define TOK_USEITEM 261 28 #define TOK_NAME 262 29 #define TOK_PROBTYPE 263 30 #define YYERRCODE 256 31 short yylhs[] = { -1, 32 0, 0, 1, 1, 1, 1, 1, 1, 1, 124 } 125 /* Line 193 of yacc.c. */ 126 #line 127 "convert.tab.c" 127 YYSTYPE; 128 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ 129 # define YYSTYPE_IS_DECLARED 1 130 # define YYSTYPE_IS_TRIVIAL 1 131 #endif 132 133 134 135 /* Copy the second part of user declarations. */ 136 137 138 /* Line 216 of yacc.c. */ 139 #line 140 "convert.tab.c" 140 141 #ifdef short 142 # undef short 143 #endif 144 145 #ifdef YYTYPE_UINT8 146 typedef YYTYPE_UINT8 yytype_uint8; 147 #else 148 typedef unsigned char yytype_uint8; 149 #endif 150 151 #ifdef YYTYPE_INT8 152 typedef YYTYPE_INT8 yytype_int8; 153 #elif (defined __STDC__ || defined __C99__FUNC__ \ 154 || defined __cplusplus || defined _MSC_VER) 155 typedef signed char yytype_int8; 156 #else 157 typedef short int yytype_int8; 158 #endif 159 160 #ifdef YYTYPE_UINT16 161 typedef YYTYPE_UINT16 yytype_uint16; 162 #else 163 typedef unsigned short int yytype_uint16; 164 #endif 165 166 #ifdef YYTYPE_INT16 167 typedef YYTYPE_INT16 yytype_int16; 168 #else 169 typedef short int yytype_int16; 170 #endif 171 172 #ifndef YYSIZE_T 173 # ifdef __SIZE_TYPE__ 174 # define YYSIZE_T __SIZE_TYPE__ 175 # elif defined size_t 176 # define YYSIZE_T size_t 177 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ 178 || defined __cplusplus || defined _MSC_VER) 179 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 180 # define YYSIZE_T size_t 181 # else 182 # define YYSIZE_T unsigned int 183 # endif 184 #endif 185 186 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) 187 188 #ifndef YY_ 189 # if defined YYENABLE_NLS && YYENABLE_NLS 190 # if ENABLE_NLS 191 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 192 # define YY_(msgid) dgettext ("bison-runtime", msgid) 193 # endif 194 # endif 195 # ifndef YY_ 196 # define YY_(msgid) msgid 197 # endif 198 #endif 199 200 /* Suppress unused-variable warnings by "using" E. */ 201 #if ! defined lint || defined __GNUC__ 202 # define YYUSE(e) ((void) (e)) 203 #else 204 # define YYUSE(e) /* empty */ 205 #endif 206 207 /* Identity function, used to suppress warnings about constant conditions. */ 208 #ifndef lint 209 # define YYID(n) (n) 210 #else 211 #if (defined __STDC__ || defined __C99__FUNC__ \ 212 || defined __cplusplus || defined _MSC_VER) 213 static int 214 YYID (int i) 215 #else 216 static int 217 YYID (i) 218 int i; 219 #endif 220 { 221 return i; 222 } 223 #endif 224 225 #if ! defined yyoverflow || YYERROR_VERBOSE 226 227 /* The parser invokes alloca or malloc; define the necessary symbols. */ 228 229 # ifdef YYSTACK_USE_ALLOCA 230 # if YYSTACK_USE_ALLOCA 231 # ifdef __GNUC__ 232 # define YYSTACK_ALLOC __builtin_alloca 233 # elif defined __BUILTIN_VA_ARG_INCR 234 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */ 235 # elif defined _AIX 236 # define YYSTACK_ALLOC __alloca 237 # elif defined _MSC_VER 238 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */ 239 # define alloca _alloca 240 # else 241 # define YYSTACK_ALLOC alloca 242 # if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 243 || defined __cplusplus || defined _MSC_VER) 244 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 245 # ifndef _STDLIB_H 246 # define _STDLIB_H 1 247 # endif 248 # endif 249 # endif 250 # endif 251 # endif 252 253 # ifdef YYSTACK_ALLOC 254 /* Pacify GCC's `empty if-body' warning. */ 255 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) 256 # ifndef YYSTACK_ALLOC_MAXIMUM 257 /* The OS might guarantee only one guard page at the bottom of the stack, 258 and a page size can be as small as 4096 bytes. So we cannot safely 259 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number 260 to allow for a few compiler-allocated temporary stack slots. */ 261 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ 262 # endif 263 # else 264 # define YYSTACK_ALLOC YYMALLOC 265 # define YYSTACK_FREE YYFREE 266 # ifndef YYSTACK_ALLOC_MAXIMUM 267 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM 268 # endif 269 # if (defined __cplusplus && ! defined _STDLIB_H \ 270 && ! ((defined YYMALLOC || defined malloc) \ 271 && (defined YYFREE || defined free))) 272 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 273 # ifndef _STDLIB_H 274 # define _STDLIB_H 1 275 # endif 276 # endif 277 # ifndef YYMALLOC 278 # define YYMALLOC malloc 279 # if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 280 || defined __cplusplus || defined _MSC_VER) 281 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ 282 # endif 283 # endif 284 # ifndef YYFREE 285 # define YYFREE free 286 # if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 287 || defined __cplusplus || defined _MSC_VER) 288 void free (void *); /* INFRINGES ON USER NAME SPACE */ 289 # endif 290 # endif 291 # endif 292 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */ 293 294 295 #if (! defined yyoverflow \ 296 && (! defined __cplusplus \ 297 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) 298 299 /* A type that is properly aligned for any stack member. */ 300 union yyalloc 301 { 302 yytype_int16 yyss; 303 YYSTYPE yyvs; 304 }; 305 306 /* The size of the maximum gap between one aligned stack and the next. */ 307 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 308 309 /* The size of an array large to enough to hold all stacks, each with 310 N elements. */ 311 # define YYSTACK_BYTES(N) \ 312 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ 313 + YYSTACK_GAP_MAXIMUM) 314 315 /* Copy COUNT objects from FROM to TO. The source and destination do 316 not overlap. */ 317 # ifndef YYCOPY 318 # if defined __GNUC__ && 1 < __GNUC__ 319 # define YYCOPY(To, From, Count) \ 320 __builtin_memcpy (To, From, (Count) * sizeof (*(From))) 321 # else 322 # define YYCOPY(To, From, Count) \ 323 do \ 324 { \ 325 YYSIZE_T yyi; \ 326 for (yyi = 0; yyi < (Count); yyi++) \ 327 (To)[yyi] = (From)[yyi]; \ 328 } \ 329 while (YYID (0)) 330 # endif 331 # endif 332 333 /* Relocate STACK from its old location to the new one. The 334 local variables YYSIZE and YYSTACKSIZE give the old and new number of 335 elements in the stack, and YYPTR gives the new location of the 336 stack. Advance YYPTR to a properly aligned location for the next 337 stack. */ 338 # define YYSTACK_RELOCATE(Stack) \ 339 do \ 340 { \ 341 YYSIZE_T yynewbytes; \ 342 YYCOPY (&yyptr->Stack, Stack, yysize); \ 343 Stack = &yyptr->Stack; \ 344 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 345 yyptr += yynewbytes / sizeof (*yyptr); \ 346 } \ 347 while (YYID (0)) 348 349 #endif 350 351 /* YYFINAL -- State number of the termination state. */ 352 #define YYFINAL 2 353 /* YYLAST -- Last index in YYTABLE. */ 354 #define YYLAST 23 355 356 /* YYNTOKENS -- Number of terminals. */ 357 #define YYNTOKENS 18 358 /* YYNNTS -- Number of nonterminals. */ 359 #define YYNNTS 3 360 /* YYNRULES -- Number of rules. */ 361 #define YYNRULES 10 362 /* YYNRULES -- Number of states. */ 363 #define YYNSTATES 24 364 365 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ 366 #define YYUNDEFTOK 2 367 #define YYMAXUTOK 264 368 369 #define YYTRANSLATE(YYX) \ 370 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) 371 372 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ 373 static const yytype_uint8 yytranslate[] = 374 { 375 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 376 17, 2, 2, 2, 2, 2, 2, 2, 2, 2, 377 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 378 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 379 13, 14, 2, 2, 10, 2, 2, 2, 2, 2, 380 2, 2, 2, 2, 2, 2, 2, 2, 12, 11, 381 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 382 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 383 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 384 2, 15, 2, 16, 2, 2, 2, 2, 2, 2, 385 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 386 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 387 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 388 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 389 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 390 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 391 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 392 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 393 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 394 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 395 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 396 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 397 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 398 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 399 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 400 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 401 5, 6, 7, 8, 9 33 402 }; 34 short yylen[] = { 2, 35 0, 2, 1, 3, 5, 7, 3, 4, 3, 403 404 #if YYDEBUG 405 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in 406 YYRHS. */ 407 static const yytype_uint8 yyprhs[] = 408 { 409 0, 0, 3, 4, 7, 9, 13, 19, 27, 31, 410 36 36 411 }; 37 short yydefred[] = { 1, 38 0, 0, 0, 0, 0, 3, 2, 0, 0, 0, 39 0, 9, 7, 0, 0, 4, 8, 0, 0, 5, 40 0, 6, 412 413 /* YYRHS -- A `-1'-separated list of the rules' RHS. */ 414 static const yytype_int8 yyrhs[] = 415 { 416 19, 0, -1, -1, 19, 20, -1, 17, -1, 9, 417 8, 11, -1, 9, 8, 10, 8, 11, -1, 9, 418 8, 10, 8, 10, 8, 11, -1, 5, 8, 11, 419 -1, 6, 3, 8, 11, -1, 4, 7, 11, -1 41 420 }; 42 short yydgoto[] = { 1, 43 7, 421 422 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ 423 static const yytype_uint8 yyrline[] = 424 { 425 0, 63, 63, 64, 66, 67, 68, 69, 71, 74, 426 75 44 427 }; 45 short yysindex[] = { 0, 46 -10, -258, -257, -253, -256, 0, 0, -52, -51, -252, 47 -43, 0, 0, -50, -251, 0, 0, -42, -250, 0, 48 -46, 0, 428 #endif 429 430 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE 431 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 432 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 433 static const char *const yytname[] = 434 { 435 "$end", "error", "$undefined", "TOK_SEP", "TOK_USE", "TOK_MODULEMAIN", 436 "TOK_NOTGRIDDEP", "TOK_USEITEM", "TOK_NAME", "TOK_PROBTYPE", "','", 437 "';'", "':'", "'('", "')'", "'['", "']'", "'\\n'", "$accept", "input", 438 "line", 0 49 439 }; 50 short yyrindex[] = { 0, 51 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 52 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 53 0, 0, 440 #endif 441 442 # ifdef YYPRINT 443 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to 444 token YYLEX-NUM. */ 445 static const yytype_uint16 yytoknum[] = 446 { 447 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 448 44, 59, 58, 40, 41, 91, 93, 10 54 449 }; 55 short yygindex[] = { 0, 56 0, 450 # endif 451 452 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 453 static const yytype_uint8 yyr1[] = 454 { 455 0, 18, 19, 19, 20, 20, 20, 20, 20, 20, 456 20 57 457 }; 58 #define YYTABLESIZE 253 59 short yytable[] = { 6, 60 15, 19, 8, 10, 9, 11, 12, 13, 17, 14, 61 18, 21, 22, 0, 0, 16, 20, 0, 0, 0, 62 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 63 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 64 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 65 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 66 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 67 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 68 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 69 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 70 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 71 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 72 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 73 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 74 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 75 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 76 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 77 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 78 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 79 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 80 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 81 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 82 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 83 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 84 0, 0, 0, 0, 0, 0, 0, 2, 3, 4, 85 0, 0, 5, 458 459 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ 460 static const yytype_uint8 yyr2[] = 461 { 462 0, 2, 0, 2, 1, 3, 5, 7, 3, 4, 463 3 86 464 }; 87 short yycheck[] = { 10, 88 44, 44, 261, 257, 262, 262, 59, 59, 59, 262, 89 262, 262, 59, -1, -1, 59, 59, -1, -1, -1, 90 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 91 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 92 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 93 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 94 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 95 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 96 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 97 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 98 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 99 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 100 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 101 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 102 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 103 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 104 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 105 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 106 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 107 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 108 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 109 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 110 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 111 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 112 -1, -1, -1, -1, -1, -1, -1, 258, 259, 260, 113 -1, -1, 263, 465 466 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state 467 STATE-NUM when YYTABLE doesn't specify something else to do. Zero 468 means the default is an error. */ 469 static const yytype_uint8 yydefact[] = 470 { 471 2, 0, 1, 0, 0, 0, 0, 4, 3, 0, 472 0, 0, 0, 10, 8, 0, 0, 5, 9, 0, 473 0, 6, 0, 7 114 474 }; 115 #define YYFINAL 1 116 #ifndef YYDEBUG 117 #define YYDEBUG 1 118 #endif 119 #define YYMAXTOKEN 263 475 476 /* YYDEFGOTO[NTERM-NUM]. */ 477 static const yytype_int8 yydefgoto[] = 478 { 479 -1, 1, 8 480 }; 481 482 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 483 STATE-NUM. */ 484 #define YYPACT_NINF -10 485 static const yytype_int8 yypact[] = 486 { 487 -10, 0, -10, -4, 2, 8, 4, -10, -10, 3, 488 5, 7, -9, -10, -10, 9, 10, -10, -10, -3, 489 11, -10, 12, -10 490 }; 491 492 /* YYPGOTO[NTERM-NUM]. */ 493 static const yytype_int8 yypgoto[] = 494 { 495 -10, -10, -10 496 }; 497 498 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If 499 positive, shift that token. If negative, reduce the rule which 500 number is the opposite. If zero, do what YYDEFACT says. 501 If YYTABLE_NINF, syntax error. */ 502 #define YYTABLE_NINF -1 503 static const yytype_uint8 yytable[] = 504 { 505 2, 16, 17, 9, 3, 4, 5, 20, 21, 6, 506 10, 11, 12, 0, 13, 15, 14, 7, 19, 22, 507 18, 0, 0, 23 508 }; 509 510 static const yytype_int8 yycheck[] = 511 { 512 0, 10, 11, 7, 4, 5, 6, 10, 11, 9, 513 8, 3, 8, -1, 11, 8, 11, 17, 8, 8, 514 11, -1, -1, 11 515 }; 516 517 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 518 symbol of state STATE-NUM. */ 519 static const yytype_uint8 yystos[] = 520 { 521 0, 19, 0, 4, 5, 6, 9, 17, 20, 7, 522 8, 3, 8, 11, 11, 8, 10, 11, 11, 8, 523 10, 11, 8, 11 524 }; 525 526 #define yyerrok (yyerrstatus = 0) 527 #define yyclearin (yychar = YYEMPTY) 528 #define YYEMPTY (-2) 529 #define YYEOF 0 530 531 #define YYACCEPT goto yyacceptlab 532 #define YYABORT goto yyabortlab 533 #define YYERROR goto yyerrorlab 534 535 536 /* Like YYERROR except do call yyerror. This remains here temporarily 537 to ease the transition to the new meaning of YYERROR, for GCC. 538 Once GCC version 2 has supplanted version 1, this can go. */ 539 540 #define YYFAIL goto yyerrlab 541 542 #define YYRECOVERING() (!!yyerrstatus) 543 544 #define YYBACKUP(Token, Value) \ 545 do \ 546 if (yychar == YYEMPTY && yylen == 1) \ 547 { \ 548 yychar = (Token); \ 549 yylval = (Value); \ 550 yytoken = YYTRANSLATE (yychar); \ 551 YYPOPSTACK (1); \ 552 goto yybackup; \ 553 } \ 554 else \ 555 { \ 556 yyerror (YY_("syntax error: cannot back up")); \ 557 YYERROR; \ 558 } \ 559 while (YYID (0)) 560 561 562 #define YYTERROR 1 563 #define YYERRCODE 256 564 565 566 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. 567 If N is 0, then set CURRENT to the empty location which ends 568 the previous symbol: RHS[0] (always defined). */ 569 570 #define YYRHSLOC(Rhs, K) ((Rhs)[K]) 571 #ifndef YYLLOC_DEFAULT 572 # define YYLLOC_DEFAULT(Current, Rhs, N) \ 573 do \ 574 if (YYID (N)) \ 575 { \ 576 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ 577 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ 578 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ 579 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ 580 } \ 581 else \ 582 { \ 583 (Current).first_line = (Current).last_line = \ 584 YYRHSLOC (Rhs, 0).last_line; \ 585 (Current).first_column = (Current).last_column = \ 586 YYRHSLOC (Rhs, 0).last_column; \ 587 } \ 588 while (YYID (0)) 589 #endif 590 591 592 /* YY_LOCATION_PRINT -- Print the location on the stream. 593 This macro was not mandated originally: define only if we know 594 we won't break user code: when these are the locations we know. */ 595 596 #ifndef YY_LOCATION_PRINT 597 # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL 598 # define YY_LOCATION_PRINT(File, Loc) \ 599 fprintf (File, "%d.%d-%d.%d", \ 600 (Loc).first_line, (Loc).first_column, \ 601 (Loc).last_line, (Loc).last_column) 602 # else 603 # define YY_LOCATION_PRINT(File, Loc) ((void) 0) 604 # endif 605 #endif 606 607 608 /* YYLEX -- calling `yylex' with the right arguments. */ 609 610 #ifdef YYLEX_PARAM 611 # define YYLEX yylex (YYLEX_PARAM) 612 #else 613 # define YYLEX yylex () 614 #endif 615 616 /* Enable debugging if requested. */ 120 617 #if YYDEBUG 121 char *yyname[] = { 122 "end-of-file",0,0,0,0,0,0,0,0,0,"'\\n'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 123 0,0,0,0,0,0,0,0,0,"'('","')'",0,0,"','",0,0,0,0,0,0,0,0,0,0,0,0,0,"':'","';'",0, 124 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'['",0,"']'",0,0,0, 125 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 126 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 127 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 128 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 129 "TOK_SEP","TOK_USE","TOK_MODULEMAIN","TOK_NOTGRIDDEP","TOK_USEITEM","TOK_NAME", 130 "TOK_PROBTYPE", 131 }; 132 char *yyrule[] = { 133 "$accept : input", 134 "input :", 135 "input : input line", 136 "line : '\\n'", 137 "line : TOK_PROBTYPE TOK_NAME ';'", 138 "line : TOK_PROBTYPE TOK_NAME ',' TOK_NAME ';'", 139 "line : TOK_PROBTYPE TOK_NAME ',' TOK_NAME ',' TOK_NAME ';'", 140 "line : TOK_MODULEMAIN TOK_NAME ';'", 141 "line : TOK_NOTGRIDDEP TOK_SEP TOK_NAME ';'", 142 "line : TOK_USE TOK_USEITEM ';'", 143 }; 144 #endif 145 #ifdef YYSTACKSIZE 146 #undef YYMAXDEPTH 147 #define YYMAXDEPTH YYSTACKSIZE 618 619 # ifndef YYFPRINTF 620 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 621 # define YYFPRINTF fprintf 622 # endif 623 624 # define YYDPRINTF(Args) \ 625 do { \ 626 if (yydebug) \ 627 YYFPRINTF Args; \ 628 } while (YYID (0)) 629 630 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ 631 do { \ 632 if (yydebug) \ 633 { \ 634 YYFPRINTF (stderr, "%s ", Title); \ 635 yy_symbol_print (stderr, \ 636 Type, Value); \ 637 YYFPRINTF (stderr, "\n"); \ 638 } \ 639 } while (YYID (0)) 640 641 642 /*--------------------------------. 643 | Print this symbol on YYOUTPUT. | 644 `--------------------------------*/ 645 646 /*ARGSUSED*/ 647 #if (defined __STDC__ || defined __C99__FUNC__ \ 648 || defined __cplusplus || defined _MSC_VER) 649 static void 650 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 148 651 #else 149 #ifdef YYMAXDEPTH 150 #define YYSTACKSIZE YYMAXDEPTH 652 static void 653 yy_symbol_value_print (yyoutput, yytype, yyvaluep) 654 FILE *yyoutput; 655 int yytype; 656 YYSTYPE const * const yyvaluep; 657 #endif 658 { 659 if (!yyvaluep) 660 return; 661 # ifdef YYPRINT 662 if (yytype < YYNTOKENS) 663 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); 664 # else 665 YYUSE (yyoutput); 666 # endif 667 switch (yytype) 668 { 669 default: 670 break; 671 } 672 } 673 674 675 /*--------------------------------. 676 | Print this symbol on YYOUTPUT. | 677 `--------------------------------*/ 678 679 #if (defined __STDC__ || defined __C99__FUNC__ \ 680 || defined __cplusplus || defined _MSC_VER) 681 static void 682 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 151 683 #else 152 #define YYSTACKSIZE 500 153 #define YYMAXDEPTH 500 154 #endif 155 #endif 684 static void 685 yy_symbol_print (yyoutput, yytype, yyvaluep) 686 FILE *yyoutput; 687 int yytype; 688 YYSTYPE const * const yyvaluep; 689 #endif 690 { 691 if (yytype < YYNTOKENS) 692 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); 693 else 694 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); 695 696 yy_symbol_value_print (yyoutput, yytype, yyvaluep); 697 YYFPRINTF (yyoutput, ")"); 698 } 699 700 /*------------------------------------------------------------------. 701 | yy_stack_print -- Print the state stack from its BOTTOM up to its | 702 | TOP (included). | 703 `------------------------------------------------------------------*/ 704 705 #if (defined __STDC__ || defined __C99__FUNC__ \ 706 || defined __cplusplus || defined _MSC_VER) 707 static void 708 yy_stack_print (yytype_int16 *bottom, yytype_int16 *top) 709 #else 710 static void 711 yy_stack_print (bottom, top) 712 yytype_int16 *bottom; 713 yytype_int16 *top; 714 #endif 715 { 716 YYFPRINTF (stderr, "Stack now"); 717 for (; bottom <= top; ++bottom) 718 YYFPRINTF (stderr, " %d", *bottom); 719 YYFPRINTF (stderr, "\n"); 720 } 721 722 # define YY_STACK_PRINT(Bottom, Top) \ 723 do { \ 724 if (yydebug) \ 725 yy_stack_print ((Bottom), (Top)); \ 726 } while (YYID (0)) 727 728 729 /*------------------------------------------------. 730 | Report that the YYRULE is going to be reduced. | 731 `------------------------------------------------*/ 732 733 #if (defined __STDC__ || defined __C99__FUNC__ \ 734 || defined __cplusplus || defined _MSC_VER) 735 static void 736 yy_reduce_print (YYSTYPE *yyvsp, int yyrule) 737 #else 738 static void 739 yy_reduce_print (yyvsp, yyrule) 740 YYSTYPE *yyvsp; 741 int yyrule; 742 #endif 743 { 744 int yynrhs = yyr2[yyrule]; 745 int yyi; 746 unsigned long int yylno = yyrline[yyrule]; 747 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", 748 yyrule - 1, yylno); 749 /* The symbols being reduced. */ 750 for (yyi = 0; yyi < yynrhs; yyi++) 751 { 752 fprintf (stderr, " $%d = ", yyi + 1); 753 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], 754 &(yyvsp[(yyi + 1) - (yynrhs)]) 755 ); 756 fprintf (stderr, "\n"); 757 } 758 } 759 760 # define YY_REDUCE_PRINT(Rule) \ 761 do { \ 762 if (yydebug) \ 763 yy_reduce_print (yyvsp, Rule); \ 764 } while (YYID (0)) 765 766 /* Nonzero means print parse trace. It is left uninitialized so that 767 multiple parsers can coexist. */ 156 768 int yydebug; 769 #else /* !YYDEBUG */ 770 # define YYDPRINTF(Args) 771 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) 772 # define YY_STACK_PRINT(Bottom, Top) 773 # define YY_REDUCE_PRINT(Rule) 774 #endif /* !YYDEBUG */ 775 776 777 /* YYINITDEPTH -- initial size of the parser's stacks. */ 778 #ifndef YYINITDEPTH 779 # define YYINITDEPTH 200 780 #endif 781 782 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 783 if the built-in stack extension method is used). 784 785 Do not make this value too large; the results are undefined if 786 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) 787 evaluated with infinite-precision integer arithmetic. */ 788 789 #ifndef YYMAXDEPTH 790 # define YYMAXDEPTH 10000 791 #endif 792 793 794 795 796 #if YYERROR_VERBOSE 797 798 # ifndef yystrlen 799 # if defined __GLIBC__ && defined _STRING_H 800 # define yystrlen strlen 801 # else 802 /* Return the length of YYSTR. */ 803 #if (defined __STDC__ || defined __C99__FUNC__ \ 804 || defined __cplusplus || defined _MSC_VER) 805 static YYSIZE_T 806 yystrlen (const char *yystr) 807 #else 808 static YYSIZE_T 809 yystrlen (yystr) 810 const char *yystr; 811 #endif 812 { 813 YYSIZE_T yylen; 814 for (yylen = 0; yystr[yylen]; yylen++) 815 continue; 816 return yylen; 817 } 818 # endif 819 # endif 820 821 # ifndef yystpcpy 822 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE 823 # define yystpcpy stpcpy 824 # else 825 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 826 YYDEST. */ 827 #if (defined __STDC__ || defined __C99__FUNC__ \ 828 || defined __cplusplus || defined _MSC_VER) 829 static char * 830 yystpcpy (char *yydest, const char *yysrc) 831 #else 832 static char * 833 yystpcpy (yydest, yysrc) 834 char *yydest; 835 const char *yysrc; 836 #endif 837 { 838 char *yyd = yydest; 839 const char *yys = yysrc; 840 841 while ((*yyd++ = *yys++) != '\0') 842 continue; 843 844 return yyd - 1; 845 } 846 # endif 847 # endif 848 849 # ifndef yytnamerr 850 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary 851 quotes and backslashes, so that it's suitable for yyerror. The 852 heuristic is that double-quoting is unnecessary unless the string 853 contains an apostrophe, a comma, or backslash (other than 854 backslash-backslash). YYSTR is taken from yytname. If YYRES is 855 null, do not copy; instead, return the length of what the result 856 would have been. */ 857 static YYSIZE_T 858 yytnamerr (char *yyres, const char *yystr) 859 { 860 if (*yystr == '"') 861 { 862 YYSIZE_T yyn = 0; 863 char const *yyp = yystr; 864 865 for (;;) 866 switch (*++yyp) 867 { 868 case '\'': 869 case ',': 870 goto do_not_strip_quotes; 871 872 case '\\': 873 if (*++yyp != '\\') 874 goto do_not_strip_quotes; 875 /* Fall through. */ 876 default: 877 if (yyres) 878 yyres[yyn] = *yyp; 879 yyn++; 880 break; 881 882 case '"': 883 if (yyres) 884 yyres[yyn] = '\0'; 885 return yyn; 886 } 887 do_not_strip_quotes: ; 888 } 889 890 if (! yyres) 891 return yystrlen (yystr); 892 893 return yystpcpy (yyres, yystr) - yyres; 894 } 895 # endif 896 897 /* Copy into YYRESULT an error message about the unexpected token 898 YYCHAR while in state YYSTATE. Return the number of bytes copied, 899 including the terminating null byte. If YYRESULT is null, do not 900 copy anything; just return the number of bytes that would be 901 copied. As a special case, return 0 if an ordinary "syntax error" 902 message will do. Return YYSIZE_MAXIMUM if overflow occurs during 903 size calculation. */ 904 static YYSIZE_T 905 yysyntax_error (char *yyresult, int yystate, int yychar) 906 { 907 int yyn = yypact[yystate]; 908 909 if (! (YYPACT_NINF < yyn && yyn <= YYLAST)) 910 return 0; 911 else 912 { 913 int yytype = YYTRANSLATE (yychar); 914 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); 915 YYSIZE_T yysize = yysize0; 916 YYSIZE_T yysize1; 917 int yysize_overflow = 0; 918 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 919 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 920 int yyx; 921 922 # if 0 923 /* This is so xgettext sees the translatable formats that are 924 constructed on the fly. */ 925 YY_("syntax error, unexpected %s"); 926 YY_("syntax error, unexpected %s, expecting %s"); 927 YY_("syntax error, unexpected %s, expecting %s or %s"); 928 YY_("syntax error, unexpected %s, expecting %s or %s or %s"); 929 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); 930 # endif 931 char *yyfmt; 932 char const *yyf; 933 static char const yyunexpected[] = "syntax error, unexpected %s"; 934 static char const yyexpecting[] = ", expecting %s"; 935 static char const yyor[] = " or %s"; 936 char yyformat[sizeof yyunexpected 937 + sizeof yyexpecting - 1 938 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) 939 * (sizeof yyor - 1))]; 940 char const *yyprefix = yyexpecting; 941 942 /* Start YYX at -YYN if negative to avoid negative indexes in 943 YYCHECK. */ 944 int yyxbegin = yyn < 0 ? -yyn : 0; 945 946 /* Stay within bounds of both yycheck and yytname. */ 947 int yychecklim = YYLAST - yyn + 1; 948 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 949 int yycount = 1; 950 951 yyarg[0] = yytname[yytype]; 952 yyfmt = yystpcpy (yyformat, yyunexpected); 953 954 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 955 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) 956 { 957 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) 958 { 959 yycount = 1; 960 yysize = yysize0; 961 yyformat[sizeof yyunexpected - 1] = '\0'; 962 break; 963 } 964 yyarg[yycount++] = yytname[yyx]; 965 yysize1 = yysize + yytnamerr (0, yytname[yyx]); 966 yysize_overflow |= (yysize1 < yysize); 967 yysize = yysize1; 968 yyfmt = yystpcpy (yyfmt, yyprefix); 969 yyprefix = yyor; 970 } 971 972 yyf = YY_(yyformat); 973 yysize1 = yysize + yystrlen (yyf); 974 yysize_overflow |= (yysize1 < yysize); 975 yysize = yysize1; 976 977 if (yysize_overflow) 978 return YYSIZE_MAXIMUM; 979 980 if (yyresult) 981 { 982 /* Avoid sprintf, as that infringes on the user's name space. 983 Don't have undefined behavior even if the translation 984 produced a string with the wrong number of "%s"s. */ 985 char *yyp = yyresult; 986 int yyi = 0; 987 while ((*yyp = *yyf) != '\0') 988 { 989 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) 990 { 991 yyp += yytnamerr (yyp, yyarg[yyi++]); 992 yyf += 2; 993 } 994 else 995 { 996 yyp++; 997 yyf++; 998 } 999 } 1000 } 1001 return yysize; 1002 } 1003 } 1004 #endif /* YYERROR_VERBOSE */ 1005 1006 1007 1008 /*-----------------------------------------------. 1009 | Release the memory associated to this symbol. | 1010 `-----------------------------------------------*/ 1011 1012 /*ARGSUSED*/ 1013 #if (defined __STDC__ || defined __C99__FUNC__ \ 1014 || defined __cplusplus || defined _MSC_VER) 1015 static void 1016 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) 1017 #else 1018 static void 1019 yydestruct (yymsg, yytype, yyvaluep) 1020 const char *yymsg; 1021 int yytype; 1022 YYSTYPE *yyvaluep; 1023 #endif 1024 { 1025 YYUSE (yyvaluep); 1026 1027 if (!yymsg) 1028 yymsg = "Deleting"; 1029 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 1030 1031 switch (yytype) 1032 { 1033 1034 default: 1035 break; 1036 } 1037 } 1038 1039 1040 1041 /* Prevent warnings from -Wmissing-prototypes. */ 1042 1043 #ifdef YYPARSE_PARAM 1044 #if defined __STDC__ || defined __cplusplus 1045 int yyparse (void *YYPARSE_PARAM); 1046 #else 1047 int yyparse (); 1048 #endif 1049 #else /* ! YYPARSE_PARAM */ 1050 #if defined __STDC__ || defined __cplusplus 1051 int yyparse (void); 1052 #else 1053 int yyparse (); 1054 #endif 1055 #endif /* ! YYPARSE_PARAM */ 1056 1057 1058 1059 /* The look-ahead symbol. */ 1060 int yychar; 1061 1062 /* The semantic value of the look-ahead symbol. */ 1063 YYSTYPE yylval; 1064 1065 /* Number of syntax errors so far. */ 157 1066 int yynerrs; 158 int yyerrflag; 159 int yychar; 160 short *yyssp; 161 YYSTYPE *yyvsp; 162 YYSTYPE yyval; 163 YYSTYPE yylval; 164 short yyss[YYSTACKSIZE]; 165 YYSTYPE yyvs[YYSTACKSIZE]; 166 #define yystacksize YYSTACKSIZE 167 #line 83 "convert.y" 1067 1068 1069 1070 /*----------. 1071 | yyparse. | 1072 `----------*/ 1073 1074 #ifdef YYPARSE_PARAM 1075 #if (defined __STDC__ || defined __C99__FUNC__ \ 1076 || defined __cplusplus || defined _MSC_VER) 1077 int 1078 yyparse (void *YYPARSE_PARAM) 1079 #else 1080 int 1081 yyparse (YYPARSE_PARAM) 1082 void *YYPARSE_PARAM; 1083 #endif 1084 #else /* ! YYPARSE_PARAM */ 1085 #if (defined __STDC__ || defined __C99__FUNC__ \ 1086 || defined __cplusplus || defined _MSC_VER) 1087 int 1088 yyparse (void) 1089 #else 1090 int 1091 yyparse () 1092 1093 #endif 1094 #endif 1095 { 1096 1097 int yystate; 1098 int yyn; 1099 int yyresult; 1100 /* Number of tokens to shift before error messages enabled. */ 1101 int yyerrstatus; 1102 /* Look-ahead token as an internal (translated) token number. */ 1103 int yytoken = 0; 1104 #if YYERROR_VERBOSE 1105 /* Buffer for error messages, and its allocated size. */ 1106 char yymsgbuf[128]; 1107 char *yymsg = yymsgbuf; 1108 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 1109 #endif 1110 1111 /* Three stacks and their tools: 1112 `yyss': related to states, 1113 `yyvs': related to semantic values, 1114 `yyls': related to locations. 1115 1116 Refer to the stacks thru separate pointers, to allow yyoverflow 1117 to reallocate them elsewhere. */ 1118 1119 /* The state stack. */ 1120 yytype_int16 yyssa[YYINITDEPTH]; 1121 yytype_int16 *yyss = yyssa; 1122 yytype_int16 *yyssp; 1123 1124 /* The semantic value stack. */ 1125 YYSTYPE yyvsa[YYINITDEPTH]; 1126 YYSTYPE *yyvs = yyvsa; 1127 YYSTYPE *yyvsp; 1128 1129 1130 1131 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 1132 1133 YYSIZE_T yystacksize = YYINITDEPTH; 1134 1135 /* The variables used to return semantic value and location from the 1136 action routines. */ 1137 YYSTYPE yyval; 1138 1139 1140 /* The number of symbols on the RHS of the reduced rule. 1141 Keep to zero when no symbol should be popped. */ 1142 int yylen = 0; 1143 1144 YYDPRINTF ((stderr, "Starting parse\n")); 1145 1146 yystate = 0; 1147 yyerrstatus = 0; 1148 yynerrs = 0; 1149 yychar = YYEMPTY; /* Cause a token to be read. */ 1150 1151 /* Initialize stack pointers. 1152 Waste one element of value and location stack 1153 so that they stay on the same level as the state stack. 1154 The wasted elements are never initialized. */ 1155 1156 yyssp = yyss; 1157 yyvsp = yyvs; 1158 1159 goto yysetstate; 1160 1161 /*------------------------------------------------------------. 1162 | yynewstate -- Push a new state, which is found in yystate. | 1163 `------------------------------------------------------------*/ 1164 yynewstate: 1165 /* In all cases, when you get here, the value and location stacks 1166 have just been pushed. So pushing a state here evens the stacks. */ 1167 yyssp++; 1168 1169 yysetstate: 1170 *yyssp = yystate; 1171 1172 if (yyss + yystacksize - 1 <= yyssp) 1173 { 1174 /* Get the current used size of the three stacks, in elements. */ 1175 YYSIZE_T yysize = yyssp - yyss + 1; 1176 1177 #ifdef yyoverflow 1178 { 1179 /* Give user a chance to reallocate the stack. Use copies of 1180 these so that the &'s don't force the real ones into 1181 memory. */ 1182 YYSTYPE *yyvs1 = yyvs; 1183 yytype_int16 *yyss1 = yyss; 1184 1185 1186 /* Each stack pointer address is followed by the size of the 1187 data in use in that stack, in bytes. This used to be a 1188 conditional around just the two extra args, but that might 1189 be undefined if yyoverflow is a macro. */ 1190 yyoverflow (YY_("memory exhausted"), 1191 &yyss1, yysize * sizeof (*yyssp), 1192 &yyvs1, yysize * sizeof (*yyvsp), 1193 1194 &yystacksize); 1195 1196 yyss = yyss1; 1197 yyvs = yyvs1; 1198 } 1199 #else /* no yyoverflow */ 1200 # ifndef YYSTACK_RELOCATE 1201 goto yyexhaustedlab; 1202 # else 1203 /* Extend the stack our own way. */ 1204 if (YYMAXDEPTH <= yystacksize) 1205 goto yyexhaustedlab; 1206 yystacksize *= 2; 1207 if (YYMAXDEPTH < yystacksize) 1208 yystacksize = YYMAXDEPTH; 1209 1210 { 1211 yytype_int16 *yyss1 = yyss; 1212 union yyalloc *yyptr = 1213 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 1214 if (! yyptr) 1215 goto yyexhaustedlab; 1216 YYSTACK_RELOCATE (yyss); 1217 YYSTACK_RELOCATE (yyvs); 1218 1219 # undef YYSTACK_RELOCATE 1220 if (yyss1 != yyssa) 1221 YYSTACK_FREE (yyss1); 1222 } 1223 # endif 1224 #endif /* no yyoverflow */ 1225 1226 yyssp = yyss + yysize - 1; 1227 yyvsp = yyvs + yysize - 1; 1228 1229 1230 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 1231 (unsigned long int) yystacksize)); 1232 1233 if (yyss + yystacksize - 1 <= yyssp) 1234 YYABORT; 1235 } 1236 1237 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 1238 1239 goto yybackup; 1240 1241 /*-----------. 1242 | yybackup. | 1243 `-----------*/ 1244 yybackup: 1245 1246 /* Do appropriate processing given the current state. Read a 1247 look-ahead token if we need one and don't already have one. */ 1248 1249 /* First try to decide what to do without reference to look-ahead token. */ 1250 yyn = yypact[yystate]; 1251 if (yyn == YYPACT_NINF) 1252 goto yydefault; 1253 1254 /* Not known => get a look-ahead token if don't already have one. */ 1255 1256 /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */ 1257 if (yychar == YYEMPTY) 1258 { 1259 YYDPRINTF ((stderr, "Reading a token: ")); 1260 yychar = YYLEX; 1261 } 1262 1263 if (yychar <= YYEOF) 1264 { 1265 yychar = yytoken = YYEOF; 1266 YYDPRINTF ((stderr, "Now at end of input.\n")); 1267 } 1268 else 1269 { 1270 yytoken = YYTRANSLATE (yychar); 1271 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 1272 } 1273 1274 /* If the proper action on seeing token YYTOKEN is to reduce or to 1275 detect an error, take that action. */ 1276 yyn += yytoken; 1277 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 1278 goto yydefault; 1279 yyn = yytable[yyn]; 1280 if (yyn <= 0) 1281 { 1282 if (yyn == 0 || yyn == YYTABLE_NINF) 1283 goto yyerrlab; 1284 yyn = -yyn; 1285 goto yyreduce; 1286 } 1287 1288 if (yyn == YYFINAL) 1289 YYACCEPT; 1290 1291 /* Count tokens shifted since error; after three, turn off error 1292 status. */ 1293 if (yyerrstatus) 1294 yyerrstatus--; 1295 1296 /* Shift the look-ahead token. */ 1297 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 1298 1299 /* Discard the shifted token unless it is eof. */ 1300 if (yychar != YYEOF) 1301 yychar = YYEMPTY; 1302 1303 yystate = yyn; 1304 *++yyvsp = yylval; 1305 1306 goto yynewstate; 1307 1308 1309 /*-----------------------------------------------------------. 1310 | yydefault -- do the default action for the current state. | 1311 `-----------------------------------------------------------*/ 1312 yydefault: 1313 yyn = yydefact[yystate]; 1314 if (yyn == 0) 1315 goto yyerrlab; 1316 goto yyreduce; 1317 1318 1319 /*-----------------------------. 1320 | yyreduce -- Do a reduction. | 1321 `-----------------------------*/ 1322 yyreduce: 1323 /* yyn is the number of a rule to reduce with. */ 1324 yylen = yyr2[yyn]; 1325 1326 /* If YYLEN is nonzero, implement the default value of the action: 1327 `$$ = $1'. 1328 1329 Otherwise, the following line sets YYVAL to garbage. 1330 This behavior is undocumented and Bison 1331 users should not rely upon it. Assigning to YYVAL 1332 unconditionally makes the parser a bit smaller, and it avoids a 1333 GCC warning that YYVAL may be used uninitialized. */ 1334 yyval = yyvsp[1-yylen]; 1335 1336 1337 YY_REDUCE_PRINT (yyn); 1338 switch (yyn) 1339 { 1340 case 5: 1341 #line 67 "convert.y" 1342 {initdimprob(1,(yyvsp[(2) - (3)].na),"0","0");;} 1343 break; 1344 1345 case 6: 1346 #line 68 "convert.y" 1347 {initdimprob(2,(yyvsp[(2) - (5)].na), (yyvsp[(4) - (5)].na),"0");;} 1348 break; 1349 1350 case 7: 1351 #line 70 "convert.y" 1352 {initdimprob(3,(yyvsp[(2) - (7)].na), (yyvsp[(4) - (7)].na), (yyvsp[(6) - (7)].na));;} 1353 break; 1354 1355 case 8: 1356 #line 72 "convert.y" 1357 {listofmodules = Addtolistnom((yyvsp[(2) - (3)].na),listofmodules,0); 1358 Addmoduletothelist((yyvsp[(2) - (3)].na));;} 1359 break; 1360 1361 case 9: 1362 #line 74 "convert.y" 1363 {Add_NotGridDepend_Var_1((yyvsp[(3) - (4)].na));;} 1364 break; 1365 1366 case 10: 1367 #line 75 "convert.y" 1368 { 1369 if (!strcasecmp((yyvsp[(2) - (3)].na),"FIXED_GRIDS")) 1370 fixedgrids=1; 1371 if (!strcasecmp((yyvsp[(2) - (3)].na),"ONLY_FIXED_GRIDS")) 1372 onlyfixedgrids=1; 1373 ;} 1374 break; 1375 1376 1377 /* Line 1267 of yacc.c. */ 1378 #line 1376 "convert.tab.c" 1379 default: break; 1380 } 1381 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 1382 1383 YYPOPSTACK (yylen); 1384 yylen = 0; 1385 YY_STACK_PRINT (yyss, yyssp); 1386 1387 *++yyvsp = yyval; 1388 1389 1390 /* Now `shift' the result of the reduction. Determine what state 1391 that goes to, based on the state we popped back to and the rule 1392 number reduced by. */ 1393 1394 yyn = yyr1[yyn]; 1395 1396 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 1397 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 1398 yystate = yytable[yystate]; 1399 else 1400 yystate = yydefgoto[yyn - YYNTOKENS]; 1401 1402 goto yynewstate; 1403 1404 1405 /*------------------------------------. 1406 | yyerrlab -- here on detecting error | 1407 `------------------------------------*/ 1408 yyerrlab: 1409 /* If not already recovering from an error, report this error. */ 1410 if (!yyerrstatus) 1411 { 1412 ++yynerrs; 1413 #if ! YYERROR_VERBOSE 1414 yyerror (YY_("syntax error")); 1415 #else 1416 { 1417 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); 1418 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) 1419 { 1420 YYSIZE_T yyalloc = 2 * yysize; 1421 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) 1422 yyalloc = YYSTACK_ALLOC_MAXIMUM; 1423 if (yymsg != yymsgbuf) 1424 YYSTACK_FREE (yymsg); 1425 yymsg = (char *) YYSTACK_ALLOC (yyalloc); 1426 if (yymsg) 1427 yymsg_alloc = yyalloc; 1428 else 1429 { 1430 yymsg = yymsgbuf; 1431 yymsg_alloc = sizeof yymsgbuf; 1432 } 1433 } 1434 1435 if (0 < yysize && yysize <= yymsg_alloc) 1436 { 1437 (void) yysyntax_error (yymsg, yystate, yychar); 1438 yyerror (yymsg); 1439 } 1440 else 1441 { 1442 yyerror (YY_("syntax error")); 1443 if (yysize != 0) 1444 goto yyexhaustedlab; 1445 } 1446 } 1447 #endif 1448 } 1449 1450 1451 1452 if (yyerrstatus == 3) 1453 { 1454 /* If just tried and failed to reuse look-ahead token after an 1455 error, discard it. */ 1456 1457 if (yychar <= YYEOF) 1458 { 1459 /* Return failure if at end of input. */ 1460 if (yychar == YYEOF) 1461 YYABORT; 1462 } 1463 else 1464 { 1465 yydestruct ("Error: discarding", 1466 yytoken, &yylval); 1467 yychar = YYEMPTY; 1468 } 1469 } 1470 1471 /* Else will try to reuse look-ahead token after shifting the error 1472 token. */ 1473 goto yyerrlab1; 1474 1475 1476 /*---------------------------------------------------. 1477 | yyerrorlab -- error raised explicitly by YYERROR. | 1478 `---------------------------------------------------*/ 1479 yyerrorlab: 1480 1481 /* Pacify compilers like GCC when the user code never invokes 1482 YYERROR and the label yyerrorlab therefore never appears in user 1483 code. */ 1484 if (/*CONSTCOND*/ 0) 1485 goto yyerrorlab; 1486 1487 /* Do not reclaim the symbols of the rule which action triggered 1488 this YYERROR. */ 1489 YYPOPSTACK (yylen); 1490 yylen = 0; 1491 YY_STACK_PRINT (yyss, yyssp); 1492 yystate = *yyssp; 1493 goto yyerrlab1; 1494 1495 1496 /*-------------------------------------------------------------. 1497 | yyerrlab1 -- common code for both syntax error and YYERROR. | 1498 `-------------------------------------------------------------*/ 1499 yyerrlab1: 1500 yyerrstatus = 3; /* Each real token shifted decrements this. */ 1501 1502 for (;;) 1503 { 1504 yyn = yypact[yystate]; 1505 if (yyn != YYPACT_NINF) 1506 { 1507 yyn += YYTERROR; 1508 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 1509 { 1510 yyn = yytable[yyn]; 1511 if (0 < yyn) 1512 break; 1513 } 1514 } 1515 1516 /* Pop the current state because it cannot handle the error token. */ 1517 if (yyssp == yyss) 1518 YYABORT; 1519 1520 1521 yydestruct ("Error: popping", 1522 yystos[yystate], yyvsp); 1523 YYPOPSTACK (1); 1524 yystate = *yyssp; 1525 YY_STACK_PRINT (yyss, yyssp); 1526 } 1527 1528 if (yyn == YYFINAL) 1529 YYACCEPT; 1530 1531 *++yyvsp = yylval; 1532 1533 1534 /* Shift the error token. */ 1535 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 1536 1537 yystate = yyn; 1538 goto yynewstate; 1539 1540 1541 /*-------------------------------------. 1542 | yyacceptlab -- YYACCEPT comes here. | 1543 `-------------------------------------*/ 1544 yyacceptlab: 1545 yyresult = 0; 1546 goto yyreturn; 1547 1548 /*-----------------------------------. 1549 | yyabortlab -- YYABORT comes here. | 1550 `-----------------------------------*/ 1551 yyabortlab: 1552 yyresult = 1; 1553 goto yyreturn; 1554 1555 #ifndef yyoverflow 1556 /*-------------------------------------------------. 1557 | yyexhaustedlab -- memory exhaustion comes here. | 1558 `-------------------------------------------------*/ 1559 yyexhaustedlab: 1560 yyerror (YY_("memory exhausted")); 1561 yyresult = 2; 1562 /* Fall through. */ 1563 #endif 1564 1565 yyreturn: 1566 if (yychar != YYEOF && yychar != YYEMPTY) 1567 yydestruct ("Cleanup: discarding lookahead", 1568 yytoken, &yylval); 1569 /* Do not reclaim the symbols of the rule which action triggered 1570 this YYABORT or YYACCEPT. */ 1571 YYPOPSTACK (yylen); 1572 YY_STACK_PRINT (yyss, yyssp); 1573 while (yyssp != yyss) 1574 { 1575 yydestruct ("Cleanup: popping", 1576 yystos[*yyssp], yyvsp); 1577 YYPOPSTACK (1); 1578 } 1579 #ifndef yyoverflow 1580 if (yyss != yyssa) 1581 YYSTACK_FREE (yyss); 1582 #endif 1583 #if YYERROR_VERBOSE 1584 if (yymsg != yymsgbuf) 1585 YYSTACK_FREE (yymsg); 1586 #endif 1587 /* Make sure YYID is used. */ 1588 return YYID (yyresult); 1589 } 1590 1591 1592 #line 82 "convert.y" 1593 168 1594 169 1595 int main(int argc,char *argv[]) … … 534 1960 return 0; 535 1961 } 536 #line 537 "y.tab.c" 537 #define YYABORT goto yyabort 538 #define YYREJECT goto yyabort 539 #define YYACCEPT goto yyaccept 540 #define YYERROR goto yyerrlab 541 int 542 yyparse() 543 { 544 register int yym, yyn, yystate; 545 #if YYDEBUG 546 register char *yys; 547 extern char *getenv(); 548 549 if (yys = getenv("YYDEBUG")) 550 { 551 yyn = *yys; 552 if (yyn >= '0' && yyn <= '9') 553 yydebug = yyn - '0'; 554 } 555 #endif 556 557 yynerrs = 0; 558 yyerrflag = 0; 559 yychar = (-1); 560 561 yyssp = yyss; 562 yyvsp = yyvs; 563 *yyssp = yystate = 0; 564 565 yyloop: 566 if (yyn = yydefred[yystate]) goto yyreduce; 567 if (yychar < 0) 568 { 569 if ((yychar = yylex()) < 0) yychar = 0; 570 #if YYDEBUG 571 if (yydebug) 572 { 573 yys = 0; 574 if (yychar <= YYMAXTOKEN) yys = yyname[yychar]; 575 if (!yys) yys = "illegal-symbol"; 576 printf("%sdebug: state %d, reading %d (%s)\n", 577 YYPREFIX, yystate, yychar, yys); 578 } 579 #endif 580 } 581 if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 && 582 yyn <= YYTABLESIZE && yycheck[yyn] == yychar) 583 { 584 #if YYDEBUG 585 if (yydebug) 586 printf("%sdebug: state %d, shifting to state %d\n", 587 YYPREFIX, yystate, yytable[yyn]); 588 #endif 589 if (yyssp >= yyss + yystacksize - 1) 590 { 591 goto yyoverflow; 592 } 593 *++yyssp = yystate = yytable[yyn]; 594 *++yyvsp = yylval; 595 yychar = (-1); 596 if (yyerrflag > 0) --yyerrflag; 597 goto yyloop; 598 } 599 if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 && 600 yyn <= YYTABLESIZE && yycheck[yyn] == yychar) 601 { 602 yyn = yytable[yyn]; 603 goto yyreduce; 604 } 605 if (yyerrflag) goto yyinrecovery; 606 #ifdef lint 607 goto yynewerror; 608 #endif 609 yynewerror: 610 yyerror("syntax error"); 611 #ifdef lint 612 goto yyerrlab; 613 #endif 614 yyerrlab: 615 ++yynerrs; 616 yyinrecovery: 617 if (yyerrflag < 3) 618 { 619 yyerrflag = 3; 620 for (;;) 621 { 622 if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 && 623 yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE) 624 { 625 #if YYDEBUG 626 if (yydebug) 627 printf("%sdebug: state %d, error recovery shifting\ 628 to state %d\n", YYPREFIX, *yyssp, yytable[yyn]); 629 #endif 630 if (yyssp >= yyss + yystacksize - 1) 631 { 632 goto yyoverflow; 633 } 634 *++yyssp = yystate = yytable[yyn]; 635 *++yyvsp = yylval; 636 goto yyloop; 637 } 638 else 639 { 640 #if YYDEBUG 641 if (yydebug) 642 printf("%sdebug: error recovery discarding state %d\n", 643 YYPREFIX, *yyssp); 644 #endif 645 if (yyssp <= yyss) goto yyabort; 646 --yyssp; 647 --yyvsp; 648 } 649 } 650 } 651 else 652 { 653 if (yychar == 0) goto yyabort; 654 #if YYDEBUG 655 if (yydebug) 656 { 657 yys = 0; 658 if (yychar <= YYMAXTOKEN) yys = yyname[yychar]; 659 if (!yys) yys = "illegal-symbol"; 660 printf("%sdebug: state %d, error recovery discards token %d (%s)\n", 661 YYPREFIX, yystate, yychar, yys); 662 } 663 #endif 664 yychar = (-1); 665 goto yyloop; 666 } 667 yyreduce: 668 #if YYDEBUG 669 if (yydebug) 670 printf("%sdebug: state %d, reducing by rule %d (%s)\n", 671 YYPREFIX, yystate, yyn, yyrule[yyn]); 672 #endif 673 yym = yylen[yyn]; 674 yyval = yyvsp[1-yym]; 675 switch (yyn) 676 { 677 case 4: 678 #line 67 "convert.y" 679 {initdimprob(1,yyvsp[-1].na,"0","0");} 680 break; 681 case 5: 682 #line 68 "convert.y" 683 {initdimprob(2,yyvsp[-3].na, yyvsp[-1].na,"0");} 684 break; 685 case 6: 686 #line 70 "convert.y" 687 {initdimprob(3,yyvsp[-5].na, yyvsp[-3].na, yyvsp[-1].na);} 688 break; 689 case 7: 690 #line 72 "convert.y" 691 {listofmodules = Addtolistnom(yyvsp[-1].na,listofmodules,0); 692 Addmoduletothelist(yyvsp[-1].na);} 693 break; 694 case 8: 695 #line 74 "convert.y" 696 {Add_NotGridDepend_Var_1(yyvsp[-1].na);} 697 break; 698 case 9: 699 #line 75 "convert.y" 700 { 701 if (!strcasecmp(yyvsp[-1].na,"FIXED_GRIDS")) 702 fixedgrids=1; 703 if (!strcasecmp(yyvsp[-1].na,"ONLY_FIXED_GRIDS")) 704 onlyfixedgrids=1; 705 } 706 break; 707 #line 708 "y.tab.c" 708 } 709 yyssp -= yym; 710 yystate = *yyssp; 711 yyvsp -= yym; 712 yym = yylhs[yyn]; 713 if (yystate == 0 && yym == 0) 714 { 715 #if YYDEBUG 716 if (yydebug) 717 printf("%sdebug: after reduction, shifting from state 0 to\ 718 state %d\n", YYPREFIX, YYFINAL); 719 #endif 720 yystate = YYFINAL; 721 *++yyssp = YYFINAL; 722 *++yyvsp = yyval; 723 if (yychar < 0) 724 { 725 if ((yychar = yylex()) < 0) yychar = 0; 726 #if YYDEBUG 727 if (yydebug) 728 { 729 yys = 0; 730 if (yychar <= YYMAXTOKEN) yys = yyname[yychar]; 731 if (!yys) yys = "illegal-symbol"; 732 printf("%sdebug: state %d, reading %d (%s)\n", 733 YYPREFIX, YYFINAL, yychar, yys); 734 } 735 #endif 736 } 737 if (yychar == 0) goto yyaccept; 738 goto yyloop; 739 } 740 if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 && 741 yyn <= YYTABLESIZE && yycheck[yyn] == yystate) 742 yystate = yytable[yyn]; 743 else 744 yystate = yydgoto[yym]; 745 #if YYDEBUG 746 if (yydebug) 747 printf("%sdebug: after reduction, shifting from state %d \ 748 to state %d\n", YYPREFIX, *yyssp, yystate); 749 #endif 750 if (yyssp >= yyss + yystacksize - 1) 751 { 752 goto yyoverflow; 753 } 754 *++yyssp = yystate; 755 *++yyvsp = yyval; 756 goto yyloop; 757 yyoverflow: 758 yyerror("yacc stack overflow"); 759 yyabort: 760 return (1); 761 yyaccept: 762 return (0); 763 } 1962 764 1963 #line 2 "convert.yy.c" 1964 1965 #line 4 "convert.yy.c" 1966 1967 #define YY_INT_ALIGNED short int 1968 765 1969 /* A lexical scanner generated by flex */ 766 767 /* Scanner skeleton version:768 * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.91 96/09/10 16:58:48 vern Exp $769 */770 1970 771 1971 #define FLEX_SCANNER 772 1972 #define YY_FLEX_MAJOR_VERSION 2 773 1973 #define YY_FLEX_MINOR_VERSION 5 774 1974 #define YY_FLEX_SUBMINOR_VERSION 35 1975 #if YY_FLEX_SUBMINOR_VERSION > 0 1976 #define FLEX_BETA 1977 #endif 1978 1979 /* First, we deal with platform-specific or compiler-specific issues. */ 1980 1981 /* begin standard C headers. */ 775 1982 #include <stdio.h> 776 777 778 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */ 779 #ifdef c_plusplus 780 #ifndef __cplusplus 781 #define __cplusplus 782 #endif 783 #endif 784 1983 #include <string.h> 1984 #include <errno.h> 1985 #include <stdlib.h> 1986 1987 /* end standard C headers. */ 1988 1989 /* flex integer type definitions */ 1990 1991 #ifndef FLEXINT_H 1992 #define FLEXINT_H 1993 1994 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */ 1995 1996 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L 1997 1998 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, 1999 * if you want the limit (max/min) macros for int types. 2000 */ 2001 #ifndef __STDC_LIMIT_MACROS 2002 #define __STDC_LIMIT_MACROS 1 2003 #endif 2004 2005 #include <inttypes.h> 2006 typedef int8_t flex_int8_t; 2007 typedef uint8_t flex_uint8_t; 2008 typedef int16_t flex_int16_t; 2009 typedef uint16_t flex_uint16_t; 2010 typedef int32_t flex_int32_t; 2011 typedef uint32_t flex_uint32_t; 2012 #else 2013 typedef signed char flex_int8_t; 2014 typedef short int flex_int16_t; 2015 typedef int flex_int32_t; 2016 typedef unsigned char flex_uint8_t; 2017 typedef unsigned short int flex_uint16_t; 2018 typedef unsigned int flex_uint32_t; 2019 #endif /* ! C99 */ 2020 2021 /* Limits of integral types. */ 2022 #ifndef INT8_MIN 2023 #define INT8_MIN (-128) 2024 #endif 2025 #ifndef INT16_MIN 2026 #define INT16_MIN (-32767-1) 2027 #endif 2028 #ifndef INT32_MIN 2029 #define INT32_MIN (-2147483647-1) 2030 #endif 2031 #ifndef INT8_MAX 2032 #define INT8_MAX (127) 2033 #endif 2034 #ifndef INT16_MAX 2035 #define INT16_MAX (32767) 2036 #endif 2037 #ifndef INT32_MAX 2038 #define INT32_MAX (2147483647) 2039 #endif 2040 #ifndef UINT8_MAX 2041 #define UINT8_MAX (255U) 2042 #endif 2043 #ifndef UINT16_MAX 2044 #define UINT16_MAX (65535U) 2045 #endif 2046 #ifndef UINT32_MAX 2047 #define UINT32_MAX (4294967295U) 2048 #endif 2049 2050 #endif /* ! FLEXINT_H */ 785 2051 786 2052 #ifdef __cplusplus 787 788 #include <stdlib.h>789 #include <unistd.h>790 791 /* Use prototypes in function declarations. */792 #define YY_USE_PROTOS793 2053 794 2054 /* The "const" storage-class-modifier is valid. */ … … 797 2057 #else /* ! __cplusplus */ 798 2058 799 #if __STDC__ 800 801 #define YY_USE_PROTOS 2059 /* C99 requires __STDC__ to be defined as 1. */ 2060 #if defined (__STDC__) 2061 802 2062 #define YY_USE_CONST 803 2063 804 #endif /* __STDC__*/2064 #endif /* defined (__STDC__) */ 805 2065 #endif /* ! __cplusplus */ 806 807 #ifdef __TURBOC__808 #pragma warn -rch809 #pragma warn -use810 #include <io.h>811 #include <stdlib.h>812 #define YY_USE_CONST813 #define YY_USE_PROTOS814 #endif815 2066 816 2067 #ifdef YY_USE_CONST … … 820 2071 #endif 821 2072 822 823 #ifdef YY_USE_PROTOS824 #define YY_PROTO(proto) proto825 #else826 #define YY_PROTO(proto) ()827 #endif828 829 2073 /* Returned upon end-of-file. */ 830 2074 #define YY_NULL 0 … … 841 2085 * definition of BEGIN. 842 2086 */ 843 #define BEGIN yy_start= 1 + 2 *2087 #define BEGIN (yy_start) = 1 + 2 * 844 2088 845 2089 /* Translate the current start state into a value that can be later handed … … 847 2091 * compatibility. 848 2092 */ 849 #define YY_START (( yy_start- 1) / 2)2093 #define YY_START (((yy_start) - 1) / 2) 850 2094 #define YYSTATE YY_START 851 2095 … … 854 2098 855 2099 /* Special action meaning "start processing a new file". */ 856 #define YY_NEW_FILE yyrestart( yyin)2100 #define YY_NEW_FILE yyrestart(yyin ) 857 2101 858 2102 #define YY_END_OF_BUFFER_CHAR 0 859 2103 860 2104 /* Size of default input buffer. */ 2105 #ifndef YY_BUF_SIZE 861 2106 #define YY_BUF_SIZE 16384 862 2107 #endif 2108 2109 /* The state buf must be large enough to hold one state per character in the main buffer. 2110 */ 2111 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) 2112 2113 #ifndef YY_TYPEDEF_YY_BUFFER_STATE 2114 #define YY_TYPEDEF_YY_BUFFER_STATE 863 2115 typedef struct yy_buffer_state *YY_BUFFER_STATE; 864 865 extern int yyleng; 2116 #endif 2117 2118 #ifndef YY_TYPEDEF_YY_SIZE_T 2119 #define YY_TYPEDEF_YY_SIZE_T 2120 typedef size_t yy_size_t; 2121 #endif 2122 2123 extern yy_size_t yyleng; 2124 866 2125 extern FILE *yyin, *yyout; 867 2126 … … 870 2129 #define EOB_ACT_LAST_MATCH 2 871 2130 872 /* The funky do-while in the following #define is used to turn the definition 873 * int a single C statement (which needs a semi-colon terminator). This 874 * avoids problems with code like: 875 * 876 * if ( condition_holds ) 877 * yyless( 5 ); 878 * else 879 * do_something_else(); 880 * 881 * Prior to using the do-while the compiler would get upset at the 882 * "else" because it interpreted the "if" statement as being all 883 * done when it reached the ';' after the yyless() call. 884 */ 885 886 /* Return all but the first 'n' matched characters back to the input stream. */ 887 2131 #define YY_LESS_LINENO(n) 2132 2133 /* Return all but the first "n" matched characters back to the input stream. */ 888 2134 #define yyless(n) \ 889 2135 do \ 890 2136 { \ 891 2137 /* Undo effects of setting up yytext. */ \ 892 *yy_cp = yy_hold_char; \ 2138 int yyless_macro_arg = (n); \ 2139 YY_LESS_LINENO(yyless_macro_arg);\ 2140 *yy_cp = (yy_hold_char); \ 893 2141 YY_RESTORE_YY_MORE_OFFSET \ 894 yy_c_buf_p = yy_cp = yy_bp + n- YY_MORE_ADJ; \2142 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ 895 2143 YY_DO_BEFORE_ACTION; /* set up yytext again */ \ 896 2144 } \ 897 2145 while ( 0 ) 898 2146 899 #define unput(c) yyunput( c, yytext_ptr ) 900 901 /* The following is because we cannot portably get our hands on size_t 902 * (without autoconf's help, which isn't available because we want 903 * flex-generated scanners to compile on their own). 904 */ 905 typedef unsigned int yy_size_t; 906 907 2147 #define unput(c) yyunput( c, (yytext_ptr) ) 2148 2149 #ifndef YY_STRUCT_YY_BUFFER_STATE 2150 #define YY_STRUCT_YY_BUFFER_STATE 908 2151 struct yy_buffer_state 909 2152 { … … 921 2164 * characters. 922 2165 */ 923 int yy_n_chars;2166 yy_size_t yy_n_chars; 924 2167 925 2168 /* Whether we "own" the buffer - i.e., we know we created it, … … 942 2185 int yy_at_bol; 943 2186 2187 int yy_bs_lineno; /**< The line count. */ 2188 int yy_bs_column; /**< The column count. */ 2189 944 2190 /* Whether to try to fill the input buffer when we reach the 945 2191 * end of it. … … 948 2194 949 2195 int yy_buffer_status; 2196 950 2197 #define YY_BUFFER_NEW 0 951 2198 #define YY_BUFFER_NORMAL 1 … … 961 2208 */ 962 2209 #define YY_BUFFER_EOF_PENDING 2 2210 963 2211 }; 964 965 static YY_BUFFER_STATE yy_current_buffer = 0; 2212 #endif /* !YY_STRUCT_YY_BUFFER_STATE */ 2213 2214 /* Stack of input buffers. */ 2215 static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */ 2216 static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */ 2217 static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */ 966 2218 967 2219 /* We provide macros for accessing buffer states in case in the 968 2220 * future we want to put the buffer states in a more general 969 2221 * "scanner state". 970 */ 971 #define YY_CURRENT_BUFFER yy_current_buffer 972 2222 * 2223 * Returns the top of the stack, or NULL. 2224 */ 2225 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ 2226 ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ 2227 : NULL) 2228 2229 /* Same as previous macro, but useful when we know that the buffer stack is not 2230 * NULL or when we need an lvalue. For internal use only. 2231 */ 2232 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] 973 2233 974 2234 /* yy_hold_char holds the character lost when yytext is formed. */ 975 2235 static char yy_hold_char; 976 977 static int yy_n_chars; /* number of characters read into yy_ch_buf */ 978 979 980 int yyleng; 2236 static yy_size_t yy_n_chars; /* number of characters read into yy_ch_buf */ 2237 yy_size_t yyleng; 981 2238 982 2239 /* Points to current character in buffer. */ 983 2240 static char *yy_c_buf_p = (char *) 0; 984 static int yy_init = 1; /* whether we need to initialize */2241 static int yy_init = 0; /* whether we need to initialize */ 985 2242 static int yy_start = 0; /* start state number */ 986 2243 … … 990 2247 static int yy_did_buffer_switch_on_eof; 991 2248 992 void yyrestart YY_PROTO(( FILE *input_file )); 993 994 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer )); 995 void yy_load_buffer_state YY_PROTO(( void )); 996 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size )); 997 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b )); 998 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file )); 999 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b )); 1000 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer ) 1001 1002 YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size )); 1003 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str )); 1004 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len )); 1005 1006 static void *yy_flex_alloc YY_PROTO(( yy_size_t )); 1007 static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )); 1008 static void yy_flex_free YY_PROTO(( void * )); 2249 void yyrestart (FILE *input_file ); 2250 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ); 2251 YY_BUFFER_STATE yy_create_buffer (FILE *file,int size ); 2252 void yy_delete_buffer (YY_BUFFER_STATE b ); 2253 void yy_flush_buffer (YY_BUFFER_STATE b ); 2254 void yypush_buffer_state (YY_BUFFER_STATE new_buffer ); 2255 void yypop_buffer_state (void ); 2256 2257 static void yyensure_buffer_stack (void ); 2258 static void yy_load_buffer_state (void ); 2259 static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file ); 2260 2261 #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER ) 2262 2263 YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size ); 2264 YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str ); 2265 YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,yy_size_t len ); 2266 2267 void *yyalloc (yy_size_t ); 2268 void *yyrealloc (void *,yy_size_t ); 2269 void yyfree (void * ); 1009 2270 1010 2271 #define yy_new_buffer yy_create_buffer … … 1012 2273 #define yy_set_interactive(is_interactive) \ 1013 2274 { \ 1014 if ( ! yy_current_buffer ) \ 1015 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ 1016 yy_current_buffer->yy_is_interactive = is_interactive; \ 2275 if ( ! YY_CURRENT_BUFFER ){ \ 2276 yyensure_buffer_stack (); \ 2277 YY_CURRENT_BUFFER_LVALUE = \ 2278 yy_create_buffer(yyin,YY_BUF_SIZE ); \ 2279 } \ 2280 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ 1017 2281 } 1018 2282 1019 2283 #define yy_set_bol(at_bol) \ 1020 2284 { \ 1021 if ( ! yy_current_buffer ) \ 1022 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ 1023 yy_current_buffer->yy_at_bol = at_bol; \ 2285 if ( ! YY_CURRENT_BUFFER ){\ 2286 yyensure_buffer_stack (); \ 2287 YY_CURRENT_BUFFER_LVALUE = \ 2288 yy_create_buffer(yyin,YY_BUF_SIZE ); \ 2289 } \ 2290 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ 1024 2291 } 1025 2292 1026 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol) 2293 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) 2294 2295 /* Begin user sect3 */ 1027 2296 1028 2297 typedef unsigned char YY_CHAR; 2298 1029 2299 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; 2300 1030 2301 typedef int yy_state_type; 2302 2303 extern int yylineno; 2304 2305 int yylineno = 1; 2306 1031 2307 extern char *yytext; 1032 2308 #define yytext_ptr yytext 1033 2309 1034 static yy_state_type yy_get_previous_state YY_PROTO(( void ));1035 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));1036 static int yy_get_next_buffer YY_PROTO(( void ));1037 static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));2310 static yy_state_type yy_get_previous_state (void ); 2311 static yy_state_type yy_try_NUL_trans (yy_state_type current_state ); 2312 static int yy_get_next_buffer (void ); 2313 static void yy_fatal_error (yyconst char msg[] ); 1038 2314 1039 2315 /* Done after the current pattern has been matched and before the … … 1041 2317 */ 1042 2318 #define YY_DO_BEFORE_ACTION \ 1043 yytext_ptr= yy_bp; \1044 yyleng = ( int) (yy_cp - yy_bp); \1045 yy_hold_char= *yy_cp; \2319 (yytext_ptr) = yy_bp; \ 2320 yyleng = (size_t) (yy_cp - yy_bp); \ 2321 (yy_hold_char) = *yy_cp; \ 1046 2322 *yy_cp = '\0'; \ 1047 yy_c_buf_p= yy_cp;2323 (yy_c_buf_p) = yy_cp; 1048 2324 1049 2325 #define YY_NUM_RULES 12 1050 2326 #define YY_END_OF_BUFFER 13 1051 static yyconst short int yy_accept[74] = 2327 /* This struct is not used in this scanner, 2328 but its presence is necessary. */ 2329 struct yy_trans_info 2330 { 2331 flex_int32_t yy_verify; 2332 flex_int32_t yy_nxt; 2333 }; 2334 static yyconst flex_int16_t yy_accept[77] = 1052 2335 { 0, 1053 2336 0, 0, 0, 0, 13, 12, 11, 10, 12, 9, 1054 2337 12, 12, 12, 9, 8, 8, 8, 8, 8, 8, 1055 11, 0, 4, 7, 5, 8, 8, 8, 8, 8,1056 8, 8, 6, 8, 8, 8, 8, 3, 8, 8,2338 11, 0, 4, 7, 7, 7, 5, 8, 8, 8, 2339 8, 8, 8, 8, 6, 8, 8, 8, 8, 3, 1057 2340 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 1058 2341 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 1059 8, 8, 8, 2, 8, 8, 8, 1, 8, 8,1060 8, 8, 02342 8, 8, 8, 8, 8, 2, 8, 8, 8, 1, 2343 8, 8, 8, 8, 6, 0 1061 2344 } ; 1062 2345 1063 static yyconst int yy_ec[256] =2346 static yyconst flex_int32_t yy_ec[256] = 1064 2347 { 0, 1065 2348 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, … … 1069 2352 6, 1, 1, 7, 1, 1, 1, 8, 9, 10, 1070 2353 11, 8, 8, 8, 12, 8, 8, 13, 14, 1, 1071 1, 1, 1, 1, 1 8, 19, 19, 20, 21, 22,1072 2 3, 19, 24, 19, 19, 25, 26, 27, 28, 29,1073 1 9, 30, 31, 32, 33, 19, 19, 34, 35, 19,1074 15, 1, 16, 1, 17, 1, 18, 19, 19, 20,1075 1076 21, 22, 23, 19, 24, 19, 19, 25, 26, 27,1077 28, 29, 19, 30, 31, 32, 33, 19, 19, 34,1078 35, 19, 1, 1, 1, 1, 1, 1, 1, 1,2354 1, 1, 1, 1, 15, 16, 16, 17, 18, 19, 2355 20, 16, 21, 16, 16, 22, 23, 24, 25, 26, 2356 16, 27, 28, 29, 30, 16, 16, 31, 32, 16, 2357 33, 1, 34, 1, 35, 1, 36, 16, 16, 37, 2358 2359 38, 39, 40, 16, 41, 16, 16, 42, 43, 44, 2360 45, 46, 16, 47, 48, 49, 50, 16, 16, 51, 2361 52, 16, 1, 1, 1, 1, 1, 1, 1, 1, 1079 2362 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1080 2363 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, … … 1093 2376 } ; 1094 2377 1095 static yyconst int yy_meta[36] =2378 static yyconst flex_int32_t yy_meta[53] = 1096 2379 { 0, 1097 2380 1, 1, 2, 1, 1, 1, 1, 3, 3, 3, 1098 3, 3, 1, 1, 1, 1, 3, 3, 3, 3,2381 3, 3, 1, 1, 3, 3, 3, 3, 3, 3, 1099 2382 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 1100 3, 3, 3, 3, 3 2383 3, 3, 1, 1, 3, 3, 3, 3, 3, 3, 2384 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2385 3, 3 1101 2386 } ; 1102 2387 1103 static yyconst short int yy_base[76] =2388 static yyconst flex_int16_t yy_base[79] = 1104 2389 { 0, 1105 0, 0, 0, 0, 96, 97, 93, 97, 90, 97,1106 73, 72, 71, 77, 0, 24, 61, 61, 69, 55,1107 83, 80, 79, 97, 97, 0, 70, 47, 48, 54,1108 48, 56, 0, 55, 52, 39, 55, 0, 52, 41,1109 5 3, 43, 51, 43, 44, 39, 41, 43, 38, 33,1110 30, 39, 24, 37, 32, 34, 33, 20, 32, 21,1111 27, 21, 14, 0, 27, 22, 19, 0, 11, 16,1112 19, 7, 97, 48, 342390 0, 0, 0, 0, 150, 164, 147, 164, 144, 164, 2391 36, 37, 38, 134, 0, 44, 32, 34, 44, 33, 2392 144, 141, 140, 164, 164, 164, 164, 0, 131, 31, 2393 34, 42, 39, 49, 0, 50, 49, 38, 56, 0, 2394 59, 52, 107, 68, 106, 72, 75, 72, 77, 81, 2395 79, 76, 75, 86, 73, 88, 85, 89, 90, 79, 2396 93, 86, 99, 97, 103, 0, 37, 115, 114, 0, 2397 108, 116, 121, 112, 0, 164, 160, 57 1113 2398 } ; 1114 2399 1115 static yyconst short int yy_def[76] =2400 static yyconst flex_int16_t yy_def[79] = 1116 2401 { 0, 1117 7 3, 1, 1, 1, 73, 73, 73, 73, 74, 73,1118 7 3, 73, 73, 73, 75, 75, 75, 75, 75, 75,1119 7 3, 74, 74, 73, 73, 75, 75, 75, 75, 75,1120 7 5, 75, 75, 75, 75, 75, 75, 75, 75, 75,1121 7 5, 75, 75, 75, 75, 75, 75, 75, 75, 75,1122 7 5, 75, 75, 75, 75, 75, 75, 75, 75, 75,1123 7 5, 75, 75, 75, 75, 75, 75, 75, 75, 75,1124 7 5, 75, 0, 73, 732402 76, 1, 1, 1, 76, 76, 76, 76, 77, 76, 2403 76, 76, 76, 76, 78, 78, 78, 78, 78, 78, 2404 76, 77, 77, 76, 76, 76, 76, 78, 78, 78, 2405 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 2406 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 2407 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 2408 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 2409 78, 78, 78, 78, 78, 0, 76, 76 1125 2410 } ; 1126 2411 1127 static yyconst short int yy_nxt[133] =2412 static yyconst flex_int16_t yy_nxt[217] = 1128 2413 { 0, 1129 2414 6, 7, 8, 9, 10, 10, 10, 6, 11, 12, 1130 13, 6, 14, 10, 10, 10, 15, 15, 15, 15, 1131 15, 16, 15, 15, 15, 15, 17, 18, 19, 15, 1132 15, 15, 20, 15, 15, 27, 26, 33, 72, 71, 1133 70, 69, 68, 67, 33, 66, 65, 28, 22, 64, 1134 22, 63, 62, 61, 60, 59, 58, 57, 56, 55, 1135 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 1136 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 1137 34, 33, 23, 23, 21, 32, 31, 30, 29, 25, 1138 24, 24, 24, 23, 21, 73, 5, 73, 73, 73, 1139 1140 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 1141 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 1142 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 1143 73, 73 2415 13, 6, 14, 10, 15, 15, 15, 15, 16, 15, 2416 15, 15, 15, 17, 18, 19, 15, 15, 15, 20, 2417 15, 15, 10, 10, 15, 15, 15, 15, 16, 15, 2418 15, 15, 15, 17, 18, 19, 15, 15, 15, 20, 2419 15, 15, 24, 25, 26, 29, 31, 32, 33, 28, 2420 34, 36, 37, 38, 30, 39, 40, 41, 42, 43, 2421 44, 69, 24, 25, 26, 45, 31, 32, 46, 33, 2422 34, 36, 37, 38, 30, 39, 40, 41, 42, 43, 2423 48, 44, 50, 51, 52, 45, 53, 54, 46, 55, 2424 2425 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 2426 48, 66, 50, 51, 52, 67, 53, 54, 68, 55, 2427 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 2428 35, 66, 70, 71, 72, 67, 73, 74, 68, 75, 2429 49, 47, 35, 23, 23, 21, 27, 23, 21, 76, 2430 35, 76, 70, 71, 72, 76, 73, 74, 76, 75, 2431 22, 76, 22, 5, 76, 76, 76, 76, 76, 76, 2432 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 2433 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 2434 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 2435 2436 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 2437 76, 76, 76, 76, 76, 76 1144 2438 } ; 1145 2439 1146 static yyconst short int yy_chk[133] =2440 static yyconst flex_int16_t yy_chk[217] = 1147 2441 { 0, 1148 2442 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1149 2443 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1150 2444 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1151 1, 1, 1, 1, 1, 16, 75, 72, 71, 70, 1152 69, 67, 66, 65, 63, 62, 61, 16, 74, 60, 1153 74, 59, 58, 57, 56, 55, 54, 53, 52, 51, 1154 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 1155 40, 39, 37, 36, 35, 34, 32, 31, 30, 29, 1156 28, 27, 23, 22, 21, 20, 19, 18, 17, 14, 1157 13, 12, 11, 9, 7, 5, 73, 73, 73, 73, 1158 1159 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 1160 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 1161 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 1162 73, 73 2445 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2446 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2447 1, 1, 11, 12, 13, 16, 17, 18, 19, 78, 2448 20, 30, 31, 32, 16, 33, 34, 36, 37, 38, 2449 39, 67, 11, 12, 13, 41, 17, 18, 42, 19, 2450 20, 30, 31, 32, 16, 33, 34, 36, 37, 38, 2451 44, 39, 46, 47, 48, 41, 49, 50, 42, 51, 2452 2453 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 2454 44, 62, 46, 47, 48, 63, 49, 50, 64, 51, 2455 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 2456 65, 62, 68, 69, 71, 63, 72, 73, 64, 74, 2457 45, 43, 29, 23, 22, 21, 14, 9, 7, 5, 2458 65, 0, 68, 69, 71, 0, 72, 73, 0, 74, 2459 77, 0, 77, 76, 76, 76, 76, 76, 76, 76, 2460 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 2461 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 2462 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 2463 2464 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 2465 76, 76, 76, 76, 76, 76 1163 2466 } ; 1164 2467 1165 2468 static yy_state_type yy_last_accepting_state; 1166 2469 static char *yy_last_accepting_cpos; 2470 2471 extern int yy_flex_debug; 2472 int yy_flex_debug = 0; 1167 2473 1168 2474 /* The intent behind this definition is that it'll catch … … 1175 2481 char *yytext; 1176 2482 #line 1 "convert.lex" 1177 #define INITIAL 01178 2483 /******************************************************************************/ 1179 2484 /* */ … … 1210 2515 /* version 1.7 */ 1211 2516 /******************************************************************************/ 1212 #define character 11213 2517 1214 2518 #line 37 "convert.lex" … … 1220 2524 #define MAX_INCLUDE_DEPTH 30 1221 2525 YY_BUFFER_STATE include_stack[MAX_INCLUDE_DEPTH]; 1222 #line 460 "convert.yy.c" 2526 #line 565 "convert.yy.c" 2527 2528 #define INITIAL 0 2529 #define character 1 2530 2531 #ifndef YY_NO_UNISTD_H 2532 /* Special case for "unistd.h", since it is non-ANSI. We include it way 2533 * down here because we want the user's section 1 to have been scanned first. 2534 * The user has a chance to override it with an option. 2535 */ 2536 #include <unistd.h> 2537 #endif 2538 2539 #ifndef YY_EXTRA_TYPE 2540 #define YY_EXTRA_TYPE void * 2541 #endif 2542 2543 static int yy_init_globals (void ); 2544 2545 /* Accessor methods to globals. 2546 These are made visible to non-reentrant scanners for convenience. */ 2547 2548 int yylex_destroy (void ); 2549 2550 int yyget_debug (void ); 2551 2552 void yyset_debug (int debug_flag ); 2553 2554 YY_EXTRA_TYPE yyget_extra (void ); 2555 2556 void yyset_extra (YY_EXTRA_TYPE user_defined ); 2557 2558 FILE *yyget_in (void ); 2559 2560 void yyset_in (FILE * in_str ); 2561 2562 FILE *yyget_out (void ); 2563 2564 void yyset_out (FILE * out_str ); 2565 2566 yy_size_t yyget_leng (void ); 2567 2568 char *yyget_text (void ); 2569 2570 int yyget_lineno (void ); 2571 2572 void yyset_lineno (int line_number ); 1223 2573 1224 2574 /* Macros after this point can all be overridden by user definitions in … … 1228 2578 #ifndef YY_SKIP_YYWRAP 1229 2579 #ifdef __cplusplus 1230 extern "C" int yywrap YY_PROTO(( void ));2580 extern "C" int yywrap (void ); 1231 2581 #else 1232 extern int yywrap YY_PROTO(( void )); 1233 #endif 1234 #endif 1235 1236 #ifndef YY_NO_UNPUT 1237 static void yyunput YY_PROTO(( int c, char *buf_ptr )); 1238 #endif 1239 2582 extern int yywrap (void ); 2583 #endif 2584 #endif 2585 2586 static void yyunput (int c,char *buf_ptr ); 2587 1240 2588 #ifndef yytext_ptr 1241 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));2589 static void yy_flex_strncpy (char *,yyconst char *,int ); 1242 2590 #endif 1243 2591 1244 2592 #ifdef YY_NEED_STRLEN 1245 static int yy_flex_strlen YY_PROTO(( yyconst char * ));2593 static int yy_flex_strlen (yyconst char * ); 1246 2594 #endif 1247 2595 1248 2596 #ifndef YY_NO_INPUT 2597 1249 2598 #ifdef __cplusplus 1250 static int yyinput YY_PROTO(( void ));2599 static int yyinput (void ); 1251 2600 #else 1252 static int input YY_PROTO(( void )); 1253 #endif 1254 #endif 1255 1256 #if YY_STACK_USED 1257 static int yy_start_stack_ptr = 0; 1258 static int yy_start_stack_depth = 0; 1259 static int *yy_start_stack = 0; 1260 #ifndef YY_NO_PUSH_STATE 1261 static void yy_push_state YY_PROTO(( int new_state )); 1262 #endif 1263 #ifndef YY_NO_POP_STATE 1264 static void yy_pop_state YY_PROTO(( void )); 1265 #endif 1266 #ifndef YY_NO_TOP_STATE 1267 static int yy_top_state YY_PROTO(( void )); 1268 #endif 1269 1270 #else 1271 #define YY_NO_PUSH_STATE 1 1272 #define YY_NO_POP_STATE 1 1273 #define YY_NO_TOP_STATE 1 1274 #endif 1275 1276 #ifdef YY_MALLOC_DECL 1277 YY_MALLOC_DECL 1278 #else 1279 #if __STDC__ 1280 #ifndef __cplusplus 1281 #include <stdlib.h> 1282 #endif 1283 #else 1284 /* Just try to get by without declaring the routines. This will fail 1285 * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int) 1286 * or sizeof(void*) != sizeof(int). 1287 */ 1288 #endif 2601 static int input (void ); 2602 #endif 2603 1289 2604 #endif 1290 2605 … … 1295 2610 1296 2611 /* Copy whatever the last rule matched to the standard output. */ 1297 1298 2612 #ifndef ECHO 1299 2613 /* This used to be an fputs(), but since the string might contain NUL's, 1300 2614 * we now use fwrite(). 1301 2615 */ 1302 #define ECHO (void)fwrite( yytext, yyleng, 1, yyout )2616 #define ECHO fwrite( yytext, yyleng, 1, yyout ) 1303 2617 #endif 1304 2618 … … 1308 2622 #ifndef YY_INPUT 1309 2623 #define YY_INPUT(buf,result,max_size) \ 1310 if ( yy_current_buffer->yy_is_interactive ) \2624 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ 1311 2625 { \ 1312 int c = '*', n; \ 2626 int c = '*'; \ 2627 yy_size_t n; \ 1313 2628 for ( n = 0; n < max_size && \ 1314 2629 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ … … 1320 2635 result = n; \ 1321 2636 } \ 1322 else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \ 1323 && ferror( yyin ) ) \ 1324 YY_FATAL_ERROR( "input in flex scanner failed" ); 2637 else \ 2638 { \ 2639 errno=0; \ 2640 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \ 2641 { \ 2642 if( errno != EINTR) \ 2643 { \ 2644 YY_FATAL_ERROR( "input in flex scanner failed" ); \ 2645 break; \ 2646 } \ 2647 errno=0; \ 2648 clearerr(yyin); \ 2649 } \ 2650 }\ 2651 \ 2652 1325 2653 #endif 1326 2654 … … 1343 2671 #endif 1344 2672 2673 /* end tables serialization structures and prototypes */ 2674 1345 2675 /* Default declaration of generated scanner - a define so the user can 1346 2676 * easily add parameters. 1347 2677 */ 1348 2678 #ifndef YY_DECL 1349 #define YY_DECL int yylex YY_PROTO(( void )) 1350 #endif 2679 #define YY_DECL_IS_OURS 1 2680 2681 extern int yylex (void); 2682 2683 #define YY_DECL int yylex (void) 2684 #endif /* !YY_DECL */ 1351 2685 1352 2686 /* Code executed at the beginning of each rule, after yytext and yyleng … … 1365 2699 YY_USER_ACTION 1366 2700 2701 /** The main scanner function which does all the work. 2702 */ 1367 2703 YY_DECL 1368 2704 { 1369 2705 register yy_state_type yy_current_state; 1370 2706 register char *yy_cp, *yy_bp; 1371 2707 register int yy_act; 1372 2708 1373 2709 #line 55 "convert.lex" 1374 2710 1375 #line 613"convert.yy.c"1376 1377 if ( yy_init)2711 #line 750 "convert.yy.c" 2712 2713 if ( !(yy_init) ) 1378 2714 { 1379 yy_init = 0;2715 (yy_init) = 1; 1380 2716 1381 2717 #ifdef YY_USER_INIT … … 1383 2719 #endif 1384 2720 1385 if ( ! yy_start)1386 yy_start= 1; /* first start state */2721 if ( ! (yy_start) ) 2722 (yy_start) = 1; /* first start state */ 1387 2723 1388 2724 if ( ! yyin ) … … 1392 2728 yyout = stdout; 1393 2729 1394 if ( ! yy_current_buffer ) 1395 yy_current_buffer = 1396 yy_create_buffer( yyin, YY_BUF_SIZE ); 1397 1398 yy_load_buffer_state(); 2730 if ( ! YY_CURRENT_BUFFER ) { 2731 yyensure_buffer_stack (); 2732 YY_CURRENT_BUFFER_LVALUE = 2733 yy_create_buffer(yyin,YY_BUF_SIZE ); 2734 } 2735 2736 yy_load_buffer_state( ); 1399 2737 } 1400 2738 1401 2739 while ( 1 ) /* loops until end-of-file is reached */ 1402 2740 { 1403 yy_cp = yy_c_buf_p;2741 yy_cp = (yy_c_buf_p); 1404 2742 1405 2743 /* Support of yytext. */ 1406 *yy_cp = yy_hold_char;2744 *yy_cp = (yy_hold_char); 1407 2745 1408 2746 /* yy_bp points to the position in yy_ch_buf of the start of … … 1411 2749 yy_bp = yy_cp; 1412 2750 1413 yy_current_state = yy_start;2751 yy_current_state = (yy_start); 1414 2752 yy_match: 1415 2753 do … … 1418 2756 if ( yy_accept[yy_current_state] ) 1419 2757 { 1420 yy_last_accepting_state= yy_current_state;1421 yy_last_accepting_cpos= yy_cp;2758 (yy_last_accepting_state) = yy_current_state; 2759 (yy_last_accepting_cpos) = yy_cp; 1422 2760 } 1423 2761 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 1424 2762 { 1425 2763 yy_current_state = (int) yy_def[yy_current_state]; 1426 if ( yy_current_state >= 7 4)2764 if ( yy_current_state >= 77 ) 1427 2765 yy_c = yy_meta[(unsigned int) yy_c]; 1428 2766 } … … 1430 2768 ++yy_cp; 1431 2769 } 1432 while ( yy_base[yy_current_state] != 97);2770 while ( yy_base[yy_current_state] != 164 ); 1433 2771 1434 2772 yy_find_action: … … 1436 2774 if ( yy_act == 0 ) 1437 2775 { /* have to back up */ 1438 yy_cp = yy_last_accepting_cpos;1439 yy_current_state = yy_last_accepting_state;2776 yy_cp = (yy_last_accepting_cpos); 2777 yy_current_state = (yy_last_accepting_state); 1440 2778 yy_act = yy_accept[yy_current_state]; 1441 2779 } … … 1443 2781 YY_DO_BEFORE_ACTION; 1444 2782 1445 1446 2783 do_action: /* This label is used only to access EOF actions. */ 1447 1448 2784 1449 2785 switch ( yy_act ) … … 1451 2787 case 0: /* must back up */ 1452 2788 /* undo the effects of YY_DO_BEFORE_ACTION */ 1453 *yy_cp = yy_hold_char;1454 yy_cp = yy_last_accepting_cpos;1455 yy_current_state = yy_last_accepting_state;2789 *yy_cp = (yy_hold_char); 2790 yy_cp = (yy_last_accepting_cpos); 2791 yy_current_state = (yy_last_accepting_state); 1456 2792 goto yy_find_action; 1457 2793 … … 1503 2839 YY_BREAK 1504 2840 case 10: 2841 /* rule 10 can match eol */ 1505 2842 YY_RULE_SETUP 1506 2843 #line 66 "convert.lex" … … 1517 2854 ECHO; 1518 2855 YY_BREAK 1519 #line 757"convert.yy.c"2856 #line 895 "convert.yy.c" 1520 2857 case YY_STATE_EOF(INITIAL): 1521 2858 case YY_STATE_EOF(character): … … 1525 2862 { 1526 2863 /* Amount of text matched not including the EOB char. */ 1527 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;2864 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1; 1528 2865 1529 2866 /* Undo the effects of YY_DO_BEFORE_ACTION. */ 1530 *yy_cp = yy_hold_char;2867 *yy_cp = (yy_hold_char); 1531 2868 YY_RESTORE_YY_MORE_OFFSET 1532 2869 1533 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )2870 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) 1534 2871 { 1535 2872 /* We're scanning a new file or input source. It's … … 1537 2874 * just pointed yyin at a new source and called 1538 2875 * yylex(). If so, then we have to assure 1539 * consistency between yy_current_bufferand our2876 * consistency between YY_CURRENT_BUFFER and our 1540 2877 * globals. Here is the right place to do so, because 1541 2878 * this is the first action (other than possibly a 1542 2879 * back-up) that will match for the new input source. 1543 2880 */ 1544 yy_n_chars = yy_current_buffer->yy_n_chars;1545 yy_current_buffer->yy_input_file = yyin;1546 yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;2881 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; 2882 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; 2883 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; 1547 2884 } 1548 2885 … … 1554 2891 * in input(). 1555 2892 */ 1556 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )2893 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) 1557 2894 { /* This was really a NUL. */ 1558 2895 yy_state_type yy_next_state; 1559 2896 1560 yy_c_buf_p = yytext_ptr+ yy_amount_of_matched_text;1561 1562 yy_current_state = yy_get_previous_state( );2897 (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text; 2898 2899 yy_current_state = yy_get_previous_state( ); 1563 2900 1564 2901 /* Okay, we're now positioned to make the NUL … … 1573 2910 yy_next_state = yy_try_NUL_trans( yy_current_state ); 1574 2911 1575 yy_bp = yytext_ptr+ YY_MORE_ADJ;2912 yy_bp = (yytext_ptr) + YY_MORE_ADJ; 1576 2913 1577 2914 if ( yy_next_state ) 1578 2915 { 1579 2916 /* Consume the NUL. */ 1580 yy_cp = ++ yy_c_buf_p;2917 yy_cp = ++(yy_c_buf_p); 1581 2918 yy_current_state = yy_next_state; 1582 2919 goto yy_match; … … 1585 2922 else 1586 2923 { 1587 yy_cp = yy_c_buf_p;2924 yy_cp = (yy_c_buf_p); 1588 2925 goto yy_find_action; 1589 2926 } 1590 2927 } 1591 2928 1592 else switch ( yy_get_next_buffer( ) )2929 else switch ( yy_get_next_buffer( ) ) 1593 2930 { 1594 2931 case EOB_ACT_END_OF_FILE: 1595 2932 { 1596 yy_did_buffer_switch_on_eof= 0;1597 1598 if ( yywrap( ) )2933 (yy_did_buffer_switch_on_eof) = 0; 2934 2935 if ( yywrap( ) ) 1599 2936 { 1600 2937 /* Note: because we've taken care in … … 1607 2944 * YY_NULL will get returned. 1608 2945 */ 1609 yy_c_buf_p = yytext_ptr+ YY_MORE_ADJ;2946 (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; 1610 2947 1611 2948 yy_act = YY_STATE_EOF(YY_START); … … 1615 2952 else 1616 2953 { 1617 if ( ! yy_did_buffer_switch_on_eof)2954 if ( ! (yy_did_buffer_switch_on_eof) ) 1618 2955 YY_NEW_FILE; 1619 2956 } … … 1622 2959 1623 2960 case EOB_ACT_CONTINUE_SCAN: 1624 yy_c_buf_p=1625 yytext_ptr+ yy_amount_of_matched_text;1626 1627 yy_current_state = yy_get_previous_state( );1628 1629 yy_cp = yy_c_buf_p;1630 yy_bp = yytext_ptr+ YY_MORE_ADJ;2961 (yy_c_buf_p) = 2962 (yytext_ptr) + yy_amount_of_matched_text; 2963 2964 yy_current_state = yy_get_previous_state( ); 2965 2966 yy_cp = (yy_c_buf_p); 2967 yy_bp = (yytext_ptr) + YY_MORE_ADJ; 1631 2968 goto yy_match; 1632 2969 1633 2970 case EOB_ACT_LAST_MATCH: 1634 yy_c_buf_p=1635 & yy_current_buffer->yy_ch_buf[yy_n_chars];1636 1637 yy_current_state = yy_get_previous_state( );1638 1639 yy_cp = yy_c_buf_p;1640 yy_bp = yytext_ptr+ YY_MORE_ADJ;2971 (yy_c_buf_p) = 2972 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]; 2973 2974 yy_current_state = yy_get_previous_state( ); 2975 2976 yy_cp = (yy_c_buf_p); 2977 yy_bp = (yytext_ptr) + YY_MORE_ADJ; 1641 2978 goto yy_find_action; 1642 2979 } … … 1649 2986 } /* end of action switch */ 1650 2987 } /* end of scanning one token */ 1651 } /* end of yylex */ 1652 2988 } /* end of yylex */ 1653 2989 1654 2990 /* yy_get_next_buffer - try to read in a new buffer … … 1659 2995 * EOB_ACT_END_OF_FILE - end of file 1660 2996 */ 1661 1662 static int yy_get_next_buffer() 1663 { 1664 register char *dest = yy_current_buffer->yy_ch_buf; 1665 register char *source = yytext_ptr; 2997 static int yy_get_next_buffer (void) 2998 { 2999 register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; 3000 register char *source = (yytext_ptr); 1666 3001 register int number_to_move, i; 1667 3002 int ret_val; 1668 3003 1669 if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars+ 1] )3004 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) 1670 3005 YY_FATAL_ERROR( 1671 3006 "fatal flex scanner internal error--end of buffer missed" ); 1672 3007 1673 if ( yy_current_buffer->yy_fill_buffer == 0 )3008 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) 1674 3009 { /* Don't try to fill the buffer, so this is an EOF. */ 1675 if ( yy_c_buf_p - yytext_ptr- YY_MORE_ADJ == 1 )3010 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) 1676 3011 { 1677 3012 /* We matched a single character, the EOB, so … … 1693 3028 1694 3029 /* First move last chars to start of buffer. */ 1695 number_to_move = (int) ( yy_c_buf_p - yytext_ptr) - 1;3030 number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1; 1696 3031 1697 3032 for ( i = 0; i < number_to_move; ++i ) 1698 3033 *(dest++) = *(source++); 1699 3034 1700 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )3035 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) 1701 3036 /* don't do the read, it's not guaranteed to return an EOF, 1702 3037 * just force an EOF 1703 3038 */ 1704 yy_current_buffer->yy_n_chars = yy_n_chars= 0;3039 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0; 1705 3040 1706 3041 else 1707 3042 { 1708 int num_to_read =1709 yy_current_buffer->yy_buf_size - number_to_move - 1;3043 yy_size_t num_to_read = 3044 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; 1710 3045 1711 3046 while ( num_to_read <= 0 ) 1712 3047 { /* Not enough room in the buffer - grow it. */ 1713 #ifdef YY_USES_REJECT1714 YY_FATAL_ERROR(1715 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );1716 #else1717 3048 1718 3049 /* just a shorter name for the current buffer */ 1719 YY_BUFFER_STATE b = yy_current_buffer;3050 YY_BUFFER_STATE b = YY_CURRENT_BUFFER; 1720 3051 1721 3052 int yy_c_buf_p_offset = 1722 (int) ( yy_c_buf_p- b->yy_ch_buf);3053 (int) ((yy_c_buf_p) - b->yy_ch_buf); 1723 3054 1724 3055 if ( b->yy_is_our_buffer ) 1725 3056 { 1726 int new_size = b->yy_buf_size * 2;3057 yy_size_t new_size = b->yy_buf_size * 2; 1727 3058 1728 3059 if ( new_size <= 0 ) … … 1733 3064 b->yy_ch_buf = (char *) 1734 3065 /* Include room in for 2 EOB chars. */ 1735 yy_flex_realloc( (void *) b->yy_ch_buf, 1736 b->yy_buf_size + 2 ); 3066 yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ); 1737 3067 } 1738 3068 else … … 1744 3074 "fatal error - scanner input buffer overflow" ); 1745 3075 1746 yy_c_buf_p= &b->yy_ch_buf[yy_c_buf_p_offset];1747 1748 num_to_read = yy_current_buffer->yy_buf_size -3076 (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset]; 3077 3078 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - 1749 3079 number_to_move - 1; 1750 #endif 3080 1751 3081 } 1752 3082 … … 1755 3085 1756 3086 /* Read in more data. */ 1757 YY_INPUT( (& yy_current_buffer->yy_ch_buf[number_to_move]),1758 yy_n_chars, num_to_read );1759 1760 yy_current_buffer->yy_n_chars = yy_n_chars;3087 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), 3088 (yy_n_chars), num_to_read ); 3089 3090 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); 1761 3091 } 1762 3092 1763 if ( yy_n_chars== 0 )3093 if ( (yy_n_chars) == 0 ) 1764 3094 { 1765 3095 if ( number_to_move == YY_MORE_ADJ ) 1766 3096 { 1767 3097 ret_val = EOB_ACT_END_OF_FILE; 1768 yyrestart( yyin);3098 yyrestart(yyin ); 1769 3099 } 1770 3100 … … 1772 3102 { 1773 3103 ret_val = EOB_ACT_LAST_MATCH; 1774 yy_current_buffer->yy_buffer_status =3104 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = 1775 3105 YY_BUFFER_EOF_PENDING; 1776 3106 } … … 1780 3110 ret_val = EOB_ACT_CONTINUE_SCAN; 1781 3111 1782 yy_n_chars += number_to_move; 1783 yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; 1784 yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; 1785 1786 yytext_ptr = &yy_current_buffer->yy_ch_buf[0]; 3112 if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { 3113 /* Extend the array by 50%, plus the number we really need. */ 3114 yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); 3115 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ); 3116 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) 3117 YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); 3118 } 3119 3120 (yy_n_chars) += number_to_move; 3121 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; 3122 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; 3123 3124 (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; 1787 3125 1788 3126 return ret_val; 1789 } 1790 3127 } 1791 3128 1792 3129 /* yy_get_previous_state - get the state just before the EOB char was reached */ 1793 3130 1794 static yy_state_type yy_get_previous_state()1795 3131 static yy_state_type yy_get_previous_state (void) 3132 { 1796 3133 register yy_state_type yy_current_state; 1797 3134 register char *yy_cp; 1798 1799 yy_current_state = yy_start;1800 1801 for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )3135 3136 yy_current_state = (yy_start); 3137 3138 for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) 1802 3139 { 1803 3140 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); 1804 3141 if ( yy_accept[yy_current_state] ) 1805 3142 { 1806 yy_last_accepting_state= yy_current_state;1807 yy_last_accepting_cpos= yy_cp;3143 (yy_last_accepting_state) = yy_current_state; 3144 (yy_last_accepting_cpos) = yy_cp; 1808 3145 } 1809 3146 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 1810 3147 { 1811 3148 yy_current_state = (int) yy_def[yy_current_state]; 1812 if ( yy_current_state >= 7 4)3149 if ( yy_current_state >= 77 ) 1813 3150 yy_c = yy_meta[(unsigned int) yy_c]; 1814 3151 } … … 1817 3154 1818 3155 return yy_current_state; 1819 } 1820 3156 } 1821 3157 1822 3158 /* yy_try_NUL_trans - try to make a transition on the NUL character … … 1825 3161 * next_state = yy_try_NUL_trans( current_state ); 1826 3162 */ 1827 1828 #ifdef YY_USE_PROTOS 1829 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state ) 1830 #else 1831 static yy_state_type yy_try_NUL_trans( yy_current_state ) 1832 yy_state_type yy_current_state; 1833 #endif 1834 { 3163 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state ) 3164 { 1835 3165 register int yy_is_jam; 1836 register char *yy_cp = yy_c_buf_p;3166 register char *yy_cp = (yy_c_buf_p); 1837 3167 1838 3168 register YY_CHAR yy_c = 1; 1839 3169 if ( yy_accept[yy_current_state] ) 1840 3170 { 1841 yy_last_accepting_state= yy_current_state;1842 yy_last_accepting_cpos= yy_cp;3171 (yy_last_accepting_state) = yy_current_state; 3172 (yy_last_accepting_cpos) = yy_cp; 1843 3173 } 1844 3174 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 1845 3175 { 1846 3176 yy_current_state = (int) yy_def[yy_current_state]; 1847 if ( yy_current_state >= 7 4)3177 if ( yy_current_state >= 77 ) 1848 3178 yy_c = yy_meta[(unsigned int) yy_c]; 1849 3179 } 1850 3180 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 1851 yy_is_jam = (yy_current_state == 7 3);3181 yy_is_jam = (yy_current_state == 76); 1852 3182 1853 3183 return yy_is_jam ? 0 : yy_current_state; 1854 } 1855 1856 1857 #ifndef YY_NO_UNPUT 1858 #ifdef YY_USE_PROTOS 1859 static void yyunput( int c, register char *yy_bp ) 1860 #else 1861 static void yyunput( c, yy_bp ) 1862 int c; 1863 register char *yy_bp; 1864 #endif 1865 { 1866 register char *yy_cp = yy_c_buf_p; 3184 } 3185 3186 static void yyunput (int c, register char * yy_bp ) 3187 { 3188 register char *yy_cp; 3189 3190 yy_cp = (yy_c_buf_p); 1867 3191 1868 3192 /* undo effects of setting up yytext */ 1869 *yy_cp = yy_hold_char;1870 1871 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )3193 *yy_cp = (yy_hold_char); 3194 3195 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) 1872 3196 { /* need to shift things up to make room */ 1873 3197 /* +2 for EOB chars. */ 1874 register int number_to_move = yy_n_chars+ 2;1875 register char *dest = & yy_current_buffer->yy_ch_buf[1876 yy_current_buffer->yy_buf_size + 2];3198 register yy_size_t number_to_move = (yy_n_chars) + 2; 3199 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ 3200 YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2]; 1877 3201 register char *source = 1878 & yy_current_buffer->yy_ch_buf[number_to_move];1879 1880 while ( source > yy_current_buffer->yy_ch_buf )3202 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]; 3203 3204 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) 1881 3205 *--dest = *--source; 1882 3206 1883 3207 yy_cp += (int) (dest - source); 1884 3208 yy_bp += (int) (dest - source); 1885 yy_current_buffer->yy_n_chars =1886 yy_n_chars = yy_current_buffer->yy_buf_size;1887 1888 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )3209 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = 3210 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size; 3211 3212 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) 1889 3213 YY_FATAL_ERROR( "flex scanner push-back overflow" ); 1890 3214 } … … 1892 3216 *--yy_cp = (char) c; 1893 3217 1894 1895 yytext_ptr = yy_bp; 1896 yy_hold_char = *yy_cp; 1897 yy_c_buf_p = yy_cp; 1898 } 1899 #endif /* ifndef YY_NO_UNPUT */ 1900 1901 3218 (yytext_ptr) = yy_bp; 3219 (yy_hold_char) = *yy_cp; 3220 (yy_c_buf_p) = yy_cp; 3221 } 3222 3223 #ifndef YY_NO_INPUT 1902 3224 #ifdef __cplusplus 1903 static int yyinput()3225 static int yyinput (void) 1904 3226 #else 1905 static int input() 1906 #endif 1907 { 3227 static int input (void) 3228 #endif 3229 3230 { 1908 3231 int c; 1909 1910 * yy_c_buf_p = yy_hold_char;1911 1912 if ( * yy_c_buf_p== YY_END_OF_BUFFER_CHAR )3232 3233 *(yy_c_buf_p) = (yy_hold_char); 3234 3235 if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR ) 1913 3236 { 1914 3237 /* yy_c_buf_p now points to the character we want to return. … … 1916 3239 * valid NUL; if not, then we've hit the end of the buffer. 1917 3240 */ 1918 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )3241 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) 1919 3242 /* This was really a NUL. */ 1920 * yy_c_buf_p= '\0';3243 *(yy_c_buf_p) = '\0'; 1921 3244 1922 3245 else 1923 3246 { /* need more input */ 1924 int offset = yy_c_buf_p - yytext_ptr;1925 ++ yy_c_buf_p;1926 1927 switch ( yy_get_next_buffer( ) )3247 yy_size_t offset = (yy_c_buf_p) - (yytext_ptr); 3248 ++(yy_c_buf_p); 3249 3250 switch ( yy_get_next_buffer( ) ) 1928 3251 { 1929 3252 case EOB_ACT_LAST_MATCH: … … 1939 3262 1940 3263 /* Reset buffer status. */ 1941 yyrestart( 1942 1943 /* fall through*/3264 yyrestart(yyin ); 3265 3266 /*FALLTHROUGH*/ 1944 3267 1945 3268 case EOB_ACT_END_OF_FILE: 1946 3269 { 1947 if ( yywrap( ) )1948 return EOF;1949 1950 if ( ! yy_did_buffer_switch_on_eof)3270 if ( yywrap( ) ) 3271 return 0; 3272 3273 if ( ! (yy_did_buffer_switch_on_eof) ) 1951 3274 YY_NEW_FILE; 1952 3275 #ifdef __cplusplus … … 1958 3281 1959 3282 case EOB_ACT_CONTINUE_SCAN: 1960 yy_c_buf_p = yytext_ptr+ offset;3283 (yy_c_buf_p) = (yytext_ptr) + offset; 1961 3284 break; 1962 3285 } … … 1964 3287 } 1965 3288 1966 c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */ 1967 *yy_c_buf_p = '\0'; /* preserve yytext */ 1968 yy_hold_char = *++yy_c_buf_p; 1969 3289 c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */ 3290 *(yy_c_buf_p) = '\0'; /* preserve yytext */ 3291 (yy_hold_char) = *++(yy_c_buf_p); 1970 3292 1971 3293 return c; 3294 } 3295 #endif /* ifndef YY_NO_INPUT */ 3296 3297 /** Immediately switch to a different input stream. 3298 * @param input_file A readable stream. 3299 * 3300 * @note This function does not reset the start condition to @c INITIAL . 3301 */ 3302 void yyrestart (FILE * input_file ) 3303 { 3304 3305 if ( ! YY_CURRENT_BUFFER ){ 3306 yyensure_buffer_stack (); 3307 YY_CURRENT_BUFFER_LVALUE = 3308 yy_create_buffer(yyin,YY_BUF_SIZE ); 1972 3309 } 1973 3310 1974 1975 #ifdef YY_USE_PROTOS 1976 void yyrestart( FILE *input_file ) 1977 #else 1978 void yyrestart( input_file ) 1979 FILE *input_file; 1980 #endif 1981 { 1982 if ( ! yy_current_buffer ) 1983 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); 1984 1985 yy_init_buffer( yy_current_buffer, input_file ); 1986 yy_load_buffer_state(); 1987 } 1988 1989 1990 #ifdef YY_USE_PROTOS 1991 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) 1992 #else 1993 void yy_switch_to_buffer( new_buffer ) 1994 YY_BUFFER_STATE new_buffer; 1995 #endif 1996 { 1997 if ( yy_current_buffer == new_buffer ) 3311 yy_init_buffer(YY_CURRENT_BUFFER,input_file ); 3312 yy_load_buffer_state( ); 3313 } 3314 3315 /** Switch to a different input buffer. 3316 * @param new_buffer The new input buffer. 3317 * 3318 */ 3319 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ) 3320 { 3321 3322 /* TODO. We should be able to replace this entire function body 3323 * with 3324 * yypop_buffer_state(); 3325 * yypush_buffer_state(new_buffer); 3326 */ 3327 yyensure_buffer_stack (); 3328 if ( YY_CURRENT_BUFFER == new_buffer ) 1998 3329 return; 1999 3330 2000 if ( yy_current_buffer)3331 if ( YY_CURRENT_BUFFER ) 2001 3332 { 2002 3333 /* Flush out information for old buffer. */ 2003 * yy_c_buf_p = yy_hold_char;2004 yy_current_buffer->yy_buf_pos = yy_c_buf_p;2005 yy_current_buffer->yy_n_chars = yy_n_chars;3334 *(yy_c_buf_p) = (yy_hold_char); 3335 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); 3336 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); 2006 3337 } 2007 3338 2008 yy_current_buffer= new_buffer;2009 yy_load_buffer_state( );3339 YY_CURRENT_BUFFER_LVALUE = new_buffer; 3340 yy_load_buffer_state( ); 2010 3341 2011 3342 /* We don't actually know whether we did this switch during … … 2014 3345 * to go ahead and always set it. 2015 3346 */ 2016 yy_did_buffer_switch_on_eof = 1; 2017 } 2018 2019 2020 #ifdef YY_USE_PROTOS 2021 void yy_load_buffer_state( void ) 2022 #else 2023 void yy_load_buffer_state() 2024 #endif 2025 { 2026 yy_n_chars = yy_current_buffer->yy_n_chars; 2027 yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos; 2028 yyin = yy_current_buffer->yy_input_file; 2029 yy_hold_char = *yy_c_buf_p; 2030 } 2031 2032 2033 #ifdef YY_USE_PROTOS 2034 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size ) 2035 #else 2036 YY_BUFFER_STATE yy_create_buffer( file, size ) 2037 FILE *file; 2038 int size; 2039 #endif 2040 { 3347 (yy_did_buffer_switch_on_eof) = 1; 3348 } 3349 3350 static void yy_load_buffer_state (void) 3351 { 3352 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; 3353 (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; 3354 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; 3355 (yy_hold_char) = *(yy_c_buf_p); 3356 } 3357 3358 /** Allocate and initialize an input buffer state. 3359 * @param file A readable stream. 3360 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. 3361 * 3362 * @return the allocated buffer state. 3363 */ 3364 YY_BUFFER_STATE yy_create_buffer (FILE * file, int size ) 3365 { 2041 3366 YY_BUFFER_STATE b; 2042 2043 b = (YY_BUFFER_STATE) yy _flex_alloc( sizeof( struct yy_buffer_state ));3367 3368 b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ); 2044 3369 if ( ! b ) 2045 3370 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); … … 2050 3375 * we need to put in 2 end-of-buffer characters. 2051 3376 */ 2052 b->yy_ch_buf = (char *) yy _flex_alloc( b->yy_buf_size + 2);3377 b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2 ); 2053 3378 if ( ! b->yy_ch_buf ) 2054 3379 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); … … 2056 3381 b->yy_is_our_buffer = 1; 2057 3382 2058 yy_init_buffer( b,file );3383 yy_init_buffer(b,file ); 2059 3384 2060 3385 return b; 2061 } 2062 2063 2064 #ifdef YY_USE_PROTOS 2065 void yy_delete_buffer( YY_BUFFER_STATE b ) 2066 #else 2067 void yy_delete_buffer( b ) 2068 YY_BUFFER_STATE b; 2069 #endif 2070 { 3386 } 3387 3388 /** Destroy the buffer. 3389 * @param b a buffer created with yy_create_buffer() 3390 * 3391 */ 3392 void yy_delete_buffer (YY_BUFFER_STATE b ) 3393 { 3394 2071 3395 if ( ! b ) 2072 3396 return; 2073 3397 2074 if ( b == yy_current_buffer )2075 yy_current_buffer= (YY_BUFFER_STATE) 0;3398 if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ 3399 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; 2076 3400 2077 3401 if ( b->yy_is_our_buffer ) 2078 yy_flex_free( (void *) b->yy_ch_buf ); 2079 2080 yy_flex_free( (void *) b ); 2081 } 2082 2083 2084 #ifndef YY_ALWAYS_INTERACTIVE 2085 #ifndef YY_NEVER_INTERACTIVE 2086 extern int isatty YY_PROTO(( int )); 2087 #endif 2088 #endif 2089 2090 #ifdef YY_USE_PROTOS 2091 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file ) 2092 #else 2093 void yy_init_buffer( b, file ) 2094 YY_BUFFER_STATE b; 2095 FILE *file; 2096 #endif 2097 2098 2099 { 2100 yy_flush_buffer( b ); 3402 yyfree((void *) b->yy_ch_buf ); 3403 3404 yyfree((void *) b ); 3405 } 3406 3407 #ifndef __cplusplus 3408 extern int isatty (int ); 3409 #endif /* __cplusplus */ 3410 3411 /* Initializes or reinitializes a buffer. 3412 * This function is sometimes called more than once on the same buffer, 3413 * such as during a yyrestart() or at EOF. 3414 */ 3415 static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file ) 3416 3417 { 3418 int oerrno = errno; 3419 3420 yy_flush_buffer(b ); 2101 3421 2102 3422 b->yy_input_file = file; 2103 3423 b->yy_fill_buffer = 1; 2104 3424 2105 #if YY_ALWAYS_INTERACTIVE 2106 b->yy_is_interactive = 1; 2107 #else 2108 #if YY_NEVER_INTERACTIVE 2109 b->yy_is_interactive = 0; 2110 #else 2111 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; 2112 #endif 2113 #endif 3425 /* If b is the current buffer, then yy_init_buffer was _probably_ 3426 * called from yyrestart() or through yy_get_next_buffer. 3427 * In that case, we don't want to reset the lineno or column. 3428 */ 3429 if (b != YY_CURRENT_BUFFER){ 3430 b->yy_bs_lineno = 1; 3431 b->yy_bs_column = 0; 2114 3432 } 2115 3433 2116 2117 #ifdef YY_USE_PROTOS 2118 void yy_flush_buffer( YY_BUFFER_STATE b ) 2119 #else 2120 void yy_flush_buffer( b ) 2121 YY_BUFFER_STATE b; 2122 #endif 2123 2124 { 3434 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; 3435 3436 errno = oerrno; 3437 } 3438 3439 /** Discard all buffered characters. On the next scan, YY_INPUT will be called. 3440 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. 3441 * 3442 */ 3443 void yy_flush_buffer (YY_BUFFER_STATE b ) 3444 { 2125 3445 if ( ! b ) 2126 3446 return; … … 2140 3460 b->yy_buffer_status = YY_BUFFER_NEW; 2141 3461 2142 if ( b == yy_current_buffer ) 2143 yy_load_buffer_state(); 3462 if ( b == YY_CURRENT_BUFFER ) 3463 yy_load_buffer_state( ); 3464 } 3465 3466 /** Pushes the new state onto the stack. The new state becomes 3467 * the current state. This function will allocate the stack 3468 * if necessary. 3469 * @param new_buffer The new state. 3470 * 3471 */ 3472 void yypush_buffer_state (YY_BUFFER_STATE new_buffer ) 3473 { 3474 if (new_buffer == NULL) 3475 return; 3476 3477 yyensure_buffer_stack(); 3478 3479 /* This block is copied from yy_switch_to_buffer. */ 3480 if ( YY_CURRENT_BUFFER ) 3481 { 3482 /* Flush out information for old buffer. */ 3483 *(yy_c_buf_p) = (yy_hold_char); 3484 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); 3485 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); 2144 3486 } 2145 3487 2146 2147 #ifndef YY_NO_SCAN_BUFFER 2148 #ifdef YY_USE_PROTOS 2149 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size ) 2150 #else 2151 YY_BUFFER_STATE yy_scan_buffer( base, size ) 2152 char *base; 2153 yy_size_t size; 2154 #endif 2155 { 3488 /* Only push if top exists. Otherwise, replace top. */ 3489 if (YY_CURRENT_BUFFER) 3490 (yy_buffer_stack_top)++; 3491 YY_CURRENT_BUFFER_LVALUE = new_buffer; 3492 3493 /* copied from yy_switch_to_buffer. */ 3494 yy_load_buffer_state( ); 3495 (yy_did_buffer_switch_on_eof) = 1; 3496 } 3497 3498 /** Removes and deletes the top of the stack, if present. 3499 * The next element becomes the new top. 3500 * 3501 */ 3502 void yypop_buffer_state (void) 3503 { 3504 if (!YY_CURRENT_BUFFER) 3505 return; 3506 3507 yy_delete_buffer(YY_CURRENT_BUFFER ); 3508 YY_CURRENT_BUFFER_LVALUE = NULL; 3509 if ((yy_buffer_stack_top) > 0) 3510 --(yy_buffer_stack_top); 3511 3512 if (YY_CURRENT_BUFFER) { 3513 yy_load_buffer_state( ); 3514 (yy_did_buffer_switch_on_eof) = 1; 3515 } 3516 } 3517 3518 /* Allocates the stack if it does not exist. 3519 * Guarantees space for at least one push. 3520 */ 3521 static void yyensure_buffer_stack (void) 3522 { 3523 yy_size_t num_to_alloc; 3524 3525 if (!(yy_buffer_stack)) { 3526 3527 /* First allocation is just for 2 elements, since we don't know if this 3528 * scanner will even need a stack. We use 2 instead of 1 to avoid an 3529 * immediate realloc on the next call. 3530 */ 3531 num_to_alloc = 1; 3532 (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc 3533 (num_to_alloc * sizeof(struct yy_buffer_state*) 3534 ); 3535 if ( ! (yy_buffer_stack) ) 3536 YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); 3537 3538 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); 3539 3540 (yy_buffer_stack_max) = num_to_alloc; 3541 (yy_buffer_stack_top) = 0; 3542 return; 3543 } 3544 3545 if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){ 3546 3547 /* Increase the buffer to prepare for a possible push. */ 3548 int grow_size = 8 /* arbitrary grow size */; 3549 3550 num_to_alloc = (yy_buffer_stack_max) + grow_size; 3551 (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc 3552 ((yy_buffer_stack), 3553 num_to_alloc * sizeof(struct yy_buffer_state*) 3554 ); 3555 if ( ! (yy_buffer_stack) ) 3556 YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); 3557 3558 /* zero only the new slots.*/ 3559 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); 3560 (yy_buffer_stack_max) = num_to_alloc; 3561 } 3562 } 3563 3564 /** Setup the input buffer state to scan directly from a user-specified character buffer. 3565 * @param base the character buffer 3566 * @param size the size in bytes of the character buffer 3567 * 3568 * @return the newly allocated buffer state object. 3569 */ 3570 YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size ) 3571 { 2156 3572 YY_BUFFER_STATE b; 2157 3573 2158 3574 if ( size < 2 || 2159 3575 base[size-2] != YY_END_OF_BUFFER_CHAR || … … 2162 3578 return 0; 2163 3579 2164 b = (YY_BUFFER_STATE) yy _flex_alloc( sizeof( struct yy_buffer_state ));3580 b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ); 2165 3581 if ( ! b ) 2166 3582 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); … … 2176 3592 b->yy_buffer_status = YY_BUFFER_NEW; 2177 3593 2178 yy_switch_to_buffer( b);3594 yy_switch_to_buffer(b ); 2179 3595 2180 3596 return b; 2181 } 2182 #endif 2183 2184 2185 #ifndef YY_NO_SCAN_STRING 2186 #ifdef YY_USE_PROTOS 2187 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str ) 2188 #else 2189 YY_BUFFER_STATE yy_scan_string( yy_str ) 2190 yyconst char *yy_str; 2191 #endif 2192 { 2193 int len; 2194 for ( len = 0; yy_str[len]; ++len ) 2195 ; 2196 2197 return yy_scan_bytes( yy_str, len ); 2198 } 2199 #endif 2200 2201 2202 #ifndef YY_NO_SCAN_BYTES 2203 #ifdef YY_USE_PROTOS 2204 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len ) 2205 #else 2206 YY_BUFFER_STATE yy_scan_bytes( bytes, len ) 2207 yyconst char *bytes; 2208 int len; 2209 #endif 2210 { 3597 } 3598 3599 /** Setup the input buffer state to scan a string. The next call to yylex() will 3600 * scan from a @e copy of @a str. 3601 * @param yystr a NUL-terminated string to scan 3602 * 3603 * @return the newly allocated buffer state object. 3604 * @note If you want to scan bytes that may contain NUL values, then use 3605 * yy_scan_bytes() instead. 3606 */ 3607 YY_BUFFER_STATE yy_scan_string (yyconst char * yystr ) 3608 { 3609 3610 return yy_scan_bytes(yystr,strlen(yystr) ); 3611 } 3612 3613 /** Setup the input buffer state to scan the given bytes. The next call to yylex() will 3614 * scan from a @e copy of @a bytes. 3615 * @param bytes the byte buffer to scan 3616 * @param len the number of bytes in the buffer pointed to by @a bytes. 3617 * 3618 * @return the newly allocated buffer state object. 3619 */ 3620 YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, yy_size_t _yybytes_len ) 3621 { 2211 3622 YY_BUFFER_STATE b; 2212 3623 char *buf; 2213 yy_size_t n; 2214 int i; 2215 3624 yy_size_t n, i; 3625 2216 3626 /* Get memory for full buffer, including space for trailing EOB's. */ 2217 n = len + 2;2218 buf = (char *) yy _flex_alloc( n);3627 n = _yybytes_len + 2; 3628 buf = (char *) yyalloc(n ); 2219 3629 if ( ! buf ) 2220 3630 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); 2221 3631 2222 for ( i = 0; i < len; ++i )2223 buf[i] = bytes[i];2224 2225 buf[ len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;2226 2227 b = yy_scan_buffer( buf,n );3632 for ( i = 0; i < _yybytes_len; ++i ) 3633 buf[i] = yybytes[i]; 3634 3635 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; 3636 3637 b = yy_scan_buffer(buf,n ); 2228 3638 if ( ! b ) 2229 3639 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); … … 2235 3645 2236 3646 return b; 2237 } 2238 #endif 2239 2240 2241 #ifndef YY_NO_PUSH_STATE 2242 #ifdef YY_USE_PROTOS 2243 static void yy_push_state( int new_state ) 2244 #else 2245 static void yy_push_state( new_state ) 2246 int new_state; 2247 #endif 2248 { 2249 if ( yy_start_stack_ptr >= yy_start_stack_depth ) 2250 { 2251 yy_size_t new_size; 2252 2253 yy_start_stack_depth += YY_START_STACK_INCR; 2254 new_size = yy_start_stack_depth * sizeof( int ); 2255 2256 if ( ! yy_start_stack ) 2257 yy_start_stack = (int *) yy_flex_alloc( new_size ); 2258 2259 else 2260 yy_start_stack = (int *) yy_flex_realloc( 2261 (void *) yy_start_stack, new_size ); 2262 2263 if ( ! yy_start_stack ) 2264 YY_FATAL_ERROR( 2265 "out of memory expanding start-condition stack" ); 2266 } 2267 2268 yy_start_stack[yy_start_stack_ptr++] = YY_START; 2269 2270 BEGIN(new_state); 2271 } 2272 #endif 2273 2274 2275 #ifndef YY_NO_POP_STATE 2276 static void yy_pop_state() 2277 { 2278 if ( --yy_start_stack_ptr < 0 ) 2279 YY_FATAL_ERROR( "start-condition stack underflow" ); 2280 2281 BEGIN(yy_start_stack[yy_start_stack_ptr]); 2282 } 2283 #endif 2284 2285 2286 #ifndef YY_NO_TOP_STATE 2287 static int yy_top_state() 2288 { 2289 return yy_start_stack[yy_start_stack_ptr - 1]; 2290 } 2291 #endif 3647 } 2292 3648 2293 3649 #ifndef YY_EXIT_FAILURE … … 2295 3651 #endif 2296 3652 2297 #ifdef YY_USE_PROTOS 2298 static void yy_fatal_error( yyconst char msg[] ) 2299 #else 2300 static void yy_fatal_error( msg ) 2301 char msg[]; 2302 #endif 2303 { 2304 (void) fprintf( stderr, "%s\n", msg ); 3653 static void yy_fatal_error (yyconst char* msg ) 3654 { 3655 (void) fprintf( stderr, "%s\n", msg ); 2305 3656 exit( YY_EXIT_FAILURE ); 2306 } 2307 2308 3657 } 2309 3658 2310 3659 /* Redefine yyless() so it works in section 3 code. */ … … 2315 3664 { \ 2316 3665 /* Undo effects of setting up yytext. */ \ 2317 yytext[yyleng] = yy_hold_char; \ 2318 yy_c_buf_p = yytext + n; \ 2319 yy_hold_char = *yy_c_buf_p; \ 2320 *yy_c_buf_p = '\0'; \ 2321 yyleng = n; \ 3666 int yyless_macro_arg = (n); \ 3667 YY_LESS_LINENO(yyless_macro_arg);\ 3668 yytext[yyleng] = (yy_hold_char); \ 3669 (yy_c_buf_p) = yytext + yyless_macro_arg; \ 3670 (yy_hold_char) = *(yy_c_buf_p); \ 3671 *(yy_c_buf_p) = '\0'; \ 3672 yyleng = yyless_macro_arg; \ 2322 3673 } \ 2323 3674 while ( 0 ) 2324 3675 2325 2326 /* Internal utility routines. */ 3676 /* Accessor methods (get/set functions) to struct members. */ 3677 3678 /** Get the current line number. 3679 * 3680 */ 3681 int yyget_lineno (void) 3682 { 3683 3684 return yylineno; 3685 } 3686 3687 /** Get the input stream. 3688 * 3689 */ 3690 FILE *yyget_in (void) 3691 { 3692 return yyin; 3693 } 3694 3695 /** Get the output stream. 3696 * 3697 */ 3698 FILE *yyget_out (void) 3699 { 3700 return yyout; 3701 } 3702 3703 /** Get the length of the current token. 3704 * 3705 */ 3706 yy_size_t yyget_leng (void) 3707 { 3708 return yyleng; 3709 } 3710 3711 /** Get the current token. 3712 * 3713 */ 3714 3715 char *yyget_text (void) 3716 { 3717 return yytext; 3718 } 3719 3720 /** Set the current line number. 3721 * @param line_number 3722 * 3723 */ 3724 void yyset_lineno (int line_number ) 3725 { 3726 3727 yylineno = line_number; 3728 } 3729 3730 /** Set the input stream. This does not discard the current 3731 * input buffer. 3732 * @param in_str A readable stream. 3733 * 3734 * @see yy_switch_to_buffer 3735 */ 3736 void yyset_in (FILE * in_str ) 3737 { 3738 yyin = in_str ; 3739 } 3740 3741 void yyset_out (FILE * out_str ) 3742 { 3743 yyout = out_str ; 3744 } 3745 3746 int yyget_debug (void) 3747 { 3748 return yy_flex_debug; 3749 } 3750 3751 void yyset_debug (int bdebug ) 3752 { 3753 yy_flex_debug = bdebug ; 3754 } 3755 3756 static int yy_init_globals (void) 3757 { 3758 /* Initialization is the same as for the non-reentrant scanner. 3759 * This function is called from yylex_destroy(), so don't allocate here. 3760 */ 3761 3762 (yy_buffer_stack) = 0; 3763 (yy_buffer_stack_top) = 0; 3764 (yy_buffer_stack_max) = 0; 3765 (yy_c_buf_p) = (char *) 0; 3766 (yy_init) = 0; 3767 (yy_start) = 0; 3768 3769 /* Defined in main.c */ 3770 #ifdef YY_STDINIT 3771 yyin = stdin; 3772 yyout = stdout; 3773 #else 3774 yyin = (FILE *) 0; 3775 yyout = (FILE *) 0; 3776 #endif 3777 3778 /* For future reference: Set errno on error, since we are called by 3779 * yylex_init() 3780 */ 3781 return 0; 3782 } 3783 3784 /* yylex_destroy is for both reentrant and non-reentrant scanners. */ 3785 int yylex_destroy (void) 3786 { 3787 3788 /* Pop the buffer stack, destroying each element. */ 3789 while(YY_CURRENT_BUFFER){ 3790 yy_delete_buffer(YY_CURRENT_BUFFER ); 3791 YY_CURRENT_BUFFER_LVALUE = NULL; 3792 yypop_buffer_state(); 3793 } 3794 3795 /* Destroy the stack itself. */ 3796 yyfree((yy_buffer_stack) ); 3797 (yy_buffer_stack) = NULL; 3798 3799 /* Reset the globals. This is important in a non-reentrant scanner so the next time 3800 * yylex() is called, initialization will occur. */ 3801 yy_init_globals( ); 3802 3803 return 0; 3804 } 3805 3806 /* 3807 * Internal utility routines. 3808 */ 2327 3809 2328 3810 #ifndef yytext_ptr 2329 #ifdef YY_USE_PROTOS 2330 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n ) 2331 #else 2332 static void yy_flex_strncpy( s1, s2, n ) 2333 char *s1; 2334 yyconst char *s2; 2335 int n; 2336 #endif 2337 { 3811 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n ) 3812 { 2338 3813 register int i; 2339 3814 for ( i = 0; i < n; ++i ) 2340 3815 s1[i] = s2[i]; 2341 3816 } 2342 3817 #endif 2343 3818 2344 3819 #ifdef YY_NEED_STRLEN 2345 #ifdef YY_USE_PROTOS 2346 static int yy_flex_strlen( yyconst char *s ) 2347 #else 2348 static int yy_flex_strlen( s ) 2349 yyconst char *s; 2350 #endif 2351 { 3820 static int yy_flex_strlen (yyconst char * s ) 3821 { 2352 3822 register int n; 2353 3823 for ( n = 0; s[n]; ++n ) … … 2355 3825 2356 3826 return n; 2357 } 2358 #endif 2359 2360 2361 #ifdef YY_USE_PROTOS 2362 static void *yy_flex_alloc( yy_size_t size ) 2363 #else 2364 static void *yy_flex_alloc( size ) 2365 yy_size_t size; 2366 #endif 2367 { 3827 } 3828 #endif 3829 3830 void *yyalloc (yy_size_t size ) 3831 { 2368 3832 return (void *) malloc( size ); 2369 } 2370 2371 #ifdef YY_USE_PROTOS 2372 static void *yy_flex_realloc( void *ptr, yy_size_t size ) 2373 #else 2374 static void *yy_flex_realloc( ptr, size ) 2375 void *ptr; 2376 yy_size_t size; 2377 #endif 2378 { 3833 } 3834 3835 void *yyrealloc (void * ptr, yy_size_t size ) 3836 { 2379 3837 /* The cast to (char *) in the following accommodates both 2380 3838 * implementations that use char* generic pointers, and those … … 2385 3843 */ 2386 3844 return (void *) realloc( (char *) ptr, size ); 2387 } 2388 2389 #ifdef YY_USE_PROTOS 2390 static void yy_flex_free( void *ptr ) 2391 #else 2392 static void yy_flex_free( ptr ) 2393 void *ptr; 2394 #endif 2395 { 2396 free( ptr ); 2397 } 2398 2399 #if YY_MAIN 2400 int main() 2401 { 2402 yylex(); 2403 return 0; 2404 } 2405 #endif 3845 } 3846 3847 void yyfree (void * ptr ) 3848 { 3849 free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ 3850 } 3851 3852 #define YYTABLES_NAME "yytables" 3853 2406 3854 #line 68 "convert.lex" 2407 3855 2408 3856 2409 3857 3858 2410 3859 int yywrap() 2411 3860 { … … 2425 3874 exit(0); 2426 3875 } 3876
Note: See TracChangeset
for help on using the changeset viewer.