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 NAME = 258, 70 LIBRARY = 259, 71 DESCRIPTION = 260, 72 STACKSIZE_K = 261, 73 HEAPSIZE = 262, 74 CODE = 263, 75 DATAU = 264, 76 DATAL = 265, 77 SECTIONS = 266, 78 EXPORTS = 267, 79 IMPORTS = 268, 80 VERSIONK = 269, 81 BASE = 270, 82 CONSTANTU = 271, 83 CONSTANTL = 272, 84 PRIVATEU = 273, 85 PRIVATEL = 274, 86 ALIGNCOMM = 275, 87 READ = 276, 88 WRITE = 277, 89 EXECUTE = 278, 90 SHARED = 279, 91 NONAMEU = 280, 92 NONAMEL = 281, 93 DIRECTIVE = 282, 94 EQUAL = 283, 95 ID = 284, 96 DIGITS = 285 97 }; 98 #endif 99 /* Tokens. */ 100 #define NAME 258 101 #define LIBRARY 259 102 #define DESCRIPTION 260 103 #define STACKSIZE_K 261 104 #define HEAPSIZE 262 105 #define CODE 263 106 #define DATAU 264 107 #define DATAL 265 108 #define SECTIONS 266 109 #define EXPORTS 267 110 #define IMPORTS 268 111 #define VERSIONK 269 112 #define BASE 270 113 #define CONSTANTU 271 114 #define CONSTANTL 272 115 #define PRIVATEU 273 116 #define PRIVATEL 274 117 #define ALIGNCOMM 275 118 #define READ 276 119 #define WRITE 277 120 #define EXECUTE 278 121 #define SHARED 279 122 #define NONAMEU 280 123 #define NONAMEL 281 124 #define DIRECTIVE 282 125 #define EQUAL 283 126 #define ID 284 127 #define DIGITS 285 128 129 130 131 132 /* Copy the first part of user declarations. */ 133 #line 1 "deffilep.y" 134 /* deffilep.y - parser for .def files */ 135 136 /* Copyright (C) 1995-2016 Free Software Foundation, Inc. 137 138 This file is part of GNU Binutils. 139 140 This program is free software; you can redistribute it and/or modify 141 it under the terms of the GNU General Public License as published by 142 the Free Software Foundation; either version 3 of the License, or 143 (at your option) any later version. 144 145 This program is distributed in the hope that it will be useful, 146 but WITHOUT ANY WARRANTY; without even the implied warranty of 147 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 148 GNU General Public License for more details. 149 150 You should have received a copy of the GNU General Public License 151 along with this program; if not, write to the Free Software 152 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 153 MA 02110-1301, USA. */ 154 155 #include "sysdep.h" 156 #include "libiberty.h" 157 #include "safe-ctype.h" 158 #include "bfd.h" 159 #include "ld.h" 160 #include "ldmisc.h" 161 #include "deffile.h" 162 163 #define TRACE 0 164 165 #define ROUND_UP(a, b) (((a)+((b)-1))&~((b)-1)) 166 167 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc), 168 as well as gratuitiously global symbol names, so we can have multiple 169 yacc generated parsers in ld. Note that these are only the variables 170 produced by yacc. If other parser generators (bison, byacc, etc) produce 171 additional global names that conflict at link time, then those parser 172 generators need to be fixed instead of adding those names to this list. */ 173 174 #define yymaxdepth def_maxdepth 175 #define yyparse def_parse 176 #define yylex def_lex 177 #define yyerror def_error 178 #define yylval def_lval 179 #define yychar def_char 180 #define yydebug def_debug 181 #define yypact def_pact 182 #define yyr1 def_r1 183 #define yyr2 def_r2 184 #define yydef def_def 185 #define yychk def_chk 186 #define yypgo def_pgo 187 #define yyact def_act 188 #define yyexca def_exca 189 #define yyerrflag def_errflag 190 #define yynerrs def_nerrs 191 #define yyps def_ps 192 #define yypv def_pv 193 #define yys def_s 194 #define yy_yys def_yys 195 #define yystate def_state 196 #define yytmp def_tmp 197 #define yyv def_v 198 #define yy_yyv def_yyv 199 #define yyval def_val 200 #define yylloc def_lloc 201 #define yyreds def_reds /* With YYDEBUG defined. */ 202 #define yytoks def_toks /* With YYDEBUG defined. */ 203 #define yylhs def_yylhs 204 #define yylen def_yylen 205 #define yydefred def_yydefred 206 #define yydgoto def_yydgoto 207 #define yysindex def_yysindex 208 #define yyrindex def_yyrindex 209 #define yygindex def_yygindex 210 #define yytable def_yytable 211 #define yycheck def_yycheck 212 213 typedef struct def_pool_str { 214 struct def_pool_str *next; 215 char data[1]; 216 } def_pool_str; 217 218 static def_pool_str *pool_strs = NULL; 219 220 static char *def_pool_alloc (size_t sz); 221 static char *def_pool_strdup (const char *str); 222 static void def_pool_free (void); 223 224 static void def_description (const char *); 225 static void def_exports (const char *, const char *, int, int, const char *); 226 static void def_heapsize (int, int); 227 static void def_import (const char *, const char *, const char *, const char *, 228 int, const char *); 229 static void def_image_name (const char *, bfd_vma, int); 230 static void def_section (const char *, int); 231 static void def_section_alt (const char *, const char *); 232 static void def_stacksize (int, int); 233 static void def_version (int, int); 234 static void def_directive (char *); 235 static void def_aligncomm (char *str, int align); 236 static int def_parse (void); 237 static int def_error (const char *); 238 static int def_lex (void); 239 240 static int lex_forced_token = 0; 241 static const char *lex_parse_string = 0; 242 static const char *lex_parse_string_end = 0; 243 244 245 246 /* Enabling traces. */ 247 #ifndef YYDEBUG 248 # define YYDEBUG 0 249 #endif 250 251 /* Enabling verbose error messages. */ 252 #ifdef YYERROR_VERBOSE 253 # undef YYERROR_VERBOSE 254 # define YYERROR_VERBOSE 1 255 #else 256 # define YYERROR_VERBOSE 0 257 #endif 258 259 /* Enabling the token table. */ 260 #ifndef YYTOKEN_TABLE 261 # define YYTOKEN_TABLE 0 262 #endif 263 264 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 265 typedef union YYSTYPE 266 #line 113 "deffilep.y" 267 { 268 char *id; 269 const char *id_const; 270 int number; 271 bfd_vma vma; 272 char *digits; 273 } 274 /* Line 193 of yacc.c. */ 275 #line 276 "deffilep.c" 276 YYSTYPE; 277 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ 278 # define YYSTYPE_IS_DECLARED 1 279 # define YYSTYPE_IS_TRIVIAL 1 280 #endif 281 282 283 284 /* Copy the second part of user declarations. */ 285 286 287 /* Line 216 of yacc.c. */ 288 #line 289 "deffilep.c" 289 290 #ifdef short 291 # undef short 292 #endif 293 294 #ifdef YYTYPE_UINT8 295 typedef YYTYPE_UINT8 yytype_uint8; 296 #else 297 typedef unsigned char yytype_uint8; 298 #endif 299 300 #ifdef YYTYPE_INT8 301 typedef YYTYPE_INT8 yytype_int8; 302 #elif (defined __STDC__ || defined __C99__FUNC__ \ 303 || defined __cplusplus || defined _MSC_VER) 304 typedef signed char yytype_int8; 305 #else 306 typedef short int yytype_int8; 307 #endif 308 309 #ifdef YYTYPE_UINT16 310 typedef YYTYPE_UINT16 yytype_uint16; 311 #else 312 typedef unsigned short int yytype_uint16; 313 #endif 314 315 #ifdef YYTYPE_INT16 316 typedef YYTYPE_INT16 yytype_int16; 317 #else 318 typedef short int yytype_int16; 319 #endif 320 321 #ifndef YYSIZE_T 322 # ifdef __SIZE_TYPE__ 323 # define YYSIZE_T __SIZE_TYPE__ 324 # elif defined size_t 325 # define YYSIZE_T size_t 326 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ 327 || defined __cplusplus || defined _MSC_VER) 328 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 329 # define YYSIZE_T size_t 330 # else 331 # define YYSIZE_T unsigned int 332 # endif 333 #endif 334 335 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) 336 337 #ifndef YY_ 338 # if defined YYENABLE_NLS && YYENABLE_NLS 339 # if ENABLE_NLS 340 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 341 # define YY_(msgid) dgettext ("bison-runtime", msgid) 342 # endif 343 # endif 344 # ifndef YY_ 345 # define YY_(msgid) msgid 346 # endif 347 #endif 348 349 /* Suppress unused-variable warnings by "using" E. */ 350 #if ! defined lint || defined __GNUC__ 351 # define YYUSE(e) ((void) (e)) 352 #else 353 # define YYUSE(e) /* empty */ 354 #endif 355 356 /* Identity function, used to suppress warnings about constant conditions. */ 357 #ifndef lint 358 # define YYID(n) (n) 359 #else 360 #if (defined __STDC__ || defined __C99__FUNC__ \ 361 || defined __cplusplus || defined _MSC_VER) 362 static int 363 YYID (int i) 364 #else 365 static int 366 YYID (i) 367 int i; 368 #endif 369 { 370 return i; 371 } 372 #endif 373 374 #if ! defined yyoverflow || YYERROR_VERBOSE 375 376 /* The parser invokes alloca or malloc; define the necessary symbols. */ 377 378 # ifdef YYSTACK_USE_ALLOCA 379 # if YYSTACK_USE_ALLOCA 380 # ifdef __GNUC__ 381 # define YYSTACK_ALLOC __builtin_alloca 382 # elif defined __BUILTIN_VA_ARG_INCR 383 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */ 384 # elif defined _AIX 385 # define YYSTACK_ALLOC __alloca 386 # elif defined _MSC_VER 387 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */ 388 # define alloca _alloca 389 # else 390 # define YYSTACK_ALLOC alloca 391 # if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 392 || defined __cplusplus || defined _MSC_VER) 393 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 394 # ifndef _STDLIB_H 395 # define _STDLIB_H 1 396 # endif 397 # endif 398 # endif 399 # endif 400 # endif 401 402 # ifdef YYSTACK_ALLOC 403 /* Pacify GCC's `empty if-body' warning. */ 404 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) 405 # ifndef YYSTACK_ALLOC_MAXIMUM 406 /* The OS might guarantee only one guard page at the bottom of the stack, 407 and a page size can be as small as 4096 bytes. So we cannot safely 408 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number 409 to allow for a few compiler-allocated temporary stack slots. */ 410 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ 411 # endif 412 # else 413 # define YYSTACK_ALLOC YYMALLOC 414 # define YYSTACK_FREE YYFREE 415 # ifndef YYSTACK_ALLOC_MAXIMUM 416 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM 417 # endif 418 # if (defined __cplusplus && ! defined _STDLIB_H \ 419 && ! ((defined YYMALLOC || defined malloc) \ 420 && (defined YYFREE || defined free))) 421 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 422 # ifndef _STDLIB_H 423 # define _STDLIB_H 1 424 # endif 425 # endif 426 # ifndef YYMALLOC 427 # define YYMALLOC malloc 428 # if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 429 || defined __cplusplus || defined _MSC_VER) 430 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ 431 # endif 432 # endif 433 # ifndef YYFREE 434 # define YYFREE free 435 # if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 436 || defined __cplusplus || defined _MSC_VER) 437 void free (void *); /* INFRINGES ON USER NAME SPACE */ 438 # endif 439 # endif 440 # endif 441 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */ 442 443 444 #if (! defined yyoverflow \ 445 && (! defined __cplusplus \ 446 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) 447 448 /* A type that is properly aligned for any stack member. */ 449 union yyalloc 450 { 451 yytype_int16 yyss; 452 YYSTYPE yyvs; 453 }; 454 455 /* The size of the maximum gap between one aligned stack and the next. */ 456 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 457 458 /* The size of an array large to enough to hold all stacks, each with 459 N elements. */ 460 # define YYSTACK_BYTES(N) \ 461 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ 462 + YYSTACK_GAP_MAXIMUM) 463 464 /* Copy COUNT objects from FROM to TO. The source and destination do 465 not overlap. */ 466 # ifndef YYCOPY 467 # if defined __GNUC__ && 1 < __GNUC__ 468 # define YYCOPY(To, From, Count) \ 469 __builtin_memcpy (To, From, (Count) * sizeof (*(From))) 470 # else 471 # define YYCOPY(To, From, Count) \ 472 do \ 473 { \ 474 YYSIZE_T yyi; \ 475 for (yyi = 0; yyi < (Count); yyi++) \ 476 (To)[yyi] = (From)[yyi]; \ 477 } \ 478 while (YYID (0)) 479 # endif 480 # endif 481 482 /* Relocate STACK from its old location to the new one. The 483 local variables YYSIZE and YYSTACKSIZE give the old and new number of 484 elements in the stack, and YYPTR gives the new location of the 485 stack. Advance YYPTR to a properly aligned location for the next 486 stack. */ 487 # define YYSTACK_RELOCATE(Stack) \ 488 do \ 489 { \ 490 YYSIZE_T yynewbytes; \ 491 YYCOPY (&yyptr->Stack, Stack, yysize); \ 492 Stack = &yyptr->Stack; \ 493 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 494 yyptr += yynewbytes / sizeof (*yyptr); \ 495 } \ 496 while (YYID (0)) 497 498 #endif 499 500 /* YYFINAL -- State number of the termination state. */ 501 #define YYFINAL 69 502 /* YYLAST -- Last index in YYTABLE. */ 503 #define YYLAST 149 504 505 /* YYNTOKENS -- Number of terminals. */ 506 #define YYNTOKENS 35 507 /* YYNNTS -- Number of nonterminals. */ 508 #define YYNNTS 27 509 /* YYNRULES -- Number of rules. */ 510 #define YYNRULES 99 511 /* YYNRULES -- Number of states. */ 512 #define YYNSTATES 146 513 514 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ 515 #define YYUNDEFTOK 2 516 #define YYMAXUTOK 285 517 518 #define YYTRANSLATE(YYX) \ 519 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) 520 521 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ 522 static const yytype_uint8 yytranslate[] = 523 { 524 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 525 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 526 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 527 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 528 2, 2, 2, 2, 32, 2, 31, 2, 2, 2, 529 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 530 2, 33, 2, 2, 34, 2, 2, 2, 2, 2, 531 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 532 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 533 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 534 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 535 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 536 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 537 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 538 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 539 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 540 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 541 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 542 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 543 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 544 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 545 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 546 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 547 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 548 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 549 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 550 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 551 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 552 25, 26, 27, 28, 29, 30 553 }; 554 555 #if YYDEBUG 556 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in 557 YYRHS. */ 558 static const yytype_uint16 yyprhs[] = 559 { 560 0, 0, 3, 6, 8, 12, 16, 19, 23, 27, 561 30, 33, 36, 39, 42, 45, 50, 53, 58, 59, 562 61, 64, 72, 76, 77, 79, 81, 83, 85, 87, 563 89, 91, 93, 96, 98, 107, 116, 123, 130, 137, 564 142, 145, 147, 150, 153, 157, 159, 161, 162, 165, 565 166, 168, 170, 172, 174, 176, 178, 180, 182, 184, 566 186, 188, 190, 192, 194, 196, 198, 200, 202, 204, 567 206, 208, 210, 212, 214, 216, 218, 220, 223, 226, 568 230, 234, 236, 237, 240, 241, 244, 245, 248, 249, 569 253, 254, 256, 259, 264, 266, 267, 269, 270, 272 570 }; 571 572 /* YYRHS -- A `-1'-separated list of the rules' RHS. */ 573 static const yytype_int8 yyrhs[] = 574 { 575 36, 0, -1, 36, 37, -1, 37, -1, 3, 52, 576 56, -1, 4, 52, 56, -1, 5, 29, -1, 6, 577 60, 48, -1, 7, 60, 48, -1, 8, 46, -1, 578 9, 46, -1, 11, 44, -1, 12, 38, -1, 13, 579 42, -1, 14, 60, -1, 14, 60, 31, 60, -1, 580 27, 29, -1, 20, 57, 32, 60, -1, -1, 39, 581 -1, 38, 39, -1, 51, 55, 54, 47, 40, 47, 582 53, -1, 41, 47, 40, -1, -1, 25, -1, 26, 583 -1, 16, -1, 17, -1, 9, -1, 10, -1, 18, 584 -1, 19, -1, 42, 43, -1, 43, -1, 29, 33, 585 29, 31, 29, 31, 29, 53, -1, 29, 33, 29, 586 31, 29, 31, 60, 53, -1, 29, 33, 29, 31, 587 29, 53, -1, 29, 33, 29, 31, 60, 53, -1, 588 29, 31, 29, 31, 29, 53, -1, 29, 31, 29, 589 53, -1, 44, 45, -1, 45, -1, 29, 46, -1, 590 29, 29, -1, 46, 47, 49, -1, 49, -1, 32, 591 -1, -1, 32, 60, -1, -1, 21, -1, 22, -1, 592 23, -1, 24, -1, 15, -1, 8, -1, 16, -1, 593 17, -1, 9, -1, 10, -1, 5, -1, 27, -1, 594 23, -1, 12, -1, 7, -1, 13, -1, 3, -1, 595 25, -1, 26, -1, 18, -1, 19, -1, 21, -1, 596 24, -1, 6, -1, 14, -1, 22, -1, 29, -1, 597 31, 50, -1, 31, 51, -1, 50, 31, 51, -1, 598 29, 31, 51, -1, 51, -1, -1, 28, 29, -1, 599 -1, 34, 60, -1, -1, 33, 51, -1, -1, 15, 600 33, 61, -1, -1, 29, -1, 31, 29, -1, 57, 601 31, 58, 59, -1, 30, -1, -1, 29, -1, -1, 602 30, -1, 30, -1 603 }; 604 605 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ 606 static const yytype_uint16 yyrline[] = 607 { 608 0, 138, 138, 139, 143, 144, 145, 146, 147, 148, 609 149, 150, 151, 152, 153, 154, 155, 156, 160, 162, 610 163, 170, 177, 178, 181, 182, 183, 184, 185, 186, 611 187, 188, 191, 192, 196, 198, 200, 202, 204, 206, 612 211, 212, 216, 217, 221, 222, 226, 227, 229, 230, 613 234, 235, 236, 237, 241, 242, 243, 244, 245, 246, 614 247, 248, 249, 250, 251, 252, 259, 260, 261, 262, 615 263, 264, 265, 266, 267, 268, 271, 272, 278, 284, 616 290, 298, 299, 302, 303, 307, 308, 312, 313, 316, 617 317, 320, 321, 327, 335, 336, 339, 340, 343, 345 618 }; 619 #endif 620 621 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE 622 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 623 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 624 static const char *const yytname[] = 625 { 626 "$end", "error", "$undefined", "NAME", "LIBRARY", "DESCRIPTION", 627 "STACKSIZE_K", "HEAPSIZE", "CODE", "DATAU", "DATAL", "SECTIONS", 628 "EXPORTS", "IMPORTS", "VERSIONK", "BASE", "CONSTANTU", "CONSTANTL", 629 "PRIVATEU", "PRIVATEL", "ALIGNCOMM", "READ", "WRITE", "EXECUTE", 630 "SHARED", "NONAMEU", "NONAMEL", "DIRECTIVE", "EQUAL", "ID", "DIGITS", 631 "'.'", "','", "'='", "'@'", "$accept", "start", "command", "explist", 632 "expline", "exp_opt_list", "exp_opt", "implist", "impline", "seclist", 633 "secline", "attr_list", "opt_comma", "opt_number", "attr", 634 "keyword_as_name", "opt_name2", "opt_name", "opt_equalequal_name", 635 "opt_ordinal", "opt_equal_name", "opt_base", "anylang_id", "opt_digits", 636 "opt_id", "NUMBER", "VMA", 0 637 }; 638 #endif 639 640 # ifdef YYPRINT 641 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to 642 token YYLEX-NUM. */ 643 static const yytype_uint16 yytoknum[] = 644 { 645 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 646 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 647 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 648 285, 46, 44, 61, 64 649 }; 650 # endif 651 652 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 653 static const yytype_uint8 yyr1[] = 654 { 655 0, 35, 36, 36, 37, 37, 37, 37, 37, 37, 656 37, 37, 37, 37, 37, 37, 37, 37, 38, 38, 657 38, 39, 40, 40, 41, 41, 41, 41, 41, 41, 658 41, 41, 42, 42, 43, 43, 43, 43, 43, 43, 659 44, 44, 45, 45, 46, 46, 47, 47, 48, 48, 660 49, 49, 49, 49, 50, 50, 50, 50, 50, 50, 661 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 662 50, 50, 50, 50, 50, 50, 51, 51, 51, 51, 663 51, 52, 52, 53, 53, 54, 54, 55, 55, 56, 664 56, 57, 57, 57, 58, 58, 59, 59, 60, 61 665 }; 666 667 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ 668 static const yytype_uint8 yyr2[] = 669 { 670 0, 2, 2, 1, 3, 3, 2, 3, 3, 2, 671 2, 2, 2, 2, 2, 4, 2, 4, 0, 1, 672 2, 7, 3, 0, 1, 1, 1, 1, 1, 1, 673 1, 1, 2, 1, 8, 8, 6, 6, 6, 4, 674 2, 1, 2, 2, 3, 1, 1, 0, 2, 0, 675 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 676 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 677 1, 1, 1, 1, 1, 1, 1, 2, 2, 3, 678 3, 1, 0, 2, 0, 2, 0, 2, 0, 3, 679 0, 1, 2, 4, 1, 0, 1, 0, 1, 1 680 }; 681 682 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state 683 STATE-NUM when YYTABLE doesn't specify something else to do. Zero 684 means the default is an error. */ 685 static const yytype_uint8 yydefact[] = 686 { 687 0, 82, 82, 0, 0, 0, 0, 0, 0, 18, 688 0, 0, 0, 0, 0, 3, 66, 60, 73, 64, 689 55, 58, 59, 63, 65, 74, 54, 56, 57, 69, 690 70, 71, 75, 62, 72, 67, 68, 61, 76, 0, 691 0, 81, 90, 90, 6, 98, 49, 49, 50, 51, 692 52, 53, 9, 45, 10, 0, 11, 41, 12, 19, 693 88, 0, 13, 33, 14, 91, 0, 0, 16, 1, 694 2, 0, 77, 78, 0, 0, 4, 5, 0, 7, 695 8, 46, 0, 43, 42, 40, 20, 0, 86, 0, 696 0, 32, 0, 92, 95, 0, 80, 79, 0, 48, 697 44, 87, 0, 47, 84, 0, 15, 94, 97, 17, 698 99, 89, 85, 23, 0, 0, 39, 0, 96, 93, 699 28, 29, 26, 27, 30, 31, 24, 25, 47, 47, 700 83, 84, 84, 84, 84, 23, 38, 0, 36, 37, 701 21, 22, 84, 84, 34, 35 702 }; 703 704 /* YYDEFGOTO[NTERM-NUM]. */ 705 static const yytype_int16 yydefgoto[] = 706 { 707 -1, 14, 15, 58, 59, 128, 129, 62, 63, 56, 708 57, 52, 82, 79, 53, 40, 41, 42, 116, 103, 709 88, 76, 67, 108, 119, 46, 111 710 }; 711 712 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 713 STATE-NUM. */ 714 #define YYPACT_NINF -82 715 static const yytype_int8 yypact[] = 716 { 717 122, 11, 11, -25, 9, 9, 53, 53, -17, 11, 718 14, 9, -18, 20, 95, -82, -82, -82, -82, -82, 719 -82, -82, -82, -82, -82, -82, -82, -82, -82, -82, 720 -82, -82, -82, -82, -82, -82, -82, -82, 29, 11, 721 47, -82, 67, 67, -82, -82, 54, 54, -82, -82, 722 -82, -82, 48, -82, 48, -14, -17, -82, 11, -82, 723 58, 50, 14, -82, 61, -82, 64, 33, -82, -82, 724 -82, 11, 47, -82, 11, 63, -82, -82, 9, -82, 725 -82, -82, 53, -82, 48, -82, -82, 11, 60, 76, 726 81, -82, 9, -82, 83, 9, -82, -82, 84, -82, 727 -82, -82, 9, 79, -26, 85, -82, -82, 88, -82, 728 -82, -82, -82, 36, 89, 90, -82, 55, -82, -82, 729 -82, -82, -82, -82, -82, -82, -82, -82, 79, 79, 730 -82, 92, 13, 92, 92, 36, -82, 59, -82, -82, 731 -82, -82, 92, 92, -82, -82 732 }; 733 734 /* YYPGOTO[NTERM-NUM]. */ 735 static const yytype_int16 yypgoto[] = 736 { 737 -82, -82, 107, -82, 65, -11, -82, -82, 75, -82, 738 82, -4, -81, 93, 57, 102, -8, 141, -75, -82, 739 -82, 101, -82, -82, -82, -5, -82 740 }; 741 742 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If 743 positive, shift that token. If negative, reduce the rule which 744 number is the opposite. If zero, do what YYDEFACT says. 745 If YYTABLE_NINF, syntax error. */ 746 #define YYTABLE_NINF -48 747 static const yytype_int16 yytable[] = 748 { 749 47, 60, 114, 54, 44, 115, 64, 48, 49, 50, 750 51, 65, 55, 66, 16, 83, 17, 18, 19, 20, 751 21, 22, 113, 23, 24, 25, 26, 27, 28, 29, 752 30, 73, 31, 32, 33, 34, 35, 36, 37, 45, 753 38, 114, 39, 61, 137, 120, 121, 134, 135, 68, 754 60, 84, 122, 123, 124, 125, 136, 138, 139, 140, 755 71, 126, 127, 96, 94, 95, 97, 144, 145, -47, 756 -47, -47, -47, 99, 48, 49, 50, 51, 74, 101, 757 81, 89, 75, 90, 132, 45, 78, 106, 142, 45, 758 109, 87, 92, 93, 102, 69, 98, 112, 1, 2, 759 3, 4, 5, 6, 7, 104, 8, 9, 10, 11, 760 105, 81, 133, 107, 110, 12, 117, 118, 130, 131, 761 114, 70, 13, 86, 141, 1, 2, 3, 4, 5, 762 6, 7, 143, 8, 9, 10, 11, 91, 85, 100, 763 80, 72, 12, 43, 77, 0, 0, 0, 0, 13 764 }; 765 766 static const yytype_int16 yycheck[] = 767 { 768 5, 9, 28, 7, 29, 31, 11, 21, 22, 23, 769 24, 29, 29, 31, 3, 29, 5, 6, 7, 8, 770 9, 10, 103, 12, 13, 14, 15, 16, 17, 18, 771 19, 39, 21, 22, 23, 24, 25, 26, 27, 30, 772 29, 28, 31, 29, 31, 9, 10, 128, 129, 29, 773 58, 55, 16, 17, 18, 19, 131, 132, 133, 134, 774 31, 25, 26, 71, 31, 32, 74, 142, 143, 21, 775 22, 23, 24, 78, 21, 22, 23, 24, 31, 87, 776 32, 31, 15, 33, 29, 30, 32, 92, 29, 30, 777 95, 33, 31, 29, 34, 0, 33, 102, 3, 4, 778 5, 6, 7, 8, 9, 29, 11, 12, 13, 14, 779 29, 32, 117, 30, 30, 20, 31, 29, 29, 29, 780 28, 14, 27, 58, 135, 3, 4, 5, 6, 7, 781 8, 9, 137, 11, 12, 13, 14, 62, 56, 82, 782 47, 39, 20, 2, 43, -1, -1, -1, -1, 27 783 }; 784 785 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 786 symbol of state STATE-NUM. */ 787 static const yytype_uint8 yystos[] = 788 { 789 0, 3, 4, 5, 6, 7, 8, 9, 11, 12, 790 13, 14, 20, 27, 36, 37, 3, 5, 6, 7, 791 8, 9, 10, 12, 13, 14, 15, 16, 17, 18, 792 19, 21, 22, 23, 24, 25, 26, 27, 29, 31, 793 50, 51, 52, 52, 29, 30, 60, 60, 21, 22, 794 23, 24, 46, 49, 46, 29, 44, 45, 38, 39, 795 51, 29, 42, 43, 60, 29, 31, 57, 29, 0, 796 37, 31, 50, 51, 31, 15, 56, 56, 32, 48, 797 48, 32, 47, 29, 46, 45, 39, 33, 55, 31, 798 33, 43, 31, 29, 31, 32, 51, 51, 33, 60, 799 49, 51, 34, 54, 29, 29, 60, 30, 58, 60, 800 30, 61, 60, 47, 28, 31, 53, 31, 29, 59, 801 9, 10, 16, 17, 18, 19, 25, 26, 40, 41, 802 29, 29, 29, 60, 47, 47, 53, 31, 53, 53, 803 53, 40, 29, 60, 53, 53 804 }; 805 806 #define yyerrok (yyerrstatus = 0) 807 #define yyclearin (yychar = YYEMPTY) 808 #define YYEMPTY (-2) 809 #define YYEOF 0 810 811 #define YYACCEPT goto yyacceptlab 812 #define YYABORT goto yyabortlab 813 #define YYERROR goto yyerrorlab 814 815 816 /* Like YYERROR except do call yyerror. This remains here temporarily 817 to ease the transition to the new meaning of YYERROR, for GCC. 818 Once GCC version 2 has supplanted version 1, this can go. */ 819 820 #define YYFAIL goto yyerrlab 821 822 #define YYRECOVERING() (!!yyerrstatus) 823 824 #define YYBACKUP(Token, Value) \ 825 do \ 826 if (yychar == YYEMPTY && yylen == 1) \ 827 { \ 828 yychar = (Token); \ 829 yylval = (Value); \ 830 yytoken = YYTRANSLATE (yychar); \ 831 YYPOPSTACK (1); \ 832 goto yybackup; \ 833 } \ 834 else \ 835 { \ 836 yyerror (YY_("syntax error: cannot back up")); \ 837 YYERROR; \ 838 } \ 839 while (YYID (0)) 840 841 842 #define YYTERROR 1 843 #define YYERRCODE 256 844 845 846 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. 847 If N is 0, then set CURRENT to the empty location which ends 848 the previous symbol: RHS[0] (always defined). */ 849 850 #define YYRHSLOC(Rhs, K) ((Rhs)[K]) 851 #ifndef YYLLOC_DEFAULT 852 # define YYLLOC_DEFAULT(Current, Rhs, N) \ 853 do \ 854 if (YYID (N)) \ 855 { \ 856 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ 857 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ 858 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ 859 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ 860 } \ 861 else \ 862 { \ 863 (Current).first_line = (Current).last_line = \ 864 YYRHSLOC (Rhs, 0).last_line; \ 865 (Current).first_column = (Current).last_column = \ 866 YYRHSLOC (Rhs, 0).last_column; \ 867 } \ 868 while (YYID (0)) 869 #endif 870 871 872 /* YY_LOCATION_PRINT -- Print the location on the stream. 873 This macro was not mandated originally: define only if we know 874 we won't break user code: when these are the locations we know. */ 875 876 #ifndef YY_LOCATION_PRINT 877 # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL 878 # define YY_LOCATION_PRINT(File, Loc) \ 879 fprintf (File, "%d.%d-%d.%d", \ 880 (Loc).first_line, (Loc).first_column, \ 881 (Loc).last_line, (Loc).last_column) 882 # else 883 # define YY_LOCATION_PRINT(File, Loc) ((void) 0) 884 # endif 885 #endif 886 887 888 /* YYLEX -- calling `yylex' with the right arguments. */ 889 890 #ifdef YYLEX_PARAM 891 # define YYLEX yylex (YYLEX_PARAM) 892 #else 893 # define YYLEX yylex () 894 #endif 895 896 /* Enable debugging if requested. */ 897 #if YYDEBUG 898 899 # ifndef YYFPRINTF 900 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 901 # define YYFPRINTF fprintf 902 # endif 903 904 # define YYDPRINTF(Args) \ 905 do { \ 906 if (yydebug) \ 907 YYFPRINTF Args; \ 908 } while (YYID (0)) 909 910 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ 911 do { \ 912 if (yydebug) \ 913 { \ 914 YYFPRINTF (stderr, "%s ", Title); \ 915 yy_symbol_print (stderr, \ 916 Type, Value); \ 917 YYFPRINTF (stderr, "\n"); \ 918 } \ 919 } while (YYID (0)) 920 921 922 /*--------------------------------. 923 | Print this symbol on YYOUTPUT. | 924 `--------------------------------*/ 925 926 /*ARGSUSED*/ 927 #if (defined __STDC__ || defined __C99__FUNC__ \ 928 || defined __cplusplus || defined _MSC_VER) 929 static void 930 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 931 #else 932 static void 933 yy_symbol_value_print (yyoutput, yytype, yyvaluep) 934 FILE *yyoutput; 935 int yytype; 936 YYSTYPE const * const yyvaluep; 937 #endif 938 { 939 if (!yyvaluep) 940 return; 941 # ifdef YYPRINT 942 if (yytype < YYNTOKENS) 943 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); 944 # else 945 YYUSE (yyoutput); 946 # endif 947 switch (yytype) 948 { 949 default: 950 break; 951 } 952 } 953 954 955 /*--------------------------------. 956 | Print this symbol on YYOUTPUT. | 957 `--------------------------------*/ 958 959 #if (defined __STDC__ || defined __C99__FUNC__ \ 960 || defined __cplusplus || defined _MSC_VER) 961 static void 962 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 963 #else 964 static void 965 yy_symbol_print (yyoutput, yytype, yyvaluep) 966 FILE *yyoutput; 967 int yytype; 968 YYSTYPE const * const yyvaluep; 969 #endif 970 { 971 if (yytype < YYNTOKENS) 972 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); 973 else 974 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); 975 976 yy_symbol_value_print (yyoutput, yytype, yyvaluep); 977 YYFPRINTF (yyoutput, ")"); 978 } 979 980 /*------------------------------------------------------------------. 981 | yy_stack_print -- Print the state stack from its BOTTOM up to its | 982 | TOP (included). | 983 `------------------------------------------------------------------*/ 984 985 #if (defined __STDC__ || defined __C99__FUNC__ \ 986 || defined __cplusplus || defined _MSC_VER) 987 static void 988 yy_stack_print (yytype_int16 *bottom, yytype_int16 *top) 989 #else 990 static void 991 yy_stack_print (bottom, top) 992 yytype_int16 *bottom; 993 yytype_int16 *top; 994 #endif 995 { 996 YYFPRINTF (stderr, "Stack now"); 997 for (; bottom <= top; ++bottom) 998 YYFPRINTF (stderr, " %d", *bottom); 999 YYFPRINTF (stderr, "\n"); 1000 } 1001 1002 # define YY_STACK_PRINT(Bottom, Top) \ 1003 do { \ 1004 if (yydebug) \ 1005 yy_stack_print ((Bottom), (Top)); \ 1006 } while (YYID (0)) 1007 1008 1009 /*------------------------------------------------. 1010 | Report that the YYRULE is going to be reduced. | 1011 `------------------------------------------------*/ 1012 1013 #if (defined __STDC__ || defined __C99__FUNC__ \ 1014 || defined __cplusplus || defined _MSC_VER) 1015 static void 1016 yy_reduce_print (YYSTYPE *yyvsp, int yyrule) 1017 #else 1018 static void 1019 yy_reduce_print (yyvsp, yyrule) 1020 YYSTYPE *yyvsp; 1021 int yyrule; 1022 #endif 1023 { 1024 int yynrhs = yyr2[yyrule]; 1025 int yyi; 1026 unsigned long int yylno = yyrline[yyrule]; 1027 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", 1028 yyrule - 1, yylno); 1029 /* The symbols being reduced. */ 1030 for (yyi = 0; yyi < yynrhs; yyi++) 1031 { 1032 fprintf (stderr, " $%d = ", yyi + 1); 1033 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], 1034 &(yyvsp[(yyi + 1) - (yynrhs)]) 1035 ); 1036 fprintf (stderr, "\n"); 1037 } 1038 } 1039 1040 # define YY_REDUCE_PRINT(Rule) \ 1041 do { \ 1042 if (yydebug) \ 1043 yy_reduce_print (yyvsp, Rule); \ 1044 } while (YYID (0)) 1045 1046 /* Nonzero means print parse trace. It is left uninitialized so that 1047 multiple parsers can coexist. */ 1048 int yydebug; 1049 #else /* !YYDEBUG */ 1050 # define YYDPRINTF(Args) 1051 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) 1052 # define YY_STACK_PRINT(Bottom, Top) 1053 # define YY_REDUCE_PRINT(Rule) 1054 #endif /* !YYDEBUG */ 1055 1056 1057 /* YYINITDEPTH -- initial size of the parser's stacks. */ 1058 #ifndef YYINITDEPTH 1059 # define YYINITDEPTH 200 1060 #endif 1061 1062 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 1063 if the built-in stack extension method is used). 1064 1065 Do not make this value too large; the results are undefined if 1066 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) 1067 evaluated with infinite-precision integer arithmetic. */ 1068 1069 #ifndef YYMAXDEPTH 1070 # define YYMAXDEPTH 10000 1071 #endif 1072 1073 1074 1075 #if YYERROR_VERBOSE 1076 1077 # ifndef yystrlen 1078 # if defined __GLIBC__ && defined _STRING_H 1079 # define yystrlen strlen 1080 # else 1081 /* Return the length of YYSTR. */ 1082 #if (defined __STDC__ || defined __C99__FUNC__ \ 1083 || defined __cplusplus || defined _MSC_VER) 1084 static YYSIZE_T 1085 yystrlen (const char *yystr) 1086 #else 1087 static YYSIZE_T 1088 yystrlen (yystr) 1089 const char *yystr; 1090 #endif 1091 { 1092 YYSIZE_T yylen; 1093 for (yylen = 0; yystr[yylen]; yylen++) 1094 continue; 1095 return yylen; 1096 } 1097 # endif 1098 # endif 1099 1100 # ifndef yystpcpy 1101 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE 1102 # define yystpcpy stpcpy 1103 # else 1104 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 1105 YYDEST. */ 1106 #if (defined __STDC__ || defined __C99__FUNC__ \ 1107 || defined __cplusplus || defined _MSC_VER) 1108 static char * 1109 yystpcpy (char *yydest, const char *yysrc) 1110 #else 1111 static char * 1112 yystpcpy (yydest, yysrc) 1113 char *yydest; 1114 const char *yysrc; 1115 #endif 1116 { 1117 char *yyd = yydest; 1118 const char *yys = yysrc; 1119 1120 while ((*yyd++ = *yys++) != '\0') 1121 continue; 1122 1123 return yyd - 1; 1124 } 1125 # endif 1126 # endif 1127 1128 # ifndef yytnamerr 1129 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary 1130 quotes and backslashes, so that it's suitable for yyerror. The 1131 heuristic is that double-quoting is unnecessary unless the string 1132 contains an apostrophe, a comma, or backslash (other than 1133 backslash-backslash). YYSTR is taken from yytname. If YYRES is 1134 null, do not copy; instead, return the length of what the result 1135 would have been. */ 1136 static YYSIZE_T 1137 yytnamerr (char *yyres, const char *yystr) 1138 { 1139 if (*yystr == '"') 1140 { 1141 YYSIZE_T yyn = 0; 1142 char const *yyp = yystr; 1143 1144 for (;;) 1145 switch (*++yyp) 1146 { 1147 case '\'': 1148 case ',': 1149 goto do_not_strip_quotes; 1150 1151 case '\\': 1152 if (*++yyp != '\\') 1153 goto do_not_strip_quotes; 1154 /* Fall through. */ 1155 default: 1156 if (yyres) 1157 yyres[yyn] = *yyp; 1158 yyn++; 1159 break; 1160 1161 case '"': 1162 if (yyres) 1163 yyres[yyn] = '\0'; 1164 return yyn; 1165 } 1166 do_not_strip_quotes: ; 1167 } 1168 1169 if (! yyres) 1170 return yystrlen (yystr); 1171 1172 return yystpcpy (yyres, yystr) - yyres; 1173 } 1174 # endif 1175 1176 /* Copy into YYRESULT an error message about the unexpected token 1177 YYCHAR while in state YYSTATE. Return the number of bytes copied, 1178 including the terminating null byte. If YYRESULT is null, do not 1179 copy anything; just return the number of bytes that would be 1180 copied. As a special case, return 0 if an ordinary "syntax error" 1181 message will do. Return YYSIZE_MAXIMUM if overflow occurs during 1182 size calculation. */ 1183 static YYSIZE_T 1184 yysyntax_error (char *yyresult, int yystate, int yychar) 1185 { 1186 int yyn = yypact[yystate]; 1187 1188 if (! (YYPACT_NINF < yyn && yyn <= YYLAST)) 1189 return 0; 1190 else 1191 { 1192 int yytype = YYTRANSLATE (yychar); 1193 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); 1194 YYSIZE_T yysize = yysize0; 1195 YYSIZE_T yysize1; 1196 int yysize_overflow = 0; 1197 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 1198 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 1199 int yyx; 1200 1201 # if 0 1202 /* This is so xgettext sees the translatable formats that are 1203 constructed on the fly. */ 1204 YY_("syntax error, unexpected %s"); 1205 YY_("syntax error, unexpected %s, expecting %s"); 1206 YY_("syntax error, unexpected %s, expecting %s or %s"); 1207 YY_("syntax error, unexpected %s, expecting %s or %s or %s"); 1208 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); 1209 # endif 1210 char *yyfmt; 1211 char const *yyf; 1212 static char const yyunexpected[] = "syntax error, unexpected %s"; 1213 static char const yyexpecting[] = ", expecting %s"; 1214 static char const yyor[] = " or %s"; 1215 char yyformat[sizeof yyunexpected 1216 + sizeof yyexpecting - 1 1217 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) 1218 * (sizeof yyor - 1))]; 1219 char const *yyprefix = yyexpecting; 1220 1221 /* Start YYX at -YYN if negative to avoid negative indexes in 1222 YYCHECK. */ 1223 int yyxbegin = yyn < 0 ? -yyn : 0; 1224 1225 /* Stay within bounds of both yycheck and yytname. */ 1226 int yychecklim = YYLAST - yyn + 1; 1227 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 1228 int yycount = 1; 1229 1230 yyarg[0] = yytname[yytype]; 1231 yyfmt = yystpcpy (yyformat, yyunexpected); 1232 1233 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 1234 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) 1235 { 1236 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) 1237 { 1238 yycount = 1; 1239 yysize = yysize0; 1240 yyformat[sizeof yyunexpected - 1] = '\0'; 1241 break; 1242 } 1243 yyarg[yycount++] = yytname[yyx]; 1244 yysize1 = yysize + yytnamerr (0, yytname[yyx]); 1245 yysize_overflow |= (yysize1 < yysize); 1246 yysize = yysize1; 1247 yyfmt = yystpcpy (yyfmt, yyprefix); 1248 yyprefix = yyor; 1249 } 1250 1251 yyf = YY_(yyformat); 1252 yysize1 = yysize + yystrlen (yyf); 1253 yysize_overflow |= (yysize1 < yysize); 1254 yysize = yysize1; 1255 1256 if (yysize_overflow) 1257 return YYSIZE_MAXIMUM; 1258 1259 if (yyresult) 1260 { 1261 /* Avoid sprintf, as that infringes on the user's name space. 1262 Don't have undefined behavior even if the translation 1263 produced a string with the wrong number of "%s"s. */ 1264 char *yyp = yyresult; 1265 int yyi = 0; 1266 while ((*yyp = *yyf) != '\0') 1267 { 1268 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) 1269 { 1270 yyp += yytnamerr (yyp, yyarg[yyi++]); 1271 yyf += 2; 1272 } 1273 else 1274 { 1275 yyp++; 1276 yyf++; 1277 } 1278 } 1279 } 1280 return yysize; 1281 } 1282 } 1283 #endif /* YYERROR_VERBOSE */ 1284 1285 1286 /*-----------------------------------------------. 1287 | Release the memory associated to this symbol. | 1288 `-----------------------------------------------*/ 1289 1290 /*ARGSUSED*/ 1291 #if (defined __STDC__ || defined __C99__FUNC__ \ 1292 || defined __cplusplus || defined _MSC_VER) 1293 static void 1294 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) 1295 #else 1296 static void 1297 yydestruct (yymsg, yytype, yyvaluep) 1298 const char *yymsg; 1299 int yytype; 1300 YYSTYPE *yyvaluep; 1301 #endif 1302 { 1303 YYUSE (yyvaluep); 1304 1305 if (!yymsg) 1306 yymsg = "Deleting"; 1307 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 1308 1309 switch (yytype) 1310 { 1311 1312 default: 1313 break; 1314 } 1315 } 1316 1317 1318 /* Prevent warnings from -Wmissing-prototypes. */ 1319 1320 #ifdef YYPARSE_PARAM 1321 #if defined __STDC__ || defined __cplusplus 1322 int yyparse (void *YYPARSE_PARAM); 1323 #else 1324 int yyparse (); 1325 #endif 1326 #else /* ! YYPARSE_PARAM */ 1327 #if defined __STDC__ || defined __cplusplus 1328 int yyparse (void); 1329 #else 1330 int yyparse (); 1331 #endif 1332 #endif /* ! YYPARSE_PARAM */ 1333 1334 1335 1336 /* The look-ahead symbol. */ 1337 int yychar; 1338 1339 /* The semantic value of the look-ahead symbol. */ 1340 YYSTYPE yylval; 1341 1342 /* Number of syntax errors so far. */ 1343 int yynerrs; 1344 1345 1346 1347 /*----------. 1348 | yyparse. | 1349 `----------*/ 1350 1351 #ifdef YYPARSE_PARAM 1352 #if (defined __STDC__ || defined __C99__FUNC__ \ 1353 || defined __cplusplus || defined _MSC_VER) 1354 int 1355 yyparse (void *YYPARSE_PARAM) 1356 #else 1357 int 1358 yyparse (YYPARSE_PARAM) 1359 void *YYPARSE_PARAM; 1360 #endif 1361 #else /* ! YYPARSE_PARAM */ 1362 #if (defined __STDC__ || defined __C99__FUNC__ \ 1363 || defined __cplusplus || defined _MSC_VER) 1364 int 1365 yyparse (void) 1366 #else 1367 int 1368 yyparse () 1369 1370 #endif 1371 #endif 1372 { 1373 1374 int yystate; 1375 int yyn; 1376 int yyresult; 1377 /* Number of tokens to shift before error messages enabled. */ 1378 int yyerrstatus; 1379 /* Look-ahead token as an internal (translated) token number. */ 1380 int yytoken = 0; 1381 #if YYERROR_VERBOSE 1382 /* Buffer for error messages, and its allocated size. */ 1383 char yymsgbuf[128]; 1384 char *yymsg = yymsgbuf; 1385 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 1386 #endif 1387 1388 /* Three stacks and their tools: 1389 `yyss': related to states, 1390 `yyvs': related to semantic values, 1391 `yyls': related to locations. 1392 1393 Refer to the stacks thru separate pointers, to allow yyoverflow 1394 to reallocate them elsewhere. */ 1395 1396 /* The state stack. */ 1397 yytype_int16 yyssa[YYINITDEPTH]; 1398 yytype_int16 *yyss = yyssa; 1399 yytype_int16 *yyssp; 1400 1401 /* The semantic value stack. */ 1402 YYSTYPE yyvsa[YYINITDEPTH]; 1403 YYSTYPE *yyvs = yyvsa; 1404 YYSTYPE *yyvsp; 1405 1406 1407 1408 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 1409 1410 YYSIZE_T yystacksize = YYINITDEPTH; 1411 1412 /* The variables used to return semantic value and location from the 1413 action routines. */ 1414 YYSTYPE yyval; 1415 1416 1417 /* The number of symbols on the RHS of the reduced rule. 1418 Keep to zero when no symbol should be popped. */ 1419 int yylen = 0; 1420 1421 YYDPRINTF ((stderr, "Starting parse\n")); 1422 1423 yystate = 0; 1424 yyerrstatus = 0; 1425 yynerrs = 0; 1426 yychar = YYEMPTY; /* Cause a token to be read. */ 1427 1428 /* Initialize stack pointers. 1429 Waste one element of value and location stack 1430 so that they stay on the same level as the state stack. 1431 The wasted elements are never initialized. */ 1432 1433 yyssp = yyss; 1434 yyvsp = yyvs; 1435 1436 goto yysetstate; 1437 1438 /*------------------------------------------------------------. 1439 | yynewstate -- Push a new state, which is found in yystate. | 1440 `------------------------------------------------------------*/ 1441 yynewstate: 1442 /* In all cases, when you get here, the value and location stacks 1443 have just been pushed. So pushing a state here evens the stacks. */ 1444 yyssp++; 1445 1446 yysetstate: 1447 *yyssp = yystate; 1448 1449 if (yyss + yystacksize - 1 <= yyssp) 1450 { 1451 /* Get the current used size of the three stacks, in elements. */ 1452 YYSIZE_T yysize = yyssp - yyss + 1; 1453 1454 #ifdef yyoverflow 1455 { 1456 /* Give user a chance to reallocate the stack. Use copies of 1457 these so that the &'s don't force the real ones into 1458 memory. */ 1459 YYSTYPE *yyvs1 = yyvs; 1460 yytype_int16 *yyss1 = yyss; 1461 1462 1463 /* Each stack pointer address is followed by the size of the 1464 data in use in that stack, in bytes. This used to be a 1465 conditional around just the two extra args, but that might 1466 be undefined if yyoverflow is a macro. */ 1467 yyoverflow (YY_("memory exhausted"), 1468 &yyss1, yysize * sizeof (*yyssp), 1469 &yyvs1, yysize * sizeof (*yyvsp), 1470 1471 &yystacksize); 1472 1473 yyss = yyss1; 1474 yyvs = yyvs1; 1475 } 1476 #else /* no yyoverflow */ 1477 # ifndef YYSTACK_RELOCATE 1478 goto yyexhaustedlab; 1479 # else 1480 /* Extend the stack our own way. */ 1481 if (YYMAXDEPTH <= yystacksize) 1482 goto yyexhaustedlab; 1483 yystacksize *= 2; 1484 if (YYMAXDEPTH < yystacksize) 1485 yystacksize = YYMAXDEPTH; 1486 1487 { 1488 yytype_int16 *yyss1 = yyss; 1489 union yyalloc *yyptr = 1490 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 1491 if (! yyptr) 1492 goto yyexhaustedlab; 1493 YYSTACK_RELOCATE (yyss); 1494 YYSTACK_RELOCATE (yyvs); 1495 1496 # undef YYSTACK_RELOCATE 1497 if (yyss1 != yyssa) 1498 YYSTACK_FREE (yyss1); 1499 } 1500 # endif 1501 #endif /* no yyoverflow */ 1502 1503 yyssp = yyss + yysize - 1; 1504 yyvsp = yyvs + yysize - 1; 1505 1506 1507 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 1508 (unsigned long int) yystacksize)); 1509 1510 if (yyss + yystacksize - 1 <= yyssp) 1511 YYABORT; 1512 } 1513 1514 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 1515 1516 goto yybackup; 1517 1518 /*-----------. 1519 | yybackup. | 1520 `-----------*/ 1521 yybackup: 1522 1523 /* Do appropriate processing given the current state. Read a 1524 look-ahead token if we need one and don't already have one. */ 1525 1526 /* First try to decide what to do without reference to look-ahead token. */ 1527 yyn = yypact[yystate]; 1528 if (yyn == YYPACT_NINF) 1529 goto yydefault; 1530 1531 /* Not known => get a look-ahead token if don't already have one. */ 1532 1533 /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */ 1534 if (yychar == YYEMPTY) 1535 { 1536 YYDPRINTF ((stderr, "Reading a token: ")); 1537 yychar = YYLEX; 1538 } 1539 1540 if (yychar <= YYEOF) 1541 { 1542 yychar = yytoken = YYEOF; 1543 YYDPRINTF ((stderr, "Now at end of input.\n")); 1544 } 1545 else 1546 { 1547 yytoken = YYTRANSLATE (yychar); 1548 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 1549 } 1550 1551 /* If the proper action on seeing token YYTOKEN is to reduce or to 1552 detect an error, take that action. */ 1553 yyn += yytoken; 1554 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 1555 goto yydefault; 1556 yyn = yytable[yyn]; 1557 if (yyn <= 0) 1558 { 1559 if (yyn == 0 || yyn == YYTABLE_NINF) 1560 goto yyerrlab; 1561 yyn = -yyn; 1562 goto yyreduce; 1563 } 1564 1565 if (yyn == YYFINAL) 1566 YYACCEPT; 1567 1568 /* Count tokens shifted since error; after three, turn off error 1569 status. */ 1570 if (yyerrstatus) 1571 yyerrstatus--; 1572 1573 /* Shift the look-ahead token. */ 1574 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 1575 1576 /* Discard the shifted token unless it is eof. */ 1577 if (yychar != YYEOF) 1578 yychar = YYEMPTY; 1579 1580 yystate = yyn; 1581 *++yyvsp = yylval; 1582 1583 goto yynewstate; 1584 1585 1586 /*-----------------------------------------------------------. 1587 | yydefault -- do the default action for the current state. | 1588 `-----------------------------------------------------------*/ 1589 yydefault: 1590 yyn = yydefact[yystate]; 1591 if (yyn == 0) 1592 goto yyerrlab; 1593 goto yyreduce; 1594 1595 1596 /*-----------------------------. 1597 | yyreduce -- Do a reduction. | 1598 `-----------------------------*/ 1599 yyreduce: 1600 /* yyn is the number of a rule to reduce with. */ 1601 yylen = yyr2[yyn]; 1602 1603 /* If YYLEN is nonzero, implement the default value of the action: 1604 `$$ = $1'. 1605 1606 Otherwise, the following line sets YYVAL to garbage. 1607 This behavior is undocumented and Bison 1608 users should not rely upon it. Assigning to YYVAL 1609 unconditionally makes the parser a bit smaller, and it avoids a 1610 GCC warning that YYVAL may be used uninitialized. */ 1611 yyval = yyvsp[1-yylen]; 1612 1613 1614 YY_REDUCE_PRINT (yyn); 1615 switch (yyn) 1616 { 1617 case 4: 1618 #line 143 "deffilep.y" 1619 { def_image_name ((yyvsp[(2) - (3)].id), (yyvsp[(3) - (3)].vma), 0); } 1620 break; 1621 1622 case 5: 1623 #line 144 "deffilep.y" 1624 { def_image_name ((yyvsp[(2) - (3)].id), (yyvsp[(3) - (3)].vma), 1); } 1625 break; 1626 1627 case 6: 1628 #line 145 "deffilep.y" 1629 { def_description ((yyvsp[(2) - (2)].id));} 1630 break; 1631 1632 case 7: 1633 #line 146 "deffilep.y" 1634 { def_stacksize ((yyvsp[(2) - (3)].number), (yyvsp[(3) - (3)].number));} 1635 break; 1636 1637 case 8: 1638 #line 147 "deffilep.y" 1639 { def_heapsize ((yyvsp[(2) - (3)].number), (yyvsp[(3) - (3)].number));} 1640 break; 1641 1642 case 9: 1643 #line 148 "deffilep.y" 1644 { def_section ("CODE", (yyvsp[(2) - (2)].number));} 1645 break; 1646 1647 case 10: 1648 #line 149 "deffilep.y" 1649 { def_section ("DATA", (yyvsp[(2) - (2)].number));} 1650 break; 1651 1652 case 14: 1653 #line 153 "deffilep.y" 1654 { def_version ((yyvsp[(2) - (2)].number), 0);} 1655 break; 1656 1657 case 15: 1658 #line 154 "deffilep.y" 1659 { def_version ((yyvsp[(2) - (4)].number), (yyvsp[(4) - (4)].number));} 1660 break; 1661 1662 case 16: 1663 #line 155 "deffilep.y" 1664 { def_directive ((yyvsp[(2) - (2)].id));} 1665 break; 1666 1667 case 17: 1668 #line 156 "deffilep.y" 1669 { def_aligncomm ((yyvsp[(2) - (4)].id), (yyvsp[(4) - (4)].number));} 1670 break; 1671 1672 case 21: 1673 #line 171 "deffilep.y" 1674 { def_exports ((yyvsp[(1) - (7)].id), (yyvsp[(2) - (7)].id), (yyvsp[(3) - (7)].number), (yyvsp[(5) - (7)].number), (yyvsp[(7) - (7)].id)); } 1675 break; 1676 1677 case 22: 1678 #line 177 "deffilep.y" 1679 { (yyval.number) = (yyvsp[(1) - (3)].number) | (yyvsp[(3) - (3)].number); } 1680 break; 1681 1682 case 23: 1683 #line 178 "deffilep.y" 1684 { (yyval.number) = 0; } 1685 break; 1686 1687 case 24: 1688 #line 181 "deffilep.y" 1689 { (yyval.number) = 1; } 1690 break; 1691 1692 case 25: 1693 #line 182 "deffilep.y" 1694 { (yyval.number) = 1; } 1695 break; 1696 1697 case 26: 1698 #line 183 "deffilep.y" 1699 { (yyval.number) = 2; } 1700 break; 1701 1702 case 27: 1703 #line 184 "deffilep.y" 1704 { (yyval.number) = 2; } 1705 break; 1706 1707 case 28: 1708 #line 185 "deffilep.y" 1709 { (yyval.number) = 4; } 1710 break; 1711 1712 case 29: 1713 #line 186 "deffilep.y" 1714 { (yyval.number) = 4; } 1715 break; 1716 1717 case 30: 1718 #line 187 "deffilep.y" 1719 { (yyval.number) = 8; } 1720 break; 1721 1722 case 31: 1723 #line 188 "deffilep.y" 1724 { (yyval.number) = 8; } 1725 break; 1726 1727 case 34: 1728 #line 197 "deffilep.y" 1729 { def_import ((yyvsp[(1) - (8)].id), (yyvsp[(3) - (8)].id), (yyvsp[(5) - (8)].id), (yyvsp[(7) - (8)].id), -1, (yyvsp[(8) - (8)].id)); } 1730 break; 1731 1732 case 35: 1733 #line 199 "deffilep.y" 1734 { def_import ((yyvsp[(1) - (8)].id), (yyvsp[(3) - (8)].id), (yyvsp[(5) - (8)].id), 0, (yyvsp[(7) - (8)].number), (yyvsp[(8) - (8)].id)); } 1735 break; 1736 1737 case 36: 1738 #line 201 "deffilep.y" 1739 { def_import ((yyvsp[(1) - (6)].id), (yyvsp[(3) - (6)].id), 0, (yyvsp[(5) - (6)].id), -1, (yyvsp[(6) - (6)].id)); } 1740 break; 1741 1742 case 37: 1743 #line 203 "deffilep.y" 1744 { def_import ((yyvsp[(1) - (6)].id), (yyvsp[(3) - (6)].id), 0, 0, (yyvsp[(5) - (6)].number), (yyvsp[(6) - (6)].id)); } 1745 break; 1746 1747 case 38: 1748 #line 205 "deffilep.y" 1749 { def_import( 0, (yyvsp[(1) - (6)].id), (yyvsp[(3) - (6)].id), (yyvsp[(5) - (6)].id), -1, (yyvsp[(6) - (6)].id)); } 1750 break; 1751 1752 case 39: 1753 #line 207 "deffilep.y" 1754 { def_import ( 0, (yyvsp[(1) - (4)].id), 0, (yyvsp[(3) - (4)].id), -1, (yyvsp[(4) - (4)].id)); } 1755 break; 1756 1757 case 42: 1758 #line 216 "deffilep.y" 1759 { def_section ((yyvsp[(1) - (2)].id), (yyvsp[(2) - (2)].number));} 1760 break; 1761 1762 case 43: 1763 #line 217 "deffilep.y" 1764 { def_section_alt ((yyvsp[(1) - (2)].id), (yyvsp[(2) - (2)].id));} 1765 break; 1766 1767 case 44: 1768 #line 221 "deffilep.y" 1769 { (yyval.number) = (yyvsp[(1) - (3)].number) | (yyvsp[(3) - (3)].number); } 1770 break; 1771 1772 case 45: 1773 #line 222 "deffilep.y" 1774 { (yyval.number) = (yyvsp[(1) - (1)].number); } 1775 break; 1776 1777 case 48: 1778 #line 229 "deffilep.y" 1779 { (yyval.number)=(yyvsp[(2) - (2)].number);} 1780 break; 1781 1782 case 49: 1783 #line 230 "deffilep.y" 1784 { (yyval.number)=-1;} 1785 break; 1786 1787 case 50: 1788 #line 234 "deffilep.y" 1789 { (yyval.number) = 1;} 1790 break; 1791 1792 case 51: 1793 #line 235 "deffilep.y" 1794 { (yyval.number) = 2;} 1795 break; 1796 1797 case 52: 1798 #line 236 "deffilep.y" 1799 { (yyval.number)=4;} 1800 break; 1801 1802 case 53: 1803 #line 237 "deffilep.y" 1804 { (yyval.number)=8;} 1805 break; 1806 1807 case 54: 1808 #line 241 "deffilep.y" 1809 { (yyval.id_const) = "BASE"; } 1810 break; 1811 1812 case 55: 1813 #line 242 "deffilep.y" 1814 { (yyval.id_const) = "CODE"; } 1815 break; 1816 1817 case 56: 1818 #line 243 "deffilep.y" 1819 { (yyval.id_const) = "CONSTANT"; } 1820 break; 1821 1822 case 57: 1823 #line 244 "deffilep.y" 1824 { (yyval.id_const) = "constant"; } 1825 break; 1826 1827 case 58: 1828 #line 245 "deffilep.y" 1829 { (yyval.id_const) = "DATA"; } 1830 break; 1831 1832 case 59: 1833 #line 246 "deffilep.y" 1834 { (yyval.id_const) = "data"; } 1835 break; 1836 1837 case 60: 1838 #line 247 "deffilep.y" 1839 { (yyval.id_const) = "DESCRIPTION"; } 1840 break; 1841 1842 case 61: 1843 #line 248 "deffilep.y" 1844 { (yyval.id_const) = "DIRECTIVE"; } 1845 break; 1846 1847 case 62: 1848 #line 249 "deffilep.y" 1849 { (yyval.id_const) = "EXECUTE"; } 1850 break; 1851 1852 case 63: 1853 #line 250 "deffilep.y" 1854 { (yyval.id_const) = "EXPORTS"; } 1855 break; 1856 1857 case 64: 1858 #line 251 "deffilep.y" 1859 { (yyval.id_const) = "HEAPSIZE"; } 1860 break; 1861 1862 case 65: 1863 #line 252 "deffilep.y" 1864 { (yyval.id_const) = "IMPORTS"; } 1865 break; 1866 1867 case 66: 1868 #line 259 "deffilep.y" 1869 { (yyval.id_const) = "NAME"; } 1870 break; 1871 1872 case 67: 1873 #line 260 "deffilep.y" 1874 { (yyval.id_const) = "NONAME"; } 1875 break; 1876 1877 case 68: 1878 #line 261 "deffilep.y" 1879 { (yyval.id_const) = "noname"; } 1880 break; 1881 1882 case 69: 1883 #line 262 "deffilep.y" 1884 { (yyval.id_const) = "PRIVATE"; } 1885 break; 1886 1887 case 70: 1888 #line 263 "deffilep.y" 1889 { (yyval.id_const) = "private"; } 1890 break; 1891 1892 case 71: 1893 #line 264 "deffilep.y" 1894 { (yyval.id_const) = "READ"; } 1895 break; 1896 1897 case 72: 1898 #line 265 "deffilep.y" 1899 { (yyval.id_const) = "SHARED"; } 1900 break; 1901 1902 case 73: 1903 #line 266 "deffilep.y" 1904 { (yyval.id_const) = "STACKSIZE"; } 1905 break; 1906 1907 case 74: 1908 #line 267 "deffilep.y" 1909 { (yyval.id_const) = "VERSION"; } 1910 break; 1911 1912 case 75: 1913 #line 268 "deffilep.y" 1914 { (yyval.id_const) = "WRITE"; } 1915 break; 1916 1917 case 76: 1918 #line 271 "deffilep.y" 1919 { (yyval.id) = (yyvsp[(1) - (1)].id); } 1920 break; 1921 1922 case 77: 1923 #line 273 "deffilep.y" 1924 { 1925 char *name = xmalloc (strlen ((yyvsp[(2) - (2)].id_const)) + 2); 1926 sprintf (name, ".%s", (yyvsp[(2) - (2)].id_const)); 1927 (yyval.id) = name; 1928 } 1929 break; 1930 1931 case 78: 1932 #line 279 "deffilep.y" 1933 { 1934 char *name = def_pool_alloc (strlen ((yyvsp[(2) - (2)].id)) + 2); 1935 sprintf (name, ".%s", (yyvsp[(2) - (2)].id)); 1936 (yyval.id) = name; 1937 } 1938 break; 1939 1940 case 79: 1941 #line 285 "deffilep.y" 1942 { 1943 char *name = def_pool_alloc (strlen ((yyvsp[(1) - (3)].id_const)) + 1 + strlen ((yyvsp[(3) - (3)].id)) + 1); 1944 sprintf (name, "%s.%s", (yyvsp[(1) - (3)].id_const), (yyvsp[(3) - (3)].id)); 1945 (yyval.id) = name; 1946 } 1947 break; 1948 1949 case 80: 1950 #line 291 "deffilep.y" 1951 { 1952 char *name = def_pool_alloc (strlen ((yyvsp[(1) - (3)].id)) + 1 + strlen ((yyvsp[(3) - (3)].id)) + 1); 1953 sprintf (name, "%s.%s", (yyvsp[(1) - (3)].id), (yyvsp[(3) - (3)].id)); 1954 (yyval.id) = name; 1955 } 1956 break; 1957 1958 case 81: 1959 #line 298 "deffilep.y" 1960 { (yyval.id) = (yyvsp[(1) - (1)].id); } 1961 break; 1962 1963 case 82: 1964 #line 299 "deffilep.y" 1965 { (yyval.id) = ""; } 1966 break; 1967 1968 case 83: 1969 #line 302 "deffilep.y" 1970 { (yyval.id) = (yyvsp[(2) - (2)].id); } 1971 break; 1972 1973 case 84: 1974 #line 303 "deffilep.y" 1975 { (yyval.id) = 0; } 1976 break; 1977 1978 case 85: 1979 #line 307 "deffilep.y" 1980 { (yyval.number) = (yyvsp[(2) - (2)].number);} 1981 break; 1982 1983 case 86: 1984 #line 308 "deffilep.y" 1985 { (yyval.number) = -1;} 1986 break; 1987 1988 case 87: 1989 #line 312 "deffilep.y" 1990 { (yyval.id) = (yyvsp[(2) - (2)].id); } 1991 break; 1992 1993 case 88: 1994 #line 313 "deffilep.y" 1995 { (yyval.id) = 0; } 1996 break; 1997 1998 case 89: 1999 #line 316 "deffilep.y" 2000 { (yyval.vma) = (yyvsp[(3) - (3)].vma);} 2001 break; 2002 2003 case 90: 2004 #line 317 "deffilep.y" 2005 { (yyval.vma) = (bfd_vma) -1;} 2006 break; 2007 2008 case 91: 2009 #line 320 "deffilep.y" 2010 { (yyval.id) = (yyvsp[(1) - (1)].id); } 2011 break; 2012 2013 case 92: 2014 #line 322 "deffilep.y" 2015 { 2016 char *id = def_pool_alloc (strlen ((yyvsp[(2) - (2)].id)) + 2); 2017 sprintf (id, ".%s", (yyvsp[(2) - (2)].id)); 2018 (yyval.id) = id; 2019 } 2020 break; 2021 2022 case 93: 2023 #line 328 "deffilep.y" 2024 { 2025 char *id = def_pool_alloc (strlen ((yyvsp[(1) - (4)].id)) + 1 + strlen ((yyvsp[(3) - (4)].digits)) + strlen ((yyvsp[(4) - (4)].id)) + 1); 2026 sprintf (id, "%s.%s%s", (yyvsp[(1) - (4)].id), (yyvsp[(3) - (4)].digits), (yyvsp[(4) - (4)].id)); 2027 (yyval.id) = id; 2028 } 2029 break; 2030 2031 case 94: 2032 #line 335 "deffilep.y" 2033 { (yyval.digits) = (yyvsp[(1) - (1)].digits); } 2034 break; 2035 2036 case 95: 2037 #line 336 "deffilep.y" 2038 { (yyval.digits) = ""; } 2039 break; 2040 2041 case 96: 2042 #line 339 "deffilep.y" 2043 { (yyval.id) = (yyvsp[(1) - (1)].id); } 2044 break; 2045 2046 case 97: 2047 #line 340 "deffilep.y" 2048 { (yyval.id) = ""; } 2049 break; 2050 2051 case 98: 2052 #line 343 "deffilep.y" 2053 { (yyval.number) = strtoul ((yyvsp[(1) - (1)].digits), 0, 0); } 2054 break; 2055 2056 case 99: 2057 #line 345 "deffilep.y" 2058 { (yyval.vma) = (bfd_vma) strtoull ((yyvsp[(1) - (1)].digits), 0, 0); } 2059 break; 2060 2061 2062 /* Line 1267 of yacc.c. */ 2063 #line 2064 "deffilep.c" 2064 default: break; 2065 } 2066 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 2067 2068 YYPOPSTACK (yylen); 2069 yylen = 0; 2070 YY_STACK_PRINT (yyss, yyssp); 2071 2072 *++yyvsp = yyval; 2073 2074 2075 /* Now `shift' the result of the reduction. Determine what state 2076 that goes to, based on the state we popped back to and the rule 2077 number reduced by. */ 2078 2079 yyn = yyr1[yyn]; 2080 2081 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 2082 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 2083 yystate = yytable[yystate]; 2084 else 2085 yystate = yydefgoto[yyn - YYNTOKENS]; 2086 2087 goto yynewstate; 2088 2089 2090 /*------------------------------------. 2091 | yyerrlab -- here on detecting error | 2092 `------------------------------------*/ 2093 yyerrlab: 2094 /* If not already recovering from an error, report this error. */ 2095 if (!yyerrstatus) 2096 { 2097 ++yynerrs; 2098 #if ! YYERROR_VERBOSE 2099 yyerror (YY_("syntax error")); 2100 #else 2101 { 2102 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); 2103 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) 2104 { 2105 YYSIZE_T yyalloc = 2 * yysize; 2106 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) 2107 yyalloc = YYSTACK_ALLOC_MAXIMUM; 2108 if (yymsg != yymsgbuf) 2109 YYSTACK_FREE (yymsg); 2110 yymsg = (char *) YYSTACK_ALLOC (yyalloc); 2111 if (yymsg) 2112 yymsg_alloc = yyalloc; 2113 else 2114 { 2115 yymsg = yymsgbuf; 2116 yymsg_alloc = sizeof yymsgbuf; 2117 } 2118 } 2119 2120 if (0 < yysize && yysize <= yymsg_alloc) 2121 { 2122 (void) yysyntax_error (yymsg, yystate, yychar); 2123 yyerror (yymsg); 2124 } 2125 else 2126 { 2127 yyerror (YY_("syntax error")); 2128 if (yysize != 0) 2129 goto yyexhaustedlab; 2130 } 2131 } 2132 #endif 2133 } 2134 2135 2136 2137 if (yyerrstatus == 3) 2138 { 2139 /* If just tried and failed to reuse look-ahead token after an 2140 error, discard it. */ 2141 2142 if (yychar <= YYEOF) 2143 { 2144 /* Return failure if at end of input. */ 2145 if (yychar == YYEOF) 2146 YYABORT; 2147 } 2148 else 2149 { 2150 yydestruct ("Error: discarding", 2151 yytoken, &yylval); 2152 yychar = YYEMPTY; 2153 } 2154 } 2155 2156 /* Else will try to reuse look-ahead token after shifting the error 2157 token. */ 2158 goto yyerrlab1; 2159 2160 2161 /*---------------------------------------------------. 2162 | yyerrorlab -- error raised explicitly by YYERROR. | 2163 `---------------------------------------------------*/ 2164 yyerrorlab: 2165 2166 /* Pacify compilers like GCC when the user code never invokes 2167 YYERROR and the label yyerrorlab therefore never appears in user 2168 code. */ 2169 if (/*CONSTCOND*/ 0) 2170 goto yyerrorlab; 2171 2172 /* Do not reclaim the symbols of the rule which action triggered 2173 this YYERROR. */ 2174 YYPOPSTACK (yylen); 2175 yylen = 0; 2176 YY_STACK_PRINT (yyss, yyssp); 2177 yystate = *yyssp; 2178 goto yyerrlab1; 2179 2180 2181 /*-------------------------------------------------------------. 2182 | yyerrlab1 -- common code for both syntax error and YYERROR. | 2183 `-------------------------------------------------------------*/ 2184 yyerrlab1: 2185 yyerrstatus = 3; /* Each real token shifted decrements this. */ 2186 2187 for (;;) 2188 { 2189 yyn = yypact[yystate]; 2190 if (yyn != YYPACT_NINF) 2191 { 2192 yyn += YYTERROR; 2193 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 2194 { 2195 yyn = yytable[yyn]; 2196 if (0 < yyn) 2197 break; 2198 } 2199 } 2200 2201 /* Pop the current state because it cannot handle the error token. */ 2202 if (yyssp == yyss) 2203 YYABORT; 2204 2205 2206 yydestruct ("Error: popping", 2207 yystos[yystate], yyvsp); 2208 YYPOPSTACK (1); 2209 yystate = *yyssp; 2210 YY_STACK_PRINT (yyss, yyssp); 2211 } 2212 2213 if (yyn == YYFINAL) 2214 YYACCEPT; 2215 2216 *++yyvsp = yylval; 2217 2218 2219 /* Shift the error token. */ 2220 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 2221 2222 yystate = yyn; 2223 goto yynewstate; 2224 2225 2226 /*-------------------------------------. 2227 | yyacceptlab -- YYACCEPT comes here. | 2228 `-------------------------------------*/ 2229 yyacceptlab: 2230 yyresult = 0; 2231 goto yyreturn; 2232 2233 /*-----------------------------------. 2234 | yyabortlab -- YYABORT comes here. | 2235 `-----------------------------------*/ 2236 yyabortlab: 2237 yyresult = 1; 2238 goto yyreturn; 2239 2240 #ifndef yyoverflow 2241 /*-------------------------------------------------. 2242 | yyexhaustedlab -- memory exhaustion comes here. | 2243 `-------------------------------------------------*/ 2244 yyexhaustedlab: 2245 yyerror (YY_("memory exhausted")); 2246 yyresult = 2; 2247 /* Fall through. */ 2248 #endif 2249 2250 yyreturn: 2251 if (yychar != YYEOF && yychar != YYEMPTY) 2252 yydestruct ("Cleanup: discarding lookahead", 2253 yytoken, &yylval); 2254 /* Do not reclaim the symbols of the rule which action triggered 2255 this YYABORT or YYACCEPT. */ 2256 YYPOPSTACK (yylen); 2257 YY_STACK_PRINT (yyss, yyssp); 2258 while (yyssp != yyss) 2259 { 2260 yydestruct ("Cleanup: popping", 2261 yystos[*yyssp], yyvsp); 2262 YYPOPSTACK (1); 2263 } 2264 #ifndef yyoverflow 2265 if (yyss != yyssa) 2266 YYSTACK_FREE (yyss); 2267 #endif 2268 #if YYERROR_VERBOSE 2269 if (yymsg != yymsgbuf) 2270 YYSTACK_FREE (yymsg); 2271 #endif 2272 /* Make sure YYID is used. */ 2273 return YYID (yyresult); 2274 } 2275 2276 2277 #line 347 "deffilep.y" 2278 2279 2280 /***************************************************************************** 2281 API 2282 *****************************************************************************/ 2283 2284 static FILE *the_file; 2285 static const char *def_filename; 2286 static int linenumber; 2287 static def_file *def; 2288 static int saw_newline; 2289 2290 struct directive 2291 { 2292 struct directive *next; 2293 char *name; 2294 int len; 2295 }; 2296 2297 static struct directive *directives = 0; 2298 2299 def_file * 2300 def_file_empty (void) 2301 { 2302 def_file *rv = xmalloc (sizeof (def_file)); 2303 memset (rv, 0, sizeof (def_file)); 2304 rv->is_dll = -1; 2305 rv->base_address = (bfd_vma) -1; 2306 rv->stack_reserve = rv->stack_commit = -1; 2307 rv->heap_reserve = rv->heap_commit = -1; 2308 rv->version_major = rv->version_minor = -1; 2309 return rv; 2310 } 2311 2312 def_file * 2313 def_file_parse (const char *filename, def_file *add_to) 2314 { 2315 struct directive *d; 2316 2317 the_file = fopen (filename, "r"); 2318 def_filename = filename; 2319 linenumber = 1; 2320 if (!the_file) 2321 { 2322 perror (filename); 2323 return 0; 2324 } 2325 if (add_to) 2326 { 2327 def = add_to; 2328 } 2329 else 2330 { 2331 def = def_file_empty (); 2332 } 2333 2334 saw_newline = 1; 2335 if (def_parse ()) 2336 { 2337 def_file_free (def); 2338 fclose (the_file); 2339 def_pool_free (); 2340 return 0; 2341 } 2342 2343 fclose (the_file); 2344 2345 while ((d = directives) != NULL) 2346 { 2347 #if TRACE 2348 printf ("Adding directive %08x `%s'\n", d->name, d->name); 2349 #endif 2350 def_file_add_directive (def, d->name, d->len); 2351 directives = d->next; 2352 free (d->name); 2353 free (d); 2354 } 2355 def_pool_free (); 2356 2357 return def; 2358 } 2359 2360 void 2361 def_file_free (def_file *fdef) 2362 { 2363 int i; 2364 2365 if (!fdef) 2366 return; 2367 if (fdef->name) 2368 free (fdef->name); 2369 if (fdef->description) 2370 free (fdef->description); 2371 2372 if (fdef->section_defs) 2373 { 2374 for (i = 0; i < fdef->num_section_defs; i++) 2375 { 2376 if (fdef->section_defs[i].name) 2377 free (fdef->section_defs[i].name); 2378 if (fdef->section_defs[i].class) 2379 free (fdef->section_defs[i].class); 2380 } 2381 free (fdef->section_defs); 2382 } 2383 2384 if (fdef->exports) 2385 { 2386 for (i = 0; i < fdef->num_exports; i++) 2387 { 2388 if (fdef->exports[i].internal_name 2389 && fdef->exports[i].internal_name != fdef->exports[i].name) 2390 free (fdef->exports[i].internal_name); 2391 if (fdef->exports[i].name) 2392 free (fdef->exports[i].name); 2393 if (fdef->exports[i].its_name) 2394 free (fdef->exports[i].its_name); 2395 } 2396 free (fdef->exports); 2397 } 2398 2399 if (fdef->imports) 2400 { 2401 for (i = 0; i < fdef->num_imports; i++) 2402 { 2403 if (fdef->imports[i].internal_name 2404 && fdef->imports[i].internal_name != fdef->imports[i].name) 2405 free (fdef->imports[i].internal_name); 2406 if (fdef->imports[i].name) 2407 free (fdef->imports[i].name); 2408 if (fdef->imports[i].its_name) 2409 free (fdef->imports[i].its_name); 2410 } 2411 free (fdef->imports); 2412 } 2413 2414 while (fdef->modules) 2415 { 2416 def_file_module *m = fdef->modules; 2417 2418 fdef->modules = fdef->modules->next; 2419 free (m); 2420 } 2421 2422 while (fdef->aligncomms) 2423 { 2424 def_file_aligncomm *c = fdef->aligncomms; 2425 2426 fdef->aligncomms = fdef->aligncomms->next; 2427 free (c->symbol_name); 2428 free (c); 2429 } 2430 2431 free (fdef); 2432 } 2433 2434 #ifdef DEF_FILE_PRINT 2435 void 2436 def_file_print (FILE *file, def_file *fdef) 2437 { 2438 int i; 2439 2440 fprintf (file, ">>>> def_file at 0x%08x\n", fdef); 2441 if (fdef->name) 2442 fprintf (file, " name: %s\n", fdef->name ? fdef->name : "(unspecified)"); 2443 if (fdef->is_dll != -1) 2444 fprintf (file, " is dll: %s\n", fdef->is_dll ? "yes" : "no"); 2445 if (fdef->base_address != (bfd_vma) -1) 2446 { 2447 fprintf (file, " base address: 0x"); 2448 fprintf_vma (file, fdef->base_address); 2449 fprintf (file, "\n"); 2450 } 2451 if (fdef->description) 2452 fprintf (file, " description: `%s'\n", fdef->description); 2453 if (fdef->stack_reserve != -1) 2454 fprintf (file, " stack reserve: 0x%08x\n", fdef->stack_reserve); 2455 if (fdef->stack_commit != -1) 2456 fprintf (file, " stack commit: 0x%08x\n", fdef->stack_commit); 2457 if (fdef->heap_reserve != -1) 2458 fprintf (file, " heap reserve: 0x%08x\n", fdef->heap_reserve); 2459 if (fdef->heap_commit != -1) 2460 fprintf (file, " heap commit: 0x%08x\n", fdef->heap_commit); 2461 2462 if (fdef->num_section_defs > 0) 2463 { 2464 fprintf (file, " section defs:\n"); 2465 2466 for (i = 0; i < fdef->num_section_defs; i++) 2467 { 2468 fprintf (file, " name: `%s', class: `%s', flags:", 2469 fdef->section_defs[i].name, fdef->section_defs[i].class); 2470 if (fdef->section_defs[i].flag_read) 2471 fprintf (file, " R"); 2472 if (fdef->section_defs[i].flag_write) 2473 fprintf (file, " W"); 2474 if (fdef->section_defs[i].flag_execute) 2475 fprintf (file, " X"); 2476 if (fdef->section_defs[i].flag_shared) 2477 fprintf (file, " S"); 2478 fprintf (file, "\n"); 2479 } 2480 } 2481 2482 if (fdef->num_exports > 0) 2483 { 2484 fprintf (file, " exports:\n"); 2485 2486 for (i = 0; i < fdef->num_exports; i++) 2487 { 2488 fprintf (file, " name: `%s', int: `%s', ordinal: %d, flags:", 2489 fdef->exports[i].name, fdef->exports[i].internal_name, 2490 fdef->exports[i].ordinal); 2491 if (fdef->exports[i].flag_private) 2492 fprintf (file, " P"); 2493 if (fdef->exports[i].flag_constant) 2494 fprintf (file, " C"); 2495 if (fdef->exports[i].flag_noname) 2496 fprintf (file, " N"); 2497 if (fdef->exports[i].flag_data) 2498 fprintf (file, " D"); 2499 fprintf (file, "\n"); 2500 } 2501 } 2502 2503 if (fdef->num_imports > 0) 2504 { 2505 fprintf (file, " imports:\n"); 2506 2507 for (i = 0; i < fdef->num_imports; i++) 2508 { 2509 fprintf (file, " int: %s, from: `%s', name: `%s', ordinal: %d\n", 2510 fdef->imports[i].internal_name, 2511 fdef->imports[i].module, 2512 fdef->imports[i].name, 2513 fdef->imports[i].ordinal); 2514 } 2515 } 2516 2517 if (fdef->version_major != -1) 2518 fprintf (file, " version: %d.%d\n", fdef->version_major, fdef->version_minor); 2519 2520 fprintf (file, "<<<< def_file at 0x%08x\n", fdef); 2521 } 2522 #endif 2523 2524 /* Helper routine to check for identity of string pointers, 2525 which might be NULL. */ 2526 2527 static int 2528 are_names_equal (const char *s1, const char *s2) 2529 { 2530 if (!s1 && !s2) 2531 return 0; 2532 if (!s1 || !s2) 2533 return (!s1 ? -1 : 1); 2534 return strcmp (s1, s2); 2535 } 2536 2537 static int 2538 cmp_export_elem (const def_file_export *e, const char *ex_name, 2539 const char *in_name, const char *its_name, 2540 int ord) 2541 { 2542 int r; 2543 2544 if ((r = are_names_equal (ex_name, e->name)) != 0) 2545 return r; 2546 if ((r = are_names_equal (in_name, e->internal_name)) != 0) 2547 return r; 2548 if ((r = are_names_equal (its_name, e->its_name)) != 0) 2549 return r; 2550 return (ord - e->ordinal); 2551 } 2552 2553 /* Search the position of the identical element, or returns the position 2554 of the next higher element. If last valid element is smaller, then MAX 2555 is returned. */ 2556 2557 static int 2558 find_export_in_list (def_file_export *b, int max, 2559 const char *ex_name, const char *in_name, 2560 const char *its_name, int ord, int *is_ident) 2561 { 2562 int e, l, r, p; 2563 2564 *is_ident = 0; 2565 if (!max) 2566 return 0; 2567 if ((e = cmp_export_elem (b, ex_name, in_name, its_name, ord)) <= 0) 2568 { 2569 if (!e) 2570 *is_ident = 1; 2571 return 0; 2572 } 2573 if (max == 1) 2574 return 1; 2575 if ((e = cmp_export_elem (b + (max - 1), ex_name, in_name, its_name, ord)) > 0) 2576 return max; 2577 else if (!e || max == 2) 2578 { 2579 if (!e) 2580 *is_ident = 1; 2581 return max - 1; 2582 } 2583 l = 0; r = max - 1; 2584 while (l < r) 2585 { 2586 p = (l + r) / 2; 2587 e = cmp_export_elem (b + p, ex_name, in_name, its_name, ord); 2588 if (!e) 2589 { 2590 *is_ident = 1; 2591 return p; 2592 } 2593 else if (e < 0) 2594 r = p - 1; 2595 else if (e > 0) 2596 l = p + 1; 2597 } 2598 if ((e = cmp_export_elem (b + l, ex_name, in_name, its_name, ord)) > 0) 2599 ++l; 2600 else if (!e) 2601 *is_ident = 1; 2602 return l; 2603 } 2604 2605 def_file_export * 2606 def_file_add_export (def_file *fdef, 2607 const char *external_name, 2608 const char *internal_name, 2609 int ordinal, 2610 const char *its_name, 2611 int *is_dup) 2612 { 2613 def_file_export *e; 2614 int pos; 2615 int max_exports = ROUND_UP(fdef->num_exports, 32); 2616 2617 if (internal_name && !external_name) 2618 external_name = internal_name; 2619 if (external_name && !internal_name) 2620 internal_name = external_name; 2621 2622 /* We need to avoid duplicates. */ 2623 *is_dup = 0; 2624 pos = find_export_in_list (fdef->exports, fdef->num_exports, 2625 external_name, internal_name, 2626 its_name, ordinal, is_dup); 2627 2628 if (*is_dup != 0) 2629 return (fdef->exports + pos); 2630 2631 if (fdef->num_exports >= max_exports) 2632 { 2633 max_exports = ROUND_UP(fdef->num_exports + 1, 32); 2634 if (fdef->exports) 2635 fdef->exports = xrealloc (fdef->exports, 2636 max_exports * sizeof (def_file_export)); 2637 else 2638 fdef->exports = xmalloc (max_exports * sizeof (def_file_export)); 2639 } 2640 2641 e = fdef->exports + pos; 2642 if (pos != fdef->num_exports) 2643 memmove (&e[1], e, (sizeof (def_file_export) * (fdef->num_exports - pos))); 2644 memset (e, 0, sizeof (def_file_export)); 2645 e->name = xstrdup (external_name); 2646 e->internal_name = xstrdup (internal_name); 2647 e->its_name = (its_name ? xstrdup (its_name) : NULL); 2648 e->ordinal = ordinal; 2649 fdef->num_exports++; 2650 return e; 2651 } 2652 2653 def_file_module * 2654 def_get_module (def_file *fdef, const char *name) 2655 { 2656 def_file_module *s; 2657 2658 for (s = fdef->modules; s; s = s->next) 2659 if (strcmp (s->name, name) == 0) 2660 return s; 2661 2662 return NULL; 2663 } 2664 2665 static def_file_module * 2666 def_stash_module (def_file *fdef, const char *name) 2667 { 2668 def_file_module *s; 2669 2670 if ((s = def_get_module (fdef, name)) != NULL) 2671 return s; 2672 s = xmalloc (sizeof (def_file_module) + strlen (name)); 2673 s->next = fdef->modules; 2674 fdef->modules = s; 2675 s->user_data = 0; 2676 strcpy (s->name, name); 2677 return s; 2678 } 2679 2680 static int 2681 cmp_import_elem (const def_file_import *e, const char *ex_name, 2682 const char *in_name, const char *module, 2683 int ord) 2684 { 2685 int r; 2686 2687 if ((r = are_names_equal (module, (e->module ? e->module->name : NULL)))) 2688 return r; 2689 if ((r = are_names_equal (ex_name, e->name)) != 0) 2690 return r; 2691 if ((r = are_names_equal (in_name, e->internal_name)) != 0) 2692 return r; 2693 if (ord != e->ordinal) 2694 return (ord < e->ordinal ? -1 : 1); 2695 return 0; 2696 } 2697 2698 /* Search the position of the identical element, or returns the position 2699 of the next higher element. If last valid element is smaller, then MAX 2700 is returned. */ 2701 2702 static int 2703 find_import_in_list (def_file_import *b, int max, 2704 const char *ex_name, const char *in_name, 2705 const char *module, int ord, int *is_ident) 2706 { 2707 int e, l, r, p; 2708 2709 *is_ident = 0; 2710 if (!max) 2711 return 0; 2712 if ((e = cmp_import_elem (b, ex_name, in_name, module, ord)) <= 0) 2713 { 2714 if (!e) 2715 *is_ident = 1; 2716 return 0; 2717 } 2718 if (max == 1) 2719 return 1; 2720 if ((e = cmp_import_elem (b + (max - 1), ex_name, in_name, module, ord)) > 0) 2721 return max; 2722 else if (!e || max == 2) 2723 { 2724 if (!e) 2725 *is_ident = 1; 2726 return max - 1; 2727 } 2728 l = 0; r = max - 1; 2729 while (l < r) 2730 { 2731 p = (l + r) / 2; 2732 e = cmp_import_elem (b + p, ex_name, in_name, module, ord); 2733 if (!e) 2734 { 2735 *is_ident = 1; 2736 return p; 2737 } 2738 else if (e < 0) 2739 r = p - 1; 2740 else if (e > 0) 2741 l = p + 1; 2742 } 2743 if ((e = cmp_import_elem (b + l, ex_name, in_name, module, ord)) > 0) 2744 ++l; 2745 else if (!e) 2746 *is_ident = 1; 2747 return l; 2748 } 2749 2750 def_file_import * 2751 def_file_add_import (def_file *fdef, 2752 const char *name, 2753 const char *module, 2754 int ordinal, 2755 const char *internal_name, 2756 const char *its_name, 2757 int *is_dup) 2758 { 2759 def_file_import *i; 2760 int pos; 2761 int max_imports = ROUND_UP (fdef->num_imports, 16); 2762 2763 /* We need to avoid here duplicates. */ 2764 *is_dup = 0; 2765 pos = find_import_in_list (fdef->imports, fdef->num_imports, 2766 name, 2767 (!internal_name ? name : internal_name), 2768 module, ordinal, is_dup); 2769 if (*is_dup != 0) 2770 return fdef->imports + pos; 2771 2772 if (fdef->num_imports >= max_imports) 2773 { 2774 max_imports = ROUND_UP (fdef->num_imports+1, 16); 2775 2776 if (fdef->imports) 2777 fdef->imports = xrealloc (fdef->imports, 2778 max_imports * sizeof (def_file_import)); 2779 else 2780 fdef->imports = xmalloc (max_imports * sizeof (def_file_import)); 2781 } 2782 i = fdef->imports + pos; 2783 if (pos != fdef->num_imports) 2784 memmove (&i[1], i, (sizeof (def_file_import) * (fdef->num_imports - pos))); 2785 memset (i, 0, sizeof (def_file_import)); 2786 if (name) 2787 i->name = xstrdup (name); 2788 if (module) 2789 i->module = def_stash_module (fdef, module); 2790 i->ordinal = ordinal; 2791 if (internal_name) 2792 i->internal_name = xstrdup (internal_name); 2793 else 2794 i->internal_name = i->name; 2795 i->its_name = (its_name ? xstrdup (its_name) : NULL); 2796 fdef->num_imports++; 2797 2798 return i; 2799 } 2800 2801 struct 2802 { 2803 char *param; 2804 int token; 2805 } 2806 diropts[] = 2807 { 2808 { "-heap", HEAPSIZE }, 2809 { "-stack", STACKSIZE_K }, 2810 { "-attr", SECTIONS }, 2811 { "-export", EXPORTS }, 2812 { "-aligncomm", ALIGNCOMM }, 2813 { 0, 0 } 2814 }; 2815 2816 void 2817 def_file_add_directive (def_file *my_def, const char *param, int len) 2818 { 2819 def_file *save_def = def; 2820 const char *pend = param + len; 2821 char * tend = (char *) param; 2822 int i; 2823 2824 def = my_def; 2825 2826 while (param < pend) 2827 { 2828 while (param < pend 2829 && (ISSPACE (*param) || *param == '\n' || *param == 0)) 2830 param++; 2831 2832 if (param == pend) 2833 break; 2834 2835 /* Scan forward until we encounter any of: 2836 - the end of the buffer 2837 - the start of a new option 2838 - a newline seperating options 2839 - a NUL seperating options. */ 2840 for (tend = (char *) (param + 1); 2841 (tend < pend 2842 && !(ISSPACE (tend[-1]) && *tend == '-') 2843 && *tend != '\n' && *tend != 0); 2844 tend++) 2845 ; 2846 2847 for (i = 0; diropts[i].param; i++) 2848 { 2849 len = strlen (diropts[i].param); 2850 2851 if (tend - param >= len 2852 && strncmp (param, diropts[i].param, len) == 0 2853 && (param[len] == ':' || param[len] == ' ')) 2854 { 2855 lex_parse_string_end = tend; 2856 lex_parse_string = param + len + 1; 2857 lex_forced_token = diropts[i].token; 2858 saw_newline = 0; 2859 if (def_parse ()) 2860 continue; 2861 break; 2862 } 2863 } 2864 2865 if (!diropts[i].param) 2866 { 2867 if (tend < pend) 2868 { 2869 char saved; 2870 2871 saved = * tend; 2872 * tend = 0; 2873 /* xgettext:c-format */ 2874 einfo (_("Warning: .drectve `%s' unrecognized\n"), param); 2875 * tend = saved; 2876 } 2877 else 2878 { 2879 einfo (_("Warning: corrupt .drectve at end of def file\n")); 2880 } 2881 } 2882 2883 lex_parse_string = 0; 2884 param = tend; 2885 } 2886 2887 def = save_def; 2888 def_pool_free (); 2889 } 2890 2891 /* Parser Callbacks. */ 2892 2893 static void 2894 def_image_name (const char *name, bfd_vma base, int is_dll) 2895 { 2896 /* If a LIBRARY or NAME statement is specified without a name, there is nothing 2897 to do here. We retain the output filename specified on command line. */ 2898 if (*name) 2899 { 2900 const char* image_name = lbasename (name); 2901 2902 if (image_name != name) 2903 einfo ("%s:%d: Warning: path components stripped from %s, '%s'\n", 2904 def_filename, linenumber, is_dll ? "LIBRARY" : "NAME", 2905 name); 2906 if (def->name) 2907 free (def->name); 2908 /* Append the default suffix, if none specified. */ 2909 if (strchr (image_name, '.') == 0) 2910 { 2911 const char * suffix = is_dll ? ".dll" : ".exe"; 2912 2913 def->name = xmalloc (strlen (image_name) + strlen (suffix) + 1); 2914 sprintf (def->name, "%s%s", image_name, suffix); 2915 } 2916 else 2917 def->name = xstrdup (image_name); 2918 } 2919 2920 /* Honor a BASE address statement, even if LIBRARY string is empty. */ 2921 def->base_address = base; 2922 def->is_dll = is_dll; 2923 } 2924 2925 static void 2926 def_description (const char *text) 2927 { 2928 int len = def->description ? strlen (def->description) : 0; 2929 2930 len += strlen (text) + 1; 2931 if (def->description) 2932 { 2933 def->description = xrealloc (def->description, len); 2934 strcat (def->description, text); 2935 } 2936 else 2937 { 2938 def->description = xmalloc (len); 2939 strcpy (def->description, text); 2940 } 2941 } 2942 2943 static void 2944 def_stacksize (int reserve, int commit) 2945 { 2946 def->stack_reserve = reserve; 2947 def->stack_commit = commit; 2948 } 2949 2950 static void 2951 def_heapsize (int reserve, int commit) 2952 { 2953 def->heap_reserve = reserve; 2954 def->heap_commit = commit; 2955 } 2956 2957 static void 2958 def_section (const char *name, int attr) 2959 { 2960 def_file_section *s; 2961 int max_sections = ROUND_UP (def->num_section_defs, 4); 2962 2963 if (def->num_section_defs >= max_sections) 2964 { 2965 max_sections = ROUND_UP (def->num_section_defs+1, 4); 2966 2967 if (def->section_defs) 2968 def->section_defs = xrealloc (def->section_defs, 2969 max_sections * sizeof (def_file_import)); 2970 else 2971 def->section_defs = xmalloc (max_sections * sizeof (def_file_import)); 2972 } 2973 s = def->section_defs + def->num_section_defs; 2974 memset (s, 0, sizeof (def_file_section)); 2975 s->name = xstrdup (name); 2976 if (attr & 1) 2977 s->flag_read = 1; 2978 if (attr & 2) 2979 s->flag_write = 1; 2980 if (attr & 4) 2981 s->flag_execute = 1; 2982 if (attr & 8) 2983 s->flag_shared = 1; 2984 2985 def->num_section_defs++; 2986 } 2987 2988 static void 2989 def_section_alt (const char *name, const char *attr) 2990 { 2991 int aval = 0; 2992 2993 for (; *attr; attr++) 2994 { 2995 switch (*attr) 2996 { 2997 case 'R': 2998 case 'r': 2999 aval |= 1; 3000 break; 3001 case 'W': 3002 case 'w': 3003 aval |= 2; 3004 break; 3005 case 'X': 3006 case 'x': 3007 aval |= 4; 3008 break; 3009 case 'S': 3010 case 's': 3011 aval |= 8; 3012 break; 3013 } 3014 } 3015 def_section (name, aval); 3016 } 3017 3018 static void 3019 def_exports (const char *external_name, 3020 const char *internal_name, 3021 int ordinal, 3022 int flags, 3023 const char *its_name) 3024 { 3025 def_file_export *dfe; 3026 int is_dup = 0; 3027 3028 if (!internal_name && external_name) 3029 internal_name = external_name; 3030 #if TRACE 3031 printf ("def_exports, ext=%s int=%s\n", external_name, internal_name); 3032 #endif 3033 3034 dfe = def_file_add_export (def, external_name, internal_name, ordinal, 3035 its_name, &is_dup); 3036 3037 /* We might check here for flag redefinition and warn. For now we 3038 ignore duplicates silently. */ 3039 if (is_dup) 3040 return; 3041 3042 if (flags & 1) 3043 dfe->flag_noname = 1; 3044 if (flags & 2) 3045 dfe->flag_constant = 1; 3046 if (flags & 4) 3047 dfe->flag_data = 1; 3048 if (flags & 8) 3049 dfe->flag_private = 1; 3050 } 3051 3052 static void 3053 def_import (const char *internal_name, 3054 const char *module, 3055 const char *dllext, 3056 const char *name, 3057 int ordinal, 3058 const char *its_name) 3059 { 3060 char *buf = 0; 3061 const char *ext = dllext ? dllext : "dll"; 3062 int is_dup = 0; 3063 3064 buf = xmalloc (strlen (module) + strlen (ext) + 2); 3065 sprintf (buf, "%s.%s", module, ext); 3066 module = buf; 3067 3068 def_file_add_import (def, name, module, ordinal, internal_name, its_name, 3069 &is_dup); 3070 free (buf); 3071 } 3072 3073 static void 3074 def_version (int major, int minor) 3075 { 3076 def->version_major = major; 3077 def->version_minor = minor; 3078 } 3079 3080 static void 3081 def_directive (char *str) 3082 { 3083 struct directive *d = xmalloc (sizeof (struct directive)); 3084 3085 d->next = directives; 3086 directives = d; 3087 d->name = xstrdup (str); 3088 d->len = strlen (str); 3089 } 3090 3091 static void 3092 def_aligncomm (char *str, int align) 3093 { 3094 def_file_aligncomm *c, *p; 3095 3096 p = NULL; 3097 c = def->aligncomms; 3098 while (c != NULL) 3099 { 3100 int e = strcmp (c->symbol_name, str); 3101 if (!e) 3102 { 3103 /* Not sure if we want to allow here duplicates with 3104 different alignments, but for now we keep them. */ 3105 e = (int) c->alignment - align; 3106 if (!e) 3107 return; 3108 } 3109 if (e > 0) 3110 break; 3111 c = (p = c)->next; 3112 } 3113 3114 c = xmalloc (sizeof (def_file_aligncomm)); 3115 c->symbol_name = xstrdup (str); 3116 c->alignment = (unsigned int) align; 3117 if (!p) 3118 { 3119 c->next = def->aligncomms; 3120 def->aligncomms = c; 3121 } 3122 else 3123 { 3124 c->next = p->next; 3125 p->next = c; 3126 } 3127 } 3128 3129 static int 3130 def_error (const char *err) 3131 { 3132 einfo ("%P: %s:%d: %s\n", 3133 def_filename ? def_filename : "<unknown-file>", linenumber, err); 3134 return 0; 3135 } 3136 3137 3138 /* Lexical Scanner. */ 3139 3140 #undef TRACE 3141 #define TRACE 0 3142 3143 /* Never freed, but always reused as needed, so no real leak. */ 3144 static char *buffer = 0; 3145 static int buflen = 0; 3146 static int bufptr = 0; 3147 3148 static void 3149 put_buf (char c) 3150 { 3151 if (bufptr == buflen) 3152 { 3153 buflen += 50; /* overly reasonable, eh? */ 3154 if (buffer) 3155 buffer = xrealloc (buffer, buflen + 1); 3156 else 3157 buffer = xmalloc (buflen + 1); 3158 } 3159 buffer[bufptr++] = c; 3160 buffer[bufptr] = 0; /* not optimal, but very convenient. */ 3161 } 3162 3163 static struct 3164 { 3165 char *name; 3166 int token; 3167 } 3168 tokens[] = 3169 { 3170 { "BASE", BASE }, 3171 { "CODE", CODE }, 3172 { "CONSTANT", CONSTANTU }, 3173 { "constant", CONSTANTL }, 3174 { "DATA", DATAU }, 3175 { "data", DATAL }, 3176 { "DESCRIPTION", DESCRIPTION }, 3177 { "DIRECTIVE", DIRECTIVE }, 3178 { "EXECUTE", EXECUTE }, 3179 { "EXPORTS", EXPORTS }, 3180 { "HEAPSIZE", HEAPSIZE }, 3181 { "IMPORTS", IMPORTS }, 3182 { "LIBRARY", LIBRARY }, 3183 { "NAME", NAME }, 3184 { "NONAME", NONAMEU }, 3185 { "noname", NONAMEL }, 3186 { "PRIVATE", PRIVATEU }, 3187 { "private", PRIVATEL }, 3188 { "READ", READ }, 3189 { "SECTIONS", SECTIONS }, 3190 { "SEGMENTS", SECTIONS }, 3191 { "SHARED", SHARED }, 3192 { "STACKSIZE", STACKSIZE_K }, 3193 { "VERSION", VERSIONK }, 3194 { "WRITE", WRITE }, 3195 { 0, 0 } 3196 }; 3197 3198 static int 3199 def_getc (void) 3200 { 3201 int rv; 3202 3203 if (lex_parse_string) 3204 { 3205 if (lex_parse_string >= lex_parse_string_end) 3206 rv = EOF; 3207 else 3208 rv = *lex_parse_string++; 3209 } 3210 else 3211 { 3212 rv = fgetc (the_file); 3213 } 3214 if (rv == '\n') 3215 saw_newline = 1; 3216 return rv; 3217 } 3218 3219 static int 3220 def_ungetc (int c) 3221 { 3222 if (lex_parse_string) 3223 { 3224 lex_parse_string--; 3225 return c; 3226 } 3227 else 3228 return ungetc (c, the_file); 3229 } 3230 3231 static int 3232 def_lex (void) 3233 { 3234 int c, i, q; 3235 3236 if (lex_forced_token) 3237 { 3238 i = lex_forced_token; 3239 lex_forced_token = 0; 3240 #if TRACE 3241 printf ("lex: forcing token %d\n", i); 3242 #endif 3243 return i; 3244 } 3245 3246 c = def_getc (); 3247 3248 /* Trim leading whitespace. */ 3249 while (c != EOF && (c == ' ' || c == '\t') && saw_newline) 3250 c = def_getc (); 3251 3252 if (c == EOF) 3253 { 3254 #if TRACE 3255 printf ("lex: EOF\n"); 3256 #endif 3257 return 0; 3258 } 3259 3260 if (saw_newline && c == ';') 3261 { 3262 do 3263 { 3264 c = def_getc (); 3265 } 3266 while (c != EOF && c != '\n'); 3267 if (c == '\n') 3268 return def_lex (); 3269 return 0; 3270 } 3271 3272 /* Must be something else. */ 3273 saw_newline = 0; 3274 3275 if (ISDIGIT (c)) 3276 { 3277 bufptr = 0; 3278 while (c != EOF && (ISXDIGIT (c) || (c == 'x'))) 3279 { 3280 put_buf (c); 3281 c = def_getc (); 3282 } 3283 if (c != EOF) 3284 def_ungetc (c); 3285 yylval.digits = def_pool_strdup (buffer); 3286 #if TRACE 3287 printf ("lex: `%s' returns DIGITS\n", buffer); 3288 #endif 3289 return DIGITS; 3290 } 3291 3292 if (ISALPHA (c) || strchr ("$:-_?@", c)) 3293 { 3294 bufptr = 0; 3295 q = c; 3296 put_buf (c); 3297 c = def_getc (); 3298 3299 if (q == '@') 3300 { 3301 if (ISBLANK (c) ) /* '@' followed by whitespace. */ 3302 return (q); 3303 else if (ISDIGIT (c)) /* '@' followed by digit. */ 3304 { 3305 def_ungetc (c); 3306 return (q); 3307 } 3308 #if TRACE 3309 printf ("lex: @ returns itself\n"); 3310 #endif 3311 } 3312 3313 while (c != EOF && (ISALNUM (c) || strchr ("$:-_?/@<>", c))) 3314 { 3315 put_buf (c); 3316 c = def_getc (); 3317 } 3318 if (c != EOF) 3319 def_ungetc (c); 3320 if (ISALPHA (q)) /* Check for tokens. */ 3321 { 3322 for (i = 0; tokens[i].name; i++) 3323 if (strcmp (tokens[i].name, buffer) == 0) 3324 { 3325 #if TRACE 3326 printf ("lex: `%s' is a string token\n", buffer); 3327 #endif 3328 return tokens[i].token; 3329 } 3330 } 3331 #if TRACE 3332 printf ("lex: `%s' returns ID\n", buffer); 3333 #endif 3334 yylval.id = def_pool_strdup (buffer); 3335 return ID; 3336 } 3337 3338 if (c == '\'' || c == '"') 3339 { 3340 q = c; 3341 c = def_getc (); 3342 bufptr = 0; 3343 3344 while (c != EOF && c != q) 3345 { 3346 put_buf (c); 3347 c = def_getc (); 3348 } 3349 yylval.id = def_pool_strdup (buffer); 3350 #if TRACE 3351 printf ("lex: `%s' returns ID\n", buffer); 3352 #endif 3353 return ID; 3354 } 3355 3356 if ( c == '=') 3357 { 3358 c = def_getc (); 3359 if (c == '=') 3360 { 3361 #if TRACE 3362 printf ("lex: `==' returns EQUAL\n"); 3363 #endif 3364 return EQUAL; 3365 } 3366 def_ungetc (c); 3367 #if TRACE 3368 printf ("lex: `=' returns itself\n"); 3369 #endif 3370 return '='; 3371 } 3372 if (c == '.' || c == ',') 3373 { 3374 #if TRACE 3375 printf ("lex: `%c' returns itself\n", c); 3376 #endif 3377 return c; 3378 } 3379 3380 if (c == '\n') 3381 { 3382 linenumber++; 3383 saw_newline = 1; 3384 } 3385 3386 /*printf ("lex: 0x%02x ignored\n", c); */ 3387 return def_lex (); 3388 } 3389 3390 static char * 3391 def_pool_alloc (size_t sz) 3392 { 3393 def_pool_str *e; 3394 3395 e = (def_pool_str *) xmalloc (sizeof (def_pool_str) + sz); 3396 e->next = pool_strs; 3397 pool_strs = e; 3398 return e->data; 3399 } 3400 3401 static char * 3402 def_pool_strdup (const char *str) 3403 { 3404 char *s; 3405 size_t len; 3406 if (!str) 3407 return NULL; 3408 len = strlen (str) + 1; 3409 s = def_pool_alloc (len); 3410 memcpy (s, str, len); 3411 return s; 3412 } 3413 3414 static void 3415 def_pool_free (void) 3416 { 3417 def_pool_str *p; 3418 while ((p = pool_strs) != NULL) 3419 { 3420 pool_strs = p->next; 3421 free (p); 3422 } 3423 } 3424 3425