1 /* 2 * Copyright (c) 1999-2009 Apple Inc. All rights reserved. 3 * 4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ 5 * 6 * This file contains Original Code and/or Modifications of Original Code 7 * as defined in and that are subject to the Apple Public Source License 8 * Version 2.0 (the 'License'). You may not use this file except in 9 * compliance with the License. The rights granted to you under the License 10 * may not be used to create, or enable the creation or redistribution of, 11 * unlawful or unlicensed copies of an Apple operating system, or to 12 * circumvent, violate, or enable the circumvention or violation of, any 13 * terms of an Apple operating system software license agreement. 14 * 15 * Please obtain a copy of the License at 16 * http://www.opensource.apple.com/apsl/ and read it before using this file. 17 * 18 * The Original Code and all software distributed under the License are 19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, 21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, 22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 23 * Please see the License for the specific language governing rights and 24 * limitations under the License. 25 * 26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ 27 */ 28 29 /* 30 * HISTORY 31 * 32 * OSUnserializeXML.y created by rsulack on Tue Oct 12 1999 33 */ 34 35 // parser for unserializing OSContainer objects serialized to XML 36 // 37 // to build : 38 // bison -p OSUnserializeXML OSUnserializeXML.y 39 // head -50 OSUnserializeXML.y > OSUnserializeXML.cpp 40 // sed -e "s/#include <stdio.h>//" < OSUnserializeXML.tab.c >> OSUnserializeXML.cpp 41 // 42 // when changing code check in both OSUnserializeXML.y and OSUnserializeXML.cpp 43 // 44 // 45 // 46 // 47 // 48 // DO NOT EDIT OSUnserializeXML.cpp! 49 // 50 // this means you! 51 /* A Bison parser, made by GNU Bison 2.3. */ 52 53 /* Skeleton implementation for Bison's Yacc-like parsers in C 54 55 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 56 Free Software Foundation, Inc. 57 58 This program is free software; you can redistribute it and/or modify 59 it under the terms of the GNU General Public License as published by 60 the Free Software Foundation; either version 2, or (at your option) 61 any later version. 62 63 This program is distributed in the hope that it will be useful, 64 but WITHOUT ANY WARRANTY; without even the implied warranty of 65 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 66 GNU General Public License for more details. 67 68 You should have received a copy of the GNU General Public License 69 along with this program; if not, write to the Free Software 70 Foundation, Inc., 51 Franklin Street, Fifth Floor, 71 Boston, MA 02110-1301, USA. */ 72 73 /* As a special exception, you may create a larger work that contains 74 part or all of the Bison parser skeleton and distribute that work 75 under terms of your choice, so long as that work isn't itself a 76 parser generator using the skeleton or a modified version thereof 77 as a parser skeleton. Alternatively, if you modify or redistribute 78 the parser skeleton itself, you may (at your option) remove this 79 special exception, which will cause the skeleton and the resulting 80 Bison output files to be licensed under the GNU General Public 81 License without this special exception. 82 83 This special exception was added by the Free Software Foundation in 84 version 2.2 of Bison. */ 85 86 /* C LALR(1) parser skeleton written by Richard Stallman, by 87 simplifying the original so-called "semantic" parser. */ 88 89 /* All symbols defined below should begin with yy or YY, to avoid 90 infringing on user name space. This should be done even for local 91 variables, as they might otherwise be expanded by user macros. 92 There are some unavoidable exceptions within include files to 93 define necessary library symbols; they are noted "INFRINGES ON 94 USER NAME SPACE" below. */ 95 96 /* Identify Bison output. */ 97 #define YYBISON 1 98 99 /* Bison version. */ 100 #define YYBISON_VERSION "2.3" 101 102 /* Skeleton name. */ 103 #define YYSKELETON_NAME "yacc.c" 104 105 /* Pure parsers. */ 106 #define YYPURE 1 107 108 /* Using locations. */ 109 #define YYLSP_NEEDED 0 110 111 /* Substitute the variable and function names. */ 112 #define yyparse OSUnserializeXMLparse 113 #define yylex OSUnserializeXMLlex 114 #define yyerror OSUnserializeXMLerror 115 #define yylval OSUnserializeXMLlval 116 #define yychar OSUnserializeXMLchar 117 #define yydebug OSUnserializeXMLdebug 118 #define yynerrs OSUnserializeXMLnerrs 119 120 121 /* Tokens. */ 122 #ifndef YYTOKENTYPE 123 # define YYTOKENTYPE 124 /* Put the tokens into the symbol table, so that GDB and other debuggers 125 know about them. */ 126 enum yytokentype { 127 ARRAY = 258, 128 BOOLEAN = 259, 129 DATA = 260, 130 DICTIONARY = 261, 131 IDREF = 262, 132 KEY = 263, 133 NUMBER = 264, 134 SET = 265, 135 STRING = 266, 136 SYNTAX_ERROR = 267 137 }; 138 #endif 139 /* Tokens. */ 140 #define ARRAY 258 141 #define BOOLEAN 259 142 #define DATA 260 143 #define DICTIONARY 261 144 #define IDREF 262 145 #define KEY 263 146 #define NUMBER 264 147 #define SET 265 148 #define STRING 266 149 #define SYNTAX_ERROR 267 150 151 152 153 154 /* Copy the first part of user declarations. */ 155 #line 61 "OSUnserializeXML.y" 156 157 #include <string.h> 158 #include <libkern/c++/OSMetaClass.h> 159 #include <libkern/c++/OSContainers.h> 160 #include <libkern/c++/OSLib.h> 161 162 #define YYSTYPE object_t * 163 #define YYPARSE_PARAM state 164 #define YYLEX_PARAM (parser_state_t *)state 165 166 // this is the internal struct used to hold objects on parser stack 167 // it represents objects both before and after they have been created 168 typedef struct object { 169 struct object *next; 170 struct object *free; 171 struct object *elements; 172 OSObject *object; 173 OSString *key; // for dictionary 174 int size; 175 void *data; // for data 176 char *string; // for string & symbol 177 long long number; // for number 178 int idref; 179 } object_t; 180 181 // this code is reentrant, this structure contains all 182 // state information for the parsing of a single buffer 183 typedef struct parser_state { 184 const char *parseBuffer; // start of text to be parsed 185 int parseBufferIndex; // current index into text 186 int lineNumber; // current line number 187 object_t *objects; // internal objects in use 188 object_t *freeObjects; // internal objects that are free 189 OSDictionary *tags; // used to remember "ID" tags 190 OSString **errorString; // parse error with line 191 OSObject *parsedObject; // resultant object of parsed text 192 } parser_state_t; 193 194 #define STATE ((parser_state_t *)state) 195 196 #undef yyerror 197 #define yyerror(s) OSUnserializeerror(STATE, (s)) 198 static int OSUnserializeerror(parser_state_t *state, const char *s); 199 200 static int yylex(YYSTYPE *lvalp, parser_state_t *state); 201 202 static object_t *newObject(parser_state_t *state); 203 static void freeObject(parser_state_t *state, object_t *o); 204 static void rememberObject(parser_state_t *state, int tag, OSObject *o); 205 static object_t *retrieveObject(parser_state_t *state, int tag); 206 static void cleanupObjects(parser_state_t *state); 207 208 static object_t *buildDictionary(parser_state_t *state, object_t *o); 209 static object_t *buildArray(parser_state_t *state, object_t *o); 210 static object_t *buildSet(parser_state_t *state, object_t *o); 211 static object_t *buildString(parser_state_t *state, object_t *o); 212 static object_t *buildData(parser_state_t *state, object_t *o); 213 static object_t *buildNumber(parser_state_t *state, object_t *o); 214 static object_t *buildBoolean(parser_state_t *state, object_t *o); 215 216 extern "C" { 217 extern void *kern_os_malloc(size_t size); 218 extern void *kern_os_realloc(void * addr, size_t size); 219 extern void kern_os_free(void * addr); 220 221 } /* extern "C" */ 222 223 #define malloc(s) kern_os_malloc(s) 224 #define realloc(a, s) kern_os_realloc(a, s) 225 #define free(a) kern_os_free((void *)a) 226 227 228 229 /* Enabling traces. */ 230 #ifndef YYDEBUG 231 # define YYDEBUG 0 232 #endif 233 234 /* Enabling verbose error messages. */ 235 #ifdef YYERROR_VERBOSE 236 # undef YYERROR_VERBOSE 237 # define YYERROR_VERBOSE 1 238 #else 239 # define YYERROR_VERBOSE 0 240 #endif 241 242 /* Enabling the token table. */ 243 #ifndef YYTOKEN_TABLE 244 # define YYTOKEN_TABLE 0 245 #endif 246 247 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 248 typedef int YYSTYPE; 249 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ 250 # define YYSTYPE_IS_DECLARED 1 251 # define YYSTYPE_IS_TRIVIAL 1 252 #endif 253 254 255 256 /* Copy the second part of user declarations. */ 257 258 259 /* Line 216 of yacc.c. */ 260 #line 211 "OSUnserializeXML.tab.c" 261 262 #ifdef short 263 # undef short 264 #endif 265 266 #ifdef YYTYPE_UINT8 267 typedef YYTYPE_UINT8 yytype_uint8; 268 #else 269 typedef unsigned char yytype_uint8; 270 #endif 271 272 #ifdef YYTYPE_INT8 273 typedef YYTYPE_INT8 yytype_int8; 274 #elif (defined __STDC__ || defined __C99__FUNC__ \ 275 || defined __cplusplus || defined _MSC_VER) 276 typedef signed char yytype_int8; 277 #else 278 typedef short int yytype_int8; 279 #endif 280 281 #ifdef YYTYPE_UINT16 282 typedef YYTYPE_UINT16 yytype_uint16; 283 #else 284 typedef unsigned short int yytype_uint16; 285 #endif 286 287 #ifdef YYTYPE_INT16 288 typedef YYTYPE_INT16 yytype_int16; 289 #else 290 typedef short int yytype_int16; 291 #endif 292 293 #ifndef YYSIZE_T 294 # ifdef __SIZE_TYPE__ 295 # define YYSIZE_T __SIZE_TYPE__ 296 # elif defined size_t 297 # define YYSIZE_T size_t 298 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ 299 || defined __cplusplus || defined _MSC_VER) 300 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 301 # define YYSIZE_T size_t 302 # else 303 # define YYSIZE_T unsigned int 304 # endif 305 #endif 306 307 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) 308 309 #ifndef YY_ 310 # if defined YYENABLE_NLS && YYENABLE_NLS 311 # if ENABLE_NLS 312 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 313 # define YY_(msgid) dgettext ("bison-runtime", msgid) 314 # endif 315 # endif 316 # ifndef YY_ 317 # define YY_(msgid) msgid 318 # endif 319 #endif 320 321 /* Suppress unused-variable warnings by "using" E. */ 322 #if ! defined lint || defined __GNUC__ 323 # define YYUSE(e) ((void) (e)) 324 #else 325 # define YYUSE(e) /* empty */ 326 #endif 327 328 /* Identity function, used to suppress warnings about constant conditions. */ 329 #ifndef lint 330 # define YYID(n) (n) 331 #else 332 #if (defined __STDC__ || defined __C99__FUNC__ \ 333 || defined __cplusplus || defined _MSC_VER) 334 static int 335 YYID (int i) 336 #else 337 static int 338 YYID (i) 339 int i; 340 #endif 341 { 342 return i; 343 } 344 #endif 345 346 #if ! defined yyoverflow || YYERROR_VERBOSE 347 348 /* The parser invokes alloca or malloc; define the necessary symbols. */ 349 350 # ifdef YYSTACK_USE_ALLOCA 351 # if YYSTACK_USE_ALLOCA 352 # ifdef __GNUC__ 353 # define YYSTACK_ALLOC __builtin_alloca 354 # elif defined __BUILTIN_VA_ARG_INCR 355 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */ 356 # elif defined _AIX 357 # define YYSTACK_ALLOC __alloca 358 # elif defined _MSC_VER 359 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */ 360 # define alloca _alloca 361 # else 362 # define YYSTACK_ALLOC alloca 363 # if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 364 || defined __cplusplus || defined _MSC_VER) 365 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 366 # ifndef _STDLIB_H 367 # define _STDLIB_H 1 368 # endif 369 # endif 370 # endif 371 # endif 372 # endif 373 374 # ifdef YYSTACK_ALLOC 375 /* Pacify GCC's `empty if-body' warning. */ 376 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) 377 # ifndef YYSTACK_ALLOC_MAXIMUM 378 /* The OS might guarantee only one guard page at the bottom of the stack, 379 and a page size can be as small as 4096 bytes. So we cannot safely 380 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number 381 to allow for a few compiler-allocated temporary stack slots. */ 382 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ 383 # endif 384 # else 385 # define YYSTACK_ALLOC YYMALLOC 386 # define YYSTACK_FREE YYFREE 387 # ifndef YYSTACK_ALLOC_MAXIMUM 388 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM 389 # endif 390 # if (defined __cplusplus && ! defined _STDLIB_H \ 391 && ! ((defined YYMALLOC || defined malloc) \ 392 && (defined YYFREE || defined free))) 393 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 394 # ifndef _STDLIB_H 395 # define _STDLIB_H 1 396 # endif 397 # endif 398 # ifndef YYMALLOC 399 # define YYMALLOC malloc 400 # if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 401 || defined __cplusplus || defined _MSC_VER) 402 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ 403 # endif 404 # endif 405 # ifndef YYFREE 406 # define YYFREE free 407 # if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 408 || defined __cplusplus || defined _MSC_VER) 409 void free (void *); /* INFRINGES ON USER NAME SPACE */ 410 # endif 411 # endif 412 # endif 413 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */ 414 415 416 #if (! defined yyoverflow \ 417 && (! defined __cplusplus \ 418 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) 419 420 /* A type that is properly aligned for any stack member. */ 421 union yyalloc 422 { 423 yytype_int16 yyss; 424 YYSTYPE yyvs; 425 }; 426 427 /* The size of the maximum gap between one aligned stack and the next. */ 428 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 429 430 /* The size of an array large to enough to hold all stacks, each with 431 N elements. */ 432 # define YYSTACK_BYTES(N) \ 433 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ 434 + YYSTACK_GAP_MAXIMUM) 435 436 /* Copy COUNT objects from FROM to TO. The source and destination do 437 not overlap. */ 438 # ifndef YYCOPY 439 # if defined __GNUC__ && 1 < __GNUC__ 440 # define YYCOPY(To, From, Count) \ 441 __builtin_memcpy (To, From, (Count) * sizeof (*(From))) 442 # else 443 # define YYCOPY(To, From, Count) \ 444 do \ 445 { \ 446 YYSIZE_T yyi; \ 447 for (yyi = 0; yyi < (Count); yyi++) \ 448 (To)[yyi] = (From)[yyi]; \ 449 } \ 450 while (YYID (0)) 451 # endif 452 # endif 453 454 /* Relocate STACK from its old location to the new one. The 455 local variables YYSIZE and YYSTACKSIZE give the old and new number of 456 elements in the stack, and YYPTR gives the new location of the 457 stack. Advance YYPTR to a properly aligned location for the next 458 stack. */ 459 # define YYSTACK_RELOCATE(Stack) \ 460 do \ 461 { \ 462 YYSIZE_T yynewbytes; \ 463 YYCOPY (&yyptr->Stack, Stack, yysize); \ 464 Stack = &yyptr->Stack; \ 465 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 466 yyptr += yynewbytes / sizeof (*yyptr); \ 467 } \ 468 while (YYID (0)) 469 470 #endif 471 472 /* YYFINAL -- State number of the termination state. */ 473 #define YYFINAL 33 474 /* YYLAST -- Last index in YYTABLE. */ 475 #define YYLAST 108 476 477 /* YYNTOKENS -- Number of terminals. */ 478 #define YYNTOKENS 19 479 /* YYNNTS -- Number of nonterminals. */ 480 #define YYNNTS 15 481 /* YYNRULES -- Number of rules. */ 482 #define YYNRULES 32 483 /* YYNRULES -- Number of states. */ 484 #define YYNSTATES 40 485 486 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ 487 #define YYUNDEFTOK 2 488 #define YYMAXUTOK 267 489 490 #define YYTRANSLATE(YYX) \ 491 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) 492 493 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ 494 static const yytype_uint8 yytranslate[] = 495 { 496 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 497 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 498 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 499 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 500 15, 16, 2, 2, 2, 2, 2, 2, 2, 2, 501 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 502 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 503 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 504 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 505 2, 17, 2, 18, 2, 2, 2, 2, 2, 2, 506 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 507 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 508 2, 2, 2, 13, 2, 14, 2, 2, 2, 2, 509 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 510 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 511 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 512 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 513 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 514 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 515 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 516 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 517 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 518 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 519 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 520 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 521 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 522 5, 6, 7, 8, 9, 10, 11, 12 523 }; 524 525 #if YYDEBUG 526 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in 527 YYRHS. */ 528 static const yytype_uint8 yyprhs[] = 529 { 530 0, 0, 3, 4, 6, 8, 10, 12, 14, 16, 531 18, 20, 22, 24, 27, 31, 33, 35, 38, 41, 532 43, 46, 50, 52, 55, 59, 61, 63, 66, 68, 533 70, 72, 74 534 }; 535 536 /* YYRHS -- A `-1'-separated list of the rules' RHS. */ 537 static const yytype_int8 yyrhs[] = 538 { 539 20, 0, -1, -1, 21, -1, 12, -1, 22, -1, 540 26, -1, 27, -1, 33, -1, 30, -1, 32, -1, 541 29, -1, 31, -1, 13, 14, -1, 13, 23, 14, 542 -1, 6, -1, 24, -1, 23, 24, -1, 25, 21, 543 -1, 8, -1, 15, 16, -1, 15, 28, 16, -1, 544 3, -1, 17, 18, -1, 17, 28, 18, -1, 10, 545 -1, 21, -1, 28, 21, -1, 4, -1, 5, -1, 546 7, -1, 9, -1, 11, -1 547 }; 548 549 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ 550 static const yytype_uint8 yyrline[] = 551 { 552 0, 145, 145, 148, 153, 158, 159, 160, 161, 162, 553 163, 164, 165, 178, 181, 184, 187, 188, 193, 202, 554 207, 210, 213, 216, 219, 222, 225, 228, 235, 238, 555 241, 244, 247 556 }; 557 #endif 558 559 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE 560 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 561 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 562 static const char *const yytname[] = 563 { 564 "$end", "error", "$undefined", "ARRAY", "BOOLEAN", "DATA", "DICTIONARY", 565 "IDREF", "KEY", "NUMBER", "SET", "STRING", "SYNTAX_ERROR", "'{'", "'}'", 566 "'('", "')'", "'['", "']'", "$accept", "input", "object", "dict", 567 "pairs", "pair", "key", "array", "set", "elements", "boolean", "data", 568 "idref", "number", "string", 0 569 }; 570 #endif 571 572 # ifdef YYPRINT 573 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to 574 token YYLEX-NUM. */ 575 static const yytype_uint16 yytoknum[] = 576 { 577 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 578 265, 266, 267, 123, 125, 40, 41, 91, 93 579 }; 580 # endif 581 582 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 583 static const yytype_uint8 yyr1[] = 584 { 585 0, 19, 20, 20, 20, 21, 21, 21, 21, 21, 586 21, 21, 21, 22, 22, 22, 23, 23, 24, 25, 587 26, 26, 26, 27, 27, 27, 28, 28, 29, 30, 588 31, 32, 33 589 }; 590 591 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ 592 static const yytype_uint8 yyr2[] = 593 { 594 0, 2, 0, 1, 1, 1, 1, 1, 1, 1, 595 1, 1, 1, 2, 3, 1, 1, 2, 2, 1, 596 2, 3, 1, 2, 3, 1, 1, 2, 1, 1, 597 1, 1, 1 598 }; 599 600 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state 601 STATE-NUM when YYTABLE doesn't specify something else to do. Zero 602 means the default is an error. */ 603 static const yytype_uint8 yydefact[] = 604 { 605 2, 22, 28, 29, 15, 30, 31, 25, 32, 4, 606 0, 0, 0, 0, 3, 5, 6, 7, 11, 9, 607 12, 10, 8, 19, 13, 0, 16, 0, 20, 26, 608 0, 23, 0, 1, 14, 17, 18, 21, 27, 24 609 }; 610 611 /* YYDEFGOTO[NTERM-NUM]. */ 612 static const yytype_int8 yydefgoto[] = 613 { 614 -1, 13, 29, 15, 25, 26, 27, 16, 17, 30, 615 18, 19, 20, 21, 22 616 }; 617 618 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 619 STATE-NUM. */ 620 #define YYPACT_NINF -20 621 static const yytype_int8 yypact[] = 622 { 623 46, -20, -20, -20, -20, -20, -20, -20, -20, -20, 624 4, 61, -2, 10, -20, -20, -20, -20, -20, -20, 625 -20, -20, -20, -20, -20, 6, -20, 91, -20, -20, 626 76, -20, 30, -20, -20, -20, -20, -20, -20, -20 627 }; 628 629 /* YYPGOTO[NTERM-NUM]. */ 630 static const yytype_int8 yypgoto[] = 631 { 632 -20, -20, 0, -20, -20, -19, -20, -20, -20, 5, 633 -20, -20, -20, -20, -20 634 }; 635 636 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If 637 positive, shift that token. If negative, reduce the rule which 638 number is the opposite. If zero, do what YYDEFACT says. 639 If YYTABLE_NINF, syntax error. */ 640 #define YYTABLE_NINF -1 641 static const yytype_uint8 yytable[] = 642 { 643 14, 1, 2, 3, 4, 5, 35, 6, 7, 8, 644 33, 10, 23, 11, 23, 12, 31, 32, 24, 0, 645 34, 0, 0, 0, 0, 0, 0, 36, 0, 0, 646 38, 0, 38, 1, 2, 3, 4, 5, 0, 6, 647 7, 8, 0, 10, 0, 11, 0, 12, 39, 1, 648 2, 3, 4, 5, 0, 6, 7, 8, 9, 10, 649 0, 11, 0, 12, 1, 2, 3, 4, 5, 0, 650 6, 7, 8, 0, 10, 0, 11, 28, 12, 1, 651 2, 3, 4, 5, 0, 6, 7, 8, 0, 10, 652 0, 11, 37, 12, 1, 2, 3, 4, 5, 0, 653 6, 7, 8, 0, 10, 0, 11, 0, 12 654 }; 655 656 static const yytype_int8 yycheck[] = 657 { 658 0, 3, 4, 5, 6, 7, 25, 9, 10, 11, 659 0, 13, 8, 15, 8, 17, 18, 12, 14, -1, 660 14, -1, -1, -1, -1, -1, -1, 27, -1, -1, 661 30, -1, 32, 3, 4, 5, 6, 7, -1, 9, 662 10, 11, -1, 13, -1, 15, -1, 17, 18, 3, 663 4, 5, 6, 7, -1, 9, 10, 11, 12, 13, 664 -1, 15, -1, 17, 3, 4, 5, 6, 7, -1, 665 9, 10, 11, -1, 13, -1, 15, 16, 17, 3, 666 4, 5, 6, 7, -1, 9, 10, 11, -1, 13, 667 -1, 15, 16, 17, 3, 4, 5, 6, 7, -1, 668 9, 10, 11, -1, 13, -1, 15, -1, 17 669 }; 670 671 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 672 symbol of state STATE-NUM. */ 673 static const yytype_uint8 yystos[] = 674 { 675 0, 3, 4, 5, 6, 7, 9, 10, 11, 12, 676 13, 15, 17, 20, 21, 22, 26, 27, 29, 30, 677 31, 32, 33, 8, 14, 23, 24, 25, 16, 21, 678 28, 18, 28, 0, 14, 24, 21, 16, 21, 18 679 }; 680 681 #define yyerrok (yyerrstatus = 0) 682 #define yyclearin (yychar = YYEMPTY) 683 #define YYEMPTY (-2) 684 #define YYEOF 0 685 686 #define YYACCEPT goto yyacceptlab 687 #define YYABORT goto yyabortlab 688 #define YYERROR goto yyerrorlab 689 690 691 /* Like YYERROR except do call yyerror. This remains here temporarily 692 to ease the transition to the new meaning of YYERROR, for GCC. 693 Once GCC version 2 has supplanted version 1, this can go. */ 694 695 #define YYFAIL goto yyerrlab 696 697 #define YYRECOVERING() (!!yyerrstatus) 698 699 #define YYBACKUP(Token, Value) \ 700 do \ 701 if (yychar == YYEMPTY && yylen == 1) \ 702 { \ 703 yychar = (Token); \ 704 yylval = (Value); \ 705 yytoken = YYTRANSLATE (yychar); \ 706 YYPOPSTACK (1); \ 707 goto yybackup; \ 708 } \ 709 else \ 710 { \ 711 yyerror (YY_("syntax error: cannot back up")); \ 712 YYERROR; \ 713 } \ 714 while (YYID (0)) 715 716 717 #define YYTERROR 1 718 #define YYERRCODE 256 719 720 721 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. 722 If N is 0, then set CURRENT to the empty location which ends 723 the previous symbol: RHS[0] (always defined). */ 724 725 #define YYRHSLOC(Rhs, K) ((Rhs)[K]) 726 #ifndef YYLLOC_DEFAULT 727 # define YYLLOC_DEFAULT(Current, Rhs, N) \ 728 do \ 729 if (YYID (N)) \ 730 { \ 731 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ 732 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ 733 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ 734 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ 735 } \ 736 else \ 737 { \ 738 (Current).first_line = (Current).last_line = \ 739 YYRHSLOC (Rhs, 0).last_line; \ 740 (Current).first_column = (Current).last_column = \ 741 YYRHSLOC (Rhs, 0).last_column; \ 742 } \ 743 while (YYID (0)) 744 #endif 745 746 747 /* YY_LOCATION_PRINT -- Print the location on the stream. 748 This macro was not mandated originally: define only if we know 749 we won't break user code: when these are the locations we know. */ 750 751 #ifndef YY_LOCATION_PRINT 752 # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL 753 # define YY_LOCATION_PRINT(File, Loc) \ 754 fprintf (File, "%d.%d-%d.%d", \ 755 (Loc).first_line, (Loc).first_column, \ 756 (Loc).last_line, (Loc).last_column) 757 # else 758 # define YY_LOCATION_PRINT(File, Loc) ((void) 0) 759 # endif 760 #endif 761 762 763 /* YYLEX -- calling `yylex' with the right arguments. */ 764 765 #ifdef YYLEX_PARAM 766 # define YYLEX yylex (&yylval, YYLEX_PARAM) 767 #else 768 # define YYLEX yylex (&yylval) 769 #endif 770 771 /* Enable debugging if requested. */ 772 #if YYDEBUG 773 774 # ifndef YYFPRINTF 775 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 776 # define YYFPRINTF fprintf 777 # endif 778 779 # define YYDPRINTF(Args) \ 780 do { \ 781 if (yydebug) \ 782 YYFPRINTF Args; \ 783 } while (YYID (0)) 784 785 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ 786 do { \ 787 if (yydebug) \ 788 { \ 789 YYFPRINTF (stderr, "%s ", Title); \ 790 yy_symbol_print (stderr, \ 791 Type, Value); \ 792 YYFPRINTF (stderr, "\n"); \ 793 } \ 794 } while (YYID (0)) 795 796 797 /*--------------------------------. 798 | Print this symbol on YYOUTPUT. | 799 `--------------------------------*/ 800 801 /*ARGSUSED*/ 802 #if (defined __STDC__ || defined __C99__FUNC__ \ 803 || defined __cplusplus || defined _MSC_VER) 804 static void 805 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 806 #else 807 static void 808 yy_symbol_value_print (yyoutput, yytype, yyvaluep) 809 FILE *yyoutput; 810 int yytype; 811 YYSTYPE const * const yyvaluep; 812 #endif 813 { 814 if (!yyvaluep) 815 return; 816 # ifdef YYPRINT 817 if (yytype < YYNTOKENS) 818 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); 819 # else 820 YYUSE (yyoutput); 821 # endif 822 switch (yytype) 823 { 824 default: 825 break; 826 } 827 } 828 829 830 /*--------------------------------. 831 | Print this symbol on YYOUTPUT. | 832 `--------------------------------*/ 833 834 #if (defined __STDC__ || defined __C99__FUNC__ \ 835 || defined __cplusplus || defined _MSC_VER) 836 static void 837 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 838 #else 839 static void 840 yy_symbol_print (yyoutput, yytype, yyvaluep) 841 FILE *yyoutput; 842 int yytype; 843 YYSTYPE const * const yyvaluep; 844 #endif 845 { 846 if (yytype < YYNTOKENS) 847 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); 848 else 849 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); 850 851 yy_symbol_value_print (yyoutput, yytype, yyvaluep); 852 YYFPRINTF (yyoutput, ")"); 853 } 854 855 /*------------------------------------------------------------------. 856 | yy_stack_print -- Print the state stack from its BOTTOM up to its | 857 | TOP (included). | 858 `------------------------------------------------------------------*/ 859 860 #if (defined __STDC__ || defined __C99__FUNC__ \ 861 || defined __cplusplus || defined _MSC_VER) 862 static void 863 yy_stack_print (yytype_int16 *bottom, yytype_int16 *top) 864 #else 865 static void 866 yy_stack_print (bottom, top) 867 yytype_int16 *bottom; 868 yytype_int16 *top; 869 #endif 870 { 871 YYFPRINTF (stderr, "Stack now"); 872 for (; bottom <= top; ++bottom) 873 YYFPRINTF (stderr, " %d", *bottom); 874 YYFPRINTF (stderr, "\n"); 875 } 876 877 # define YY_STACK_PRINT(Bottom, Top) \ 878 do { \ 879 if (yydebug) \ 880 yy_stack_print ((Bottom), (Top)); \ 881 } while (YYID (0)) 882 883 884 /*------------------------------------------------. 885 | Report that the YYRULE is going to be reduced. | 886 `------------------------------------------------*/ 887 888 #if (defined __STDC__ || defined __C99__FUNC__ \ 889 || defined __cplusplus || defined _MSC_VER) 890 static void 891 yy_reduce_print (YYSTYPE *yyvsp, int yyrule) 892 #else 893 static void 894 yy_reduce_print (yyvsp, yyrule) 895 YYSTYPE *yyvsp; 896 int yyrule; 897 #endif 898 { 899 int yynrhs = yyr2[yyrule]; 900 int yyi; 901 unsigned long int yylno = yyrline[yyrule]; 902 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", 903 yyrule - 1, yylno); 904 /* The symbols being reduced. */ 905 for (yyi = 0; yyi < yynrhs; yyi++) 906 { 907 fprintf (stderr, " $%d = ", yyi + 1); 908 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], 909 &(yyvsp[(yyi + 1) - (yynrhs)]) 910 ); 911 fprintf (stderr, "\n"); 912 } 913 } 914 915 # define YY_REDUCE_PRINT(Rule) \ 916 do { \ 917 if (yydebug) \ 918 yy_reduce_print (yyvsp, Rule); \ 919 } while (YYID (0)) 920 921 /* Nonzero means print parse trace. It is left uninitialized so that 922 multiple parsers can coexist. */ 923 int yydebug; 924 #else /* !YYDEBUG */ 925 # define YYDPRINTF(Args) 926 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) 927 # define YY_STACK_PRINT(Bottom, Top) 928 # define YY_REDUCE_PRINT(Rule) 929 #endif /* !YYDEBUG */ 930 931 932 /* YYINITDEPTH -- initial size of the parser's stacks. */ 933 #ifndef YYINITDEPTH 934 # define YYINITDEPTH 200 935 #endif 936 937 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 938 if the built-in stack extension method is used). 939 940 Do not make this value too large; the results are undefined if 941 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) 942 evaluated with infinite-precision integer arithmetic. */ 943 944 #ifndef YYMAXDEPTH 945 # define YYMAXDEPTH 10000 946 #endif 947 948 949 950 #if YYERROR_VERBOSE 951 952 # ifndef yystrlen 953 # if defined __GLIBC__ && defined _STRING_H 954 # define yystrlen strlen 955 # else 956 /* Return the length of YYSTR. */ 957 #if (defined __STDC__ || defined __C99__FUNC__ \ 958 || defined __cplusplus || defined _MSC_VER) 959 static YYSIZE_T 960 yystrlen (const char *yystr) 961 #else 962 static YYSIZE_T 963 yystrlen (yystr) 964 const char *yystr; 965 #endif 966 { 967 YYSIZE_T yylen; 968 for (yylen = 0; yystr[yylen]; yylen++) 969 continue; 970 return yylen; 971 } 972 # endif 973 # endif 974 975 # ifndef yystpcpy 976 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE 977 # define yystpcpy stpcpy 978 # else 979 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 980 YYDEST. */ 981 #if (defined __STDC__ || defined __C99__FUNC__ \ 982 || defined __cplusplus || defined _MSC_VER) 983 static char * 984 yystpcpy (char *yydest, const char *yysrc) 985 #else 986 static char * 987 yystpcpy (yydest, yysrc) 988 char *yydest; 989 const char *yysrc; 990 #endif 991 { 992 char *yyd = yydest; 993 const char *yys = yysrc; 994 995 while ((*yyd++ = *yys++) != '\0') 996 continue; 997 998 return yyd - 1; 999 } 1000 # endif 1001 # endif 1002 1003 # ifndef yytnamerr 1004 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary 1005 quotes and backslashes, so that it's suitable for yyerror. The 1006 heuristic is that double-quoting is unnecessary unless the string 1007 contains an apostrophe, a comma, or backslash (other than 1008 backslash-backslash). YYSTR is taken from yytname. If YYRES is 1009 null, do not copy; instead, return the length of what the result 1010 would have been. */ 1011 static YYSIZE_T 1012 yytnamerr (char *yyres, const char *yystr) 1013 { 1014 if (*yystr == '"') 1015 { 1016 YYSIZE_T yyn = 0; 1017 char const *yyp = yystr; 1018 1019 for (;;) 1020 switch (*++yyp) 1021 { 1022 case '\'': 1023 case ',': 1024 goto do_not_strip_quotes; 1025 1026 case '\\': 1027 if (*++yyp != '\\') 1028 goto do_not_strip_quotes; 1029 /* Fall through. */ 1030 default: 1031 if (yyres) 1032 yyres[yyn] = *yyp; 1033 yyn++; 1034 break; 1035 1036 case '"': 1037 if (yyres) 1038 yyres[yyn] = '\0'; 1039 return yyn; 1040 } 1041 do_not_strip_quotes: ; 1042 } 1043 1044 if (! yyres) 1045 return yystrlen (yystr); 1046 1047 return yystpcpy (yyres, yystr) - yyres; 1048 } 1049 # endif 1050 1051 /* Copy into YYRESULT an error message about the unexpected token 1052 YYCHAR while in state YYSTATE. Return the number of bytes copied, 1053 including the terminating null byte. If YYRESULT is null, do not 1054 copy anything; just return the number of bytes that would be 1055 copied. As a special case, return 0 if an ordinary "syntax error" 1056 message will do. Return YYSIZE_MAXIMUM if overflow occurs during 1057 size calculation. */ 1058 static YYSIZE_T 1059 yysyntax_error (char *yyresult, int yystate, int yychar) 1060 { 1061 int yyn = yypact[yystate]; 1062 1063 if (! (YYPACT_NINF < yyn && yyn <= YYLAST)) 1064 return 0; 1065 else 1066 { 1067 int yytype = YYTRANSLATE (yychar); 1068 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); 1069 YYSIZE_T yysize = yysize0; 1070 YYSIZE_T yysize1; 1071 int yysize_overflow = 0; 1072 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 1073 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 1074 int yyx; 1075 1076 # if 0 1077 /* This is so xgettext sees the translatable formats that are 1078 constructed on the fly. */ 1079 YY_("syntax error, unexpected %s"); 1080 YY_("syntax error, unexpected %s, expecting %s"); 1081 YY_("syntax error, unexpected %s, expecting %s or %s"); 1082 YY_("syntax error, unexpected %s, expecting %s or %s or %s"); 1083 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); 1084 # endif 1085 char *yyfmt; 1086 char const *yyf; 1087 static char const yyunexpected[] = "syntax error, unexpected %s"; 1088 static char const yyexpecting[] = ", expecting %s"; 1089 static char const yyor[] = " or %s"; 1090 char yyformat[sizeof yyunexpected 1091 + sizeof yyexpecting - 1 1092 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) 1093 * (sizeof yyor - 1))]; 1094 char const *yyprefix = yyexpecting; 1095 1096 /* Start YYX at -YYN if negative to avoid negative indexes in 1097 YYCHECK. */ 1098 int yyxbegin = yyn < 0 ? -yyn : 0; 1099 1100 /* Stay within bounds of both yycheck and yytname. */ 1101 int yychecklim = YYLAST - yyn + 1; 1102 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 1103 int yycount = 1; 1104 1105 yyarg[0] = yytname[yytype]; 1106 yyfmt = yystpcpy (yyformat, yyunexpected); 1107 1108 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 1109 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) 1110 { 1111 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) 1112 { 1113 yycount = 1; 1114 yysize = yysize0; 1115 yyformat[sizeof yyunexpected - 1] = '\0'; 1116 break; 1117 } 1118 yyarg[yycount++] = yytname[yyx]; 1119 yysize1 = yysize + yytnamerr (0, yytname[yyx]); 1120 yysize_overflow |= (yysize1 < yysize); 1121 yysize = yysize1; 1122 yyfmt = yystpcpy (yyfmt, yyprefix); 1123 yyprefix = yyor; 1124 } 1125 1126 yyf = YY_(yyformat); 1127 yysize1 = yysize + yystrlen (yyf); 1128 yysize_overflow |= (yysize1 < yysize); 1129 yysize = yysize1; 1130 1131 if (yysize_overflow) 1132 return YYSIZE_MAXIMUM; 1133 1134 if (yyresult) 1135 { 1136 /* Avoid sprintf, as that infringes on the user's name space. 1137 Don't have undefined behavior even if the translation 1138 produced a string with the wrong number of "%s"s. */ 1139 char *yyp = yyresult; 1140 int yyi = 0; 1141 while ((*yyp = *yyf) != '\0') 1142 { 1143 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) 1144 { 1145 yyp += yytnamerr (yyp, yyarg[yyi++]); 1146 yyf += 2; 1147 } 1148 else 1149 { 1150 yyp++; 1151 yyf++; 1152 } 1153 } 1154 } 1155 return yysize; 1156 } 1157 } 1158 #endif /* YYERROR_VERBOSE */ 1159 1160 1161 /*-----------------------------------------------. 1162 | Release the memory associated to this symbol. | 1163 `-----------------------------------------------*/ 1164 1165 /*ARGSUSED*/ 1166 #if (defined __STDC__ || defined __C99__FUNC__ \ 1167 || defined __cplusplus || defined _MSC_VER) 1168 static void 1169 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) 1170 #else 1171 static void 1172 yydestruct (yymsg, yytype, yyvaluep) 1173 const char *yymsg; 1174 int yytype; 1175 YYSTYPE *yyvaluep; 1176 #endif 1177 { 1178 YYUSE (yyvaluep); 1179 1180 if (!yymsg) 1181 yymsg = "Deleting"; 1182 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 1183 1184 switch (yytype) 1185 { 1186 1187 default: 1188 break; 1189 } 1190 } 1191 1192 1193 /* Prevent warnings from -Wmissing-prototypes. */ 1194 1195 #ifdef YYPARSE_PARAM 1196 #if defined __STDC__ || defined __cplusplus 1197 int yyparse (void *YYPARSE_PARAM); 1198 #else 1199 int yyparse (); 1200 #endif 1201 #else /* ! YYPARSE_PARAM */ 1202 #if defined __STDC__ || defined __cplusplus 1203 int yyparse (void); 1204 #else 1205 int yyparse (); 1206 #endif 1207 #endif /* ! YYPARSE_PARAM */ 1208 1209 1210 1211 1212 1213 1214 /*----------. 1215 | yyparse. | 1216 `----------*/ 1217 1218 #ifdef YYPARSE_PARAM 1219 #if (defined __STDC__ || defined __C99__FUNC__ \ 1220 || defined __cplusplus || defined _MSC_VER) 1221 int 1222 yyparse (void *YYPARSE_PARAM) 1223 #else 1224 int 1225 yyparse (YYPARSE_PARAM) 1226 void *YYPARSE_PARAM; 1227 #endif 1228 #else /* ! YYPARSE_PARAM */ 1229 #if (defined __STDC__ || defined __C99__FUNC__ \ 1230 || defined __cplusplus || defined _MSC_VER) 1231 int 1232 yyparse (void) 1233 #else 1234 int 1235 yyparse () 1236 1237 #endif 1238 #endif 1239 { 1240 /* The look-ahead symbol. */ 1241 int yychar; 1242 1243 /* The semantic value of the look-ahead symbol. */ 1244 YYSTYPE yylval; 1245 1246 /* Number of syntax errors so far. */ 1247 int yynerrs; 1248 1249 int yystate; 1250 int yyn; 1251 int yyresult; 1252 /* Number of tokens to shift before error messages enabled. */ 1253 int yyerrstatus; 1254 /* Look-ahead token as an internal (translated) token number. */ 1255 int yytoken = 0; 1256 #if YYERROR_VERBOSE 1257 /* Buffer for error messages, and its allocated size. */ 1258 char yymsgbuf[128]; 1259 char *yymsg = yymsgbuf; 1260 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 1261 #endif 1262 1263 /* Three stacks and their tools: 1264 `yyss': related to states, 1265 `yyvs': related to semantic values, 1266 `yyls': related to locations. 1267 1268 Refer to the stacks thru separate pointers, to allow yyoverflow 1269 to reallocate them elsewhere. */ 1270 1271 /* The state stack. */ 1272 yytype_int16 yyssa[YYINITDEPTH]; 1273 yytype_int16 *yyss = yyssa; 1274 yytype_int16 *yyssp; 1275 1276 /* The semantic value stack. */ 1277 YYSTYPE yyvsa[YYINITDEPTH]; 1278 YYSTYPE *yyvs = yyvsa; 1279 YYSTYPE *yyvsp; 1280 1281 1282 1283 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 1284 1285 YYSIZE_T yystacksize = YYINITDEPTH; 1286 1287 /* The variables used to return semantic value and location from the 1288 action routines. */ 1289 YYSTYPE yyval; 1290 1291 1292 /* The number of symbols on the RHS of the reduced rule. 1293 Keep to zero when no symbol should be popped. */ 1294 int yylen = 0; 1295 1296 YYDPRINTF ((stderr, "Starting parse\n")); 1297 1298 yystate = 0; 1299 yyerrstatus = 0; 1300 yynerrs = 0; 1301 yychar = YYEMPTY; /* Cause a token to be read. */ 1302 1303 /* Initialize stack pointers. 1304 Waste one element of value and location stack 1305 so that they stay on the same level as the state stack. 1306 The wasted elements are never initialized. */ 1307 1308 yyssp = yyss; 1309 yyvsp = yyvs; 1310 1311 goto yysetstate; 1312 1313 /*------------------------------------------------------------. 1314 | yynewstate -- Push a new state, which is found in yystate. | 1315 `------------------------------------------------------------*/ 1316 yynewstate: 1317 /* In all cases, when you get here, the value and location stacks 1318 have just been pushed. So pushing a state here evens the stacks. */ 1319 yyssp++; 1320 1321 yysetstate: 1322 *yyssp = yystate; 1323 1324 if (yyss + yystacksize - 1 <= yyssp) 1325 { 1326 /* Get the current used size of the three stacks, in elements. */ 1327 YYSIZE_T yysize = yyssp - yyss + 1; 1328 1329 #ifdef yyoverflow 1330 { 1331 /* Give user a chance to reallocate the stack. Use copies of 1332 these so that the &'s don't force the real ones into 1333 memory. */ 1334 YYSTYPE *yyvs1 = yyvs; 1335 yytype_int16 *yyss1 = yyss; 1336 1337 1338 /* Each stack pointer address is followed by the size of the 1339 data in use in that stack, in bytes. This used to be a 1340 conditional around just the two extra args, but that might 1341 be undefined if yyoverflow is a macro. */ 1342 yyoverflow (YY_("memory exhausted"), 1343 &yyss1, yysize * sizeof (*yyssp), 1344 &yyvs1, yysize * sizeof (*yyvsp), 1345 1346 &yystacksize); 1347 1348 yyss = yyss1; 1349 yyvs = yyvs1; 1350 } 1351 #else /* no yyoverflow */ 1352 # ifndef YYSTACK_RELOCATE 1353 goto yyexhaustedlab; 1354 # else 1355 /* Extend the stack our own way. */ 1356 if (YYMAXDEPTH <= yystacksize) 1357 goto yyexhaustedlab; 1358 yystacksize *= 2; 1359 if (YYMAXDEPTH < yystacksize) 1360 yystacksize = YYMAXDEPTH; 1361 1362 { 1363 yytype_int16 *yyss1 = yyss; 1364 union yyalloc *yyptr = 1365 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 1366 if (! yyptr) 1367 goto yyexhaustedlab; 1368 YYSTACK_RELOCATE (yyss); 1369 YYSTACK_RELOCATE (yyvs); 1370 1371 # undef YYSTACK_RELOCATE 1372 if (yyss1 != yyssa) 1373 YYSTACK_FREE (yyss1); 1374 } 1375 # endif 1376 #endif /* no yyoverflow */ 1377 1378 yyssp = yyss + yysize - 1; 1379 yyvsp = yyvs + yysize - 1; 1380 1381 1382 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 1383 (unsigned long int) yystacksize)); 1384 1385 if (yyss + yystacksize - 1 <= yyssp) 1386 YYABORT; 1387 } 1388 1389 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 1390 1391 goto yybackup; 1392 1393 /*-----------. 1394 | yybackup. | 1395 `-----------*/ 1396 yybackup: 1397 1398 /* Do appropriate processing given the current state. Read a 1399 look-ahead token if we need one and don't already have one. */ 1400 1401 /* First try to decide what to do without reference to look-ahead token. */ 1402 yyn = yypact[yystate]; 1403 if (yyn == YYPACT_NINF) 1404 goto yydefault; 1405 1406 /* Not known => get a look-ahead token if don't already have one. */ 1407 1408 /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */ 1409 if (yychar == YYEMPTY) 1410 { 1411 YYDPRINTF ((stderr, "Reading a token: ")); 1412 yychar = YYLEX; 1413 } 1414 1415 if (yychar <= YYEOF) 1416 { 1417 yychar = yytoken = YYEOF; 1418 YYDPRINTF ((stderr, "Now at end of input.\n")); 1419 } 1420 else 1421 { 1422 yytoken = YYTRANSLATE (yychar); 1423 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 1424 } 1425 1426 /* If the proper action on seeing token YYTOKEN is to reduce or to 1427 detect an error, take that action. */ 1428 yyn += yytoken; 1429 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 1430 goto yydefault; 1431 yyn = yytable[yyn]; 1432 if (yyn <= 0) 1433 { 1434 if (yyn == 0 || yyn == YYTABLE_NINF) 1435 goto yyerrlab; 1436 yyn = -yyn; 1437 goto yyreduce; 1438 } 1439 1440 if (yyn == YYFINAL) 1441 YYACCEPT; 1442 1443 /* Count tokens shifted since error; after three, turn off error 1444 status. */ 1445 if (yyerrstatus) 1446 yyerrstatus--; 1447 1448 /* Shift the look-ahead token. */ 1449 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 1450 1451 /* Discard the shifted token unless it is eof. */ 1452 if (yychar != YYEOF) 1453 yychar = YYEMPTY; 1454 1455 yystate = yyn; 1456 *++yyvsp = yylval; 1457 1458 goto yynewstate; 1459 1460 1461 /*-----------------------------------------------------------. 1462 | yydefault -- do the default action for the current state. | 1463 `-----------------------------------------------------------*/ 1464 yydefault: 1465 yyn = yydefact[yystate]; 1466 if (yyn == 0) 1467 goto yyerrlab; 1468 goto yyreduce; 1469 1470 1471 /*-----------------------------. 1472 | yyreduce -- Do a reduction. | 1473 `-----------------------------*/ 1474 yyreduce: 1475 /* yyn is the number of a rule to reduce with. */ 1476 yylen = yyr2[yyn]; 1477 1478 /* If YYLEN is nonzero, implement the default value of the action: 1479 `$$ = $1'. 1480 1481 Otherwise, the following line sets YYVAL to garbage. 1482 This behavior is undocumented and Bison 1483 users should not rely upon it. Assigning to YYVAL 1484 unconditionally makes the parser a bit smaller, and it avoids a 1485 GCC warning that YYVAL may be used uninitialized. */ 1486 yyval = yyvsp[1-yylen]; 1487 1488 1489 YY_REDUCE_PRINT (yyn); 1490 switch (yyn) 1491 { 1492 case 2: 1493 #line 145 "OSUnserializeXML.y" 1494 { yyerror("unexpected end of buffer"); 1495 YYERROR; 1496 ;} 1497 break; 1498 1499 case 3: 1500 #line 148 "OSUnserializeXML.y" 1501 { STATE->parsedObject = (yyvsp[(1) - (1)])->object; 1502 (yyvsp[(1) - (1)])->object = 0; 1503 freeObject(STATE, (yyvsp[(1) - (1)])); 1504 YYACCEPT; 1505 ;} 1506 break; 1507 1508 case 4: 1509 #line 153 "OSUnserializeXML.y" 1510 { yyerror("syntax error"); 1511 YYERROR; 1512 ;} 1513 break; 1514 1515 case 5: 1516 #line 158 "OSUnserializeXML.y" 1517 { (yyval) = buildDictionary(STATE, (yyvsp[(1) - (1)])); ;} 1518 break; 1519 1520 case 6: 1521 #line 159 "OSUnserializeXML.y" 1522 { (yyval) = buildArray(STATE, (yyvsp[(1) - (1)])); ;} 1523 break; 1524 1525 case 7: 1526 #line 160 "OSUnserializeXML.y" 1527 { (yyval) = buildSet(STATE, (yyvsp[(1) - (1)])); ;} 1528 break; 1529 1530 case 8: 1531 #line 161 "OSUnserializeXML.y" 1532 { (yyval) = buildString(STATE, (yyvsp[(1) - (1)])); ;} 1533 break; 1534 1535 case 9: 1536 #line 162 "OSUnserializeXML.y" 1537 { (yyval) = buildData(STATE, (yyvsp[(1) - (1)])); ;} 1538 break; 1539 1540 case 10: 1541 #line 163 "OSUnserializeXML.y" 1542 { (yyval) = buildNumber(STATE, (yyvsp[(1) - (1)])); ;} 1543 break; 1544 1545 case 11: 1546 #line 164 "OSUnserializeXML.y" 1547 { (yyval) = buildBoolean(STATE, (yyvsp[(1) - (1)])); ;} 1548 break; 1549 1550 case 12: 1551 #line 165 "OSUnserializeXML.y" 1552 { (yyval) = retrieveObject(STATE, (yyvsp[(1) - (1)])->idref); 1553 if ((yyval)) { 1554 (yyval)->object->retain(); 1555 } else { 1556 yyerror("forward reference detected"); 1557 YYERROR; 1558 } 1559 freeObject(STATE, (yyvsp[(1) - (1)])); 1560 ;} 1561 break; 1562 1563 case 13: 1564 #line 178 "OSUnserializeXML.y" 1565 { (yyval) = (yyvsp[(1) - (2)]); 1566 (yyval)->elements = NULL; 1567 ;} 1568 break; 1569 1570 case 14: 1571 #line 181 "OSUnserializeXML.y" 1572 { (yyval) = (yyvsp[(1) - (3)]); 1573 (yyval)->elements = (yyvsp[(2) - (3)]); 1574 ;} 1575 break; 1576 1577 case 17: 1578 #line 188 "OSUnserializeXML.y" 1579 { (yyval) = (yyvsp[(2) - (2)]); 1580 (yyval)->next = (yyvsp[(1) - (2)]); 1581 ;} 1582 break; 1583 1584 case 18: 1585 #line 193 "OSUnserializeXML.y" 1586 { (yyval) = (yyvsp[(1) - (2)]); 1587 (yyval)->key = (OSString *)(yyval)->object; 1588 (yyval)->object = (yyvsp[(2) - (2)])->object; 1589 (yyval)->next = NULL; 1590 (yyvsp[(2) - (2)])->object = 0; 1591 freeObject(STATE, (yyvsp[(2) - (2)])); 1592 ;} 1593 break; 1594 1595 case 19: 1596 #line 202 "OSUnserializeXML.y" 1597 { (yyval) = buildString(STATE, (yyvsp[(1) - (1)])); ;} 1598 break; 1599 1600 case 20: 1601 #line 207 "OSUnserializeXML.y" 1602 { (yyval) = (yyvsp[(1) - (2)]); 1603 (yyval)->elements = NULL; 1604 ;} 1605 break; 1606 1607 case 21: 1608 #line 210 "OSUnserializeXML.y" 1609 { (yyval) = (yyvsp[(1) - (3)]); 1610 (yyval)->elements = (yyvsp[(2) - (3)]); 1611 ;} 1612 break; 1613 1614 case 23: 1615 #line 216 "OSUnserializeXML.y" 1616 { (yyval) = (yyvsp[(1) - (2)]); 1617 (yyval)->elements = NULL; 1618 ;} 1619 break; 1620 1621 case 24: 1622 #line 219 "OSUnserializeXML.y" 1623 { (yyval) = (yyvsp[(1) - (3)]); 1624 (yyval)->elements = (yyvsp[(2) - (3)]); 1625 ;} 1626 break; 1627 1628 case 26: 1629 #line 225 "OSUnserializeXML.y" 1630 { (yyval) = (yyvsp[(1) - (1)]); 1631 (yyval)->next = NULL; 1632 ;} 1633 break; 1634 1635 case 27: 1636 #line 228 "OSUnserializeXML.y" 1637 { (yyval) = (yyvsp[(2) - (2)]); 1638 (yyval)->next = (yyvsp[(1) - (2)]); 1639 ;} 1640 break; 1641 1642 1643 /* Line 1267 of yacc.c. */ 1644 #line 1595 "OSUnserializeXML.tab.c" 1645 default: break; 1646 } 1647 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 1648 1649 YYPOPSTACK (yylen); 1650 yylen = 0; 1651 YY_STACK_PRINT (yyss, yyssp); 1652 1653 *++yyvsp = yyval; 1654 1655 1656 /* Now `shift' the result of the reduction. Determine what state 1657 that goes to, based on the state we popped back to and the rule 1658 number reduced by. */ 1659 1660 yyn = yyr1[yyn]; 1661 1662 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 1663 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 1664 yystate = yytable[yystate]; 1665 else 1666 yystate = yydefgoto[yyn - YYNTOKENS]; 1667 1668 goto yynewstate; 1669 1670 1671 /*------------------------------------. 1672 | yyerrlab -- here on detecting error | 1673 `------------------------------------*/ 1674 yyerrlab: 1675 /* If not already recovering from an error, report this error. */ 1676 if (!yyerrstatus) 1677 { 1678 ++yynerrs; 1679 #if ! YYERROR_VERBOSE 1680 yyerror (YY_("syntax error")); 1681 #else 1682 { 1683 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); 1684 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) 1685 { 1686 YYSIZE_T yyalloc = 2 * yysize; 1687 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) 1688 yyalloc = YYSTACK_ALLOC_MAXIMUM; 1689 if (yymsg != yymsgbuf) 1690 YYSTACK_FREE (yymsg); 1691 yymsg = (char *) YYSTACK_ALLOC (yyalloc); 1692 if (yymsg) 1693 yymsg_alloc = yyalloc; 1694 else 1695 { 1696 yymsg = yymsgbuf; 1697 yymsg_alloc = sizeof yymsgbuf; 1698 } 1699 } 1700 1701 if (0 < yysize && yysize <= yymsg_alloc) 1702 { 1703 (void) yysyntax_error (yymsg, yystate, yychar); 1704 yyerror (yymsg); 1705 } 1706 else 1707 { 1708 yyerror (YY_("syntax error")); 1709 if (yysize != 0) 1710 goto yyexhaustedlab; 1711 } 1712 } 1713 #endif 1714 } 1715 1716 1717 1718 if (yyerrstatus == 3) 1719 { 1720 /* If just tried and failed to reuse look-ahead token after an 1721 error, discard it. */ 1722 1723 if (yychar <= YYEOF) 1724 { 1725 /* Return failure if at end of input. */ 1726 if (yychar == YYEOF) 1727 YYABORT; 1728 } 1729 else 1730 { 1731 yydestruct ("Error: discarding", 1732 yytoken, &yylval); 1733 yychar = YYEMPTY; 1734 } 1735 } 1736 1737 /* Else will try to reuse look-ahead token after shifting the error 1738 token. */ 1739 goto yyerrlab1; 1740 1741 1742 /*---------------------------------------------------. 1743 | yyerrorlab -- error raised explicitly by YYERROR. | 1744 `---------------------------------------------------*/ 1745 yyerrorlab: 1746 1747 /* Pacify compilers like GCC when the user code never invokes 1748 YYERROR and the label yyerrorlab therefore never appears in user 1749 code. */ 1750 if (/*CONSTCOND*/ 0) 1751 goto yyerrorlab; 1752 1753 /* Do not reclaim the symbols of the rule which action triggered 1754 this YYERROR. */ 1755 YYPOPSTACK (yylen); 1756 yylen = 0; 1757 YY_STACK_PRINT (yyss, yyssp); 1758 yystate = *yyssp; 1759 goto yyerrlab1; 1760 1761 1762 /*-------------------------------------------------------------. 1763 | yyerrlab1 -- common code for both syntax error and YYERROR. | 1764 `-------------------------------------------------------------*/ 1765 yyerrlab1: 1766 yyerrstatus = 3; /* Each real token shifted decrements this. */ 1767 1768 for (;;) 1769 { 1770 yyn = yypact[yystate]; 1771 if (yyn != YYPACT_NINF) 1772 { 1773 yyn += YYTERROR; 1774 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 1775 { 1776 yyn = yytable[yyn]; 1777 if (0 < yyn) 1778 break; 1779 } 1780 } 1781 1782 /* Pop the current state because it cannot handle the error token. */ 1783 if (yyssp == yyss) 1784 YYABORT; 1785 1786 1787 yydestruct ("Error: popping", 1788 yystos[yystate], yyvsp); 1789 YYPOPSTACK (1); 1790 yystate = *yyssp; 1791 YY_STACK_PRINT (yyss, yyssp); 1792 } 1793 1794 if (yyn == YYFINAL) 1795 YYACCEPT; 1796 1797 *++yyvsp = yylval; 1798 1799 1800 /* Shift the error token. */ 1801 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 1802 1803 yystate = yyn; 1804 goto yynewstate; 1805 1806 1807 /*-------------------------------------. 1808 | yyacceptlab -- YYACCEPT comes here. | 1809 `-------------------------------------*/ 1810 yyacceptlab: 1811 yyresult = 0; 1812 goto yyreturn; 1813 1814 /*-----------------------------------. 1815 | yyabortlab -- YYABORT comes here. | 1816 `-----------------------------------*/ 1817 yyabortlab: 1818 yyresult = 1; 1819 goto yyreturn; 1820 1821 #ifndef yyoverflow 1822 /*-------------------------------------------------. 1823 | yyexhaustedlab -- memory exhaustion comes here. | 1824 `-------------------------------------------------*/ 1825 yyexhaustedlab: 1826 yyerror (YY_("memory exhausted")); 1827 yyresult = 2; 1828 /* Fall through. */ 1829 #endif 1830 1831 yyreturn: 1832 if (yychar != YYEOF && yychar != YYEMPTY) 1833 yydestruct ("Cleanup: discarding lookahead", 1834 yytoken, &yylval); 1835 /* Do not reclaim the symbols of the rule which action triggered 1836 this YYABORT or YYACCEPT. */ 1837 YYPOPSTACK (yylen); 1838 YY_STACK_PRINT (yyss, yyssp); 1839 while (yyssp != yyss) 1840 { 1841 yydestruct ("Cleanup: popping", 1842 yystos[*yyssp], yyvsp); 1843 YYPOPSTACK (1); 1844 } 1845 #ifndef yyoverflow 1846 if (yyss != yyssa) 1847 YYSTACK_FREE (yyss); 1848 #endif 1849 #if YYERROR_VERBOSE 1850 if (yymsg != yymsgbuf) 1851 YYSTACK_FREE (yymsg); 1852 #endif 1853 /* Make sure YYID is used. */ 1854 return YYID (yyresult); 1855 } 1856 1857 1858 #line 250 "OSUnserializeXML.y" 1859 1860 1861 int 1862 OSUnserializeerror(parser_state_t * state, const char *s) /* Called by yyparse on errors */ 1863 { 1864 if (state->errorString) { 1865 char tempString[128]; 1866 snprintf(tempString, 128, "OSUnserializeXML: %s near line %d\n", s, state->lineNumber); 1867 *(state->errorString) = OSString::withCString(tempString); 1868 } 1869 1870 return 0; 1871 } 1872 1873 #define TAG_MAX_LENGTH 32 1874 #define TAG_MAX_ATTRIBUTES 32 1875 #define TAG_BAD 0 1876 #define TAG_START 1 1877 #define TAG_END 2 1878 #define TAG_EMPTY 3 1879 #define TAG_IGNORE 4 1880 1881 #define currentChar() (state->parseBuffer[state->parseBufferIndex]) 1882 #define nextChar() (state->parseBuffer[++state->parseBufferIndex]) 1883 #define prevChar() (state->parseBuffer[state->parseBufferIndex - 1]) 1884 1885 #define isSpace(c) ((c) == ' ' || (c) == '\t') 1886 #define isAlpha(c) (((c) >= 'A' && (c) <= 'Z') || ((c) >= 'a' && (c) <= 'z')) 1887 #define isDigit(c) ((c) >= '0' && (c) <= '9') 1888 #define isAlphaDigit(c) ((c) >= 'a' && (c) <= 'f') 1889 #define isHexDigit(c) (isDigit(c) || isAlphaDigit(c)) 1890 #define isAlphaNumeric(c) (isAlpha(c) || isDigit(c) || ((c) == '-')) 1891 1892 static int 1893 getTag(parser_state_t *state, 1894 char tag[TAG_MAX_LENGTH], 1895 int *attributeCount, 1896 char attributes[TAG_MAX_ATTRIBUTES][TAG_MAX_LENGTH], 1897 char values[TAG_MAX_ATTRIBUTES][TAG_MAX_LENGTH] ) 1898 { 1899 int length = 0; 1900 int c = currentChar(); 1901 int tagType = TAG_START; 1902 1903 *attributeCount = 0; 1904 1905 if (c != '<') return TAG_BAD; 1906 c = nextChar(); // skip '<' 1907 1908 1909 // <!TAG declarations > 1910 // <!-- comments --> 1911 if (c == '!') { 1912 c = nextChar(); 1913 bool isComment = (c == '-') && ((c = nextChar()) != 0) && (c == '-'); 1914 if (!isComment && !isAlpha(c)) return TAG_BAD; // <!1, <!-A, <!eos 1915 1916 while (c && (c = nextChar()) != 0) { 1917 if (c == '\n') state->lineNumber++; 1918 if (isComment) { 1919 if (c != '-') continue; 1920 c = nextChar(); 1921 if (c != '-') continue; 1922 c = nextChar(); 1923 } 1924 if (c == '>') { 1925 (void)nextChar(); 1926 return TAG_IGNORE; 1927 } 1928 if (isComment) break; 1929 } 1930 return TAG_BAD; 1931 } 1932 1933 else 1934 1935 // <? Processing Instructions ?> 1936 if (c == '?') { 1937 while ((c = nextChar()) != 0) { 1938 if (c == '\n') state->lineNumber++; 1939 if (c != '?') continue; 1940 c = nextChar(); 1941 if (c == '>') { 1942 (void)nextChar(); 1943 return TAG_IGNORE; 1944 } 1945 } 1946 return TAG_BAD; 1947 } 1948 1949 else 1950 1951 // </ end tag > 1952 if (c == '/') { 1953 c = nextChar(); // skip '/' 1954 tagType = TAG_END; 1955 } 1956 if (!isAlpha(c)) return TAG_BAD; 1957 1958 /* find end of tag while copying it */ 1959 while (isAlphaNumeric(c)) { 1960 tag[length++] = c; 1961 c = nextChar(); 1962 if (length >= (TAG_MAX_LENGTH - 1)) return TAG_BAD; 1963 } 1964 1965 tag[length] = 0; 1966 1967 // printf("tag %s, type %d\n", tag, tagType); 1968 1969 // look for attributes of the form attribute = "value" ... 1970 while ((c != '>') && (c != '/')) { 1971 while (isSpace(c)) c = nextChar(); 1972 1973 length = 0; 1974 while (isAlphaNumeric(c)) { 1975 attributes[*attributeCount][length++] = c; 1976 if (length >= (TAG_MAX_LENGTH - 1)) return TAG_BAD; 1977 c = nextChar(); 1978 } 1979 attributes[*attributeCount][length] = 0; 1980 1981 while (isSpace(c)) c = nextChar(); 1982 1983 if (c != '=') return TAG_BAD; 1984 c = nextChar(); 1985 1986 while (isSpace(c)) c = nextChar(); 1987 1988 if (c != '"') return TAG_BAD; 1989 c = nextChar(); 1990 length = 0; 1991 while (c != '"') { 1992 values[*attributeCount][length++] = c; 1993 if (length >= (TAG_MAX_LENGTH - 1)) return TAG_BAD; 1994 c = nextChar(); 1995 } 1996 values[*attributeCount][length] = 0; 1997 1998 c = nextChar(); // skip closing quote 1999 2000 // printf(" attribute '%s' = '%s', nextchar = '%c'\n", 2001 // attributes[*attributeCount], values[*attributeCount], c); 2002 2003 (*attributeCount)++; 2004 if (*attributeCount >= TAG_MAX_ATTRIBUTES) return TAG_BAD; 2005 } 2006 2007 if (c == '/') { 2008 c = nextChar(); // skip '/' 2009 tagType = TAG_EMPTY; 2010 } 2011 if (c != '>') return TAG_BAD; 2012 c = nextChar(); // skip '>' 2013 2014 return tagType; 2015 } 2016 2017 static char * 2018 getString(parser_state_t *state) 2019 { 2020 int c = currentChar(); 2021 int start, length, i, j; 2022 char * tempString; 2023 2024 start = state->parseBufferIndex; 2025 /* find end of string */ 2026 2027 while (c != 0) { 2028 if (c == '\n') state->lineNumber++; 2029 if (c == '<') { 2030 break; 2031 } 2032 c = nextChar(); 2033 } 2034 2035 if (c != '<') return 0; 2036 2037 length = state->parseBufferIndex - start; 2038 2039 /* copy to null terminated buffer */ 2040 tempString = (char *)malloc(length + 1); 2041 if (tempString == 0) { 2042 printf("OSUnserializeXML: can't alloc temp memory\n"); 2043 goto error; 2044 } 2045 2046 // copy out string in tempString 2047 // "&" -> '&', "<" -> '<', ">" -> '>' 2048 2049 i = j = 0; 2050 while (i < length) { 2051 c = state->parseBuffer[start + i++]; 2052 if (c != '&') { 2053 tempString[j++] = c; 2054 } else { 2055 if ((i+3) > length) goto error; 2056 c = state->parseBuffer[start + i++]; 2057 if (c == 'l') { 2058 if (state->parseBuffer[start + i++] != 't') goto error; 2059 if (state->parseBuffer[start + i++] != ';') goto error; 2060 tempString[j++] = '<'; 2061 continue; 2062 } 2063 if (c == 'g') { 2064 if (state->parseBuffer[start + i++] != 't') goto error; 2065 if (state->parseBuffer[start + i++] != ';') goto error; 2066 tempString[j++] = '>'; 2067 continue; 2068 } 2069 if ((i+3) > length) goto error; 2070 if (c == 'a') { 2071 if (state->parseBuffer[start + i++] != 'm') goto error; 2072 if (state->parseBuffer[start + i++] != 'p') goto error; 2073 if (state->parseBuffer[start + i++] != ';') goto error; 2074 tempString[j++] = '&'; 2075 continue; 2076 } 2077 goto error; 2078 } 2079 } 2080 tempString[j] = 0; 2081 2082 // printf("string %s\n", tempString); 2083 2084 return tempString; 2085 2086 error: 2087 if (tempString) free(tempString); 2088 return 0; 2089 } 2090 2091 static long long 2092 getNumber(parser_state_t *state) 2093 { 2094 unsigned long long n = 0; 2095 int base = 10; 2096 bool negate = false; 2097 int c = currentChar(); 2098 2099 if (c == '0') { 2100 c = nextChar(); 2101 if (c == 'x') { 2102 base = 16; 2103 c = nextChar(); 2104 } 2105 } 2106 if (base == 10) { 2107 if (c == '-') { 2108 negate = true; 2109 c = nextChar(); 2110 } 2111 while(isDigit(c)) { 2112 n = (n * base + c - '0'); 2113 c = nextChar(); 2114 } 2115 if (negate) { 2116 n = (unsigned long long)((long long)n * (long long)-1); 2117 } 2118 } else { 2119 while(isHexDigit(c)) { 2120 if (isDigit(c)) { 2121 n = (n * base + c - '0'); 2122 } else { 2123 n = (n * base + 0xa + c - 'a'); 2124 } 2125 c = nextChar(); 2126 } 2127 } 2128 // printf("number 0x%x\n", (unsigned long)n); 2129 return n; 2130 } 2131 2132 // taken from CFXMLParsing/CFPropertyList.c 2133 2134 static const signed char __CFPLDataDecodeTable[128] = { 2135 /* 000 */ -1, -1, -1, -1, -1, -1, -1, -1, 2136 /* 010 */ -1, -1, -1, -1, -1, -1, -1, -1, 2137 /* 020 */ -1, -1, -1, -1, -1, -1, -1, -1, 2138 /* 030 */ -1, -1, -1, -1, -1, -1, -1, -1, 2139 /* ' ' */ -1, -1, -1, -1, -1, -1, -1, -1, 2140 /* '(' */ -1, -1, -1, 62, -1, -1, -1, 63, 2141 /* '0' */ 52, 53, 54, 55, 56, 57, 58, 59, 2142 /* '8' */ 60, 61, -1, -1, -1, 0, -1, -1, 2143 /* '@' */ -1, 0, 1, 2, 3, 4, 5, 6, 2144 /* 'H' */ 7, 8, 9, 10, 11, 12, 13, 14, 2145 /* 'P' */ 15, 16, 17, 18, 19, 20, 21, 22, 2146 /* 'X' */ 23, 24, 25, -1, -1, -1, -1, -1, 2147 /* '`' */ -1, 26, 27, 28, 29, 30, 31, 32, 2148 /* 'h' */ 33, 34, 35, 36, 37, 38, 39, 40, 2149 /* 'p' */ 41, 42, 43, 44, 45, 46, 47, 48, 2150 /* 'x' */ 49, 50, 51, -1, -1, -1, -1, -1 2151 }; 2152 2153 #define DATA_ALLOC_SIZE 4096 2154 2155 static void * 2156 getCFEncodedData(parser_state_t *state, unsigned int *size) 2157 { 2158 int numeq = 0, acc = 0, cntr = 0; 2159 int tmpbufpos = 0, tmpbuflen = 0; 2160 unsigned char *tmpbuf = (unsigned char *)malloc(DATA_ALLOC_SIZE); 2161 2162 int c = currentChar(); 2163 *size = 0; 2164 2165 while (c != '<') { 2166 c &= 0x7f; 2167 if (c == 0) { 2168 free(tmpbuf); 2169 return 0; 2170 } 2171 if (c == '=') numeq++; else numeq = 0; 2172 if (c == '\n') state->lineNumber++; 2173 if (__CFPLDataDecodeTable[c] < 0) { 2174 c = nextChar(); 2175 continue; 2176 } 2177 cntr++; 2178 acc <<= 6; 2179 acc += __CFPLDataDecodeTable[c]; 2180 if (0 == (cntr & 0x3)) { 2181 if (tmpbuflen <= tmpbufpos + 2) { 2182 tmpbuflen += DATA_ALLOC_SIZE; 2183 tmpbuf = (unsigned char *)realloc(tmpbuf, tmpbuflen); 2184 } 2185 tmpbuf[tmpbufpos++] = (acc >> 16) & 0xff; 2186 if (numeq < 2) 2187 tmpbuf[tmpbufpos++] = (acc >> 8) & 0xff; 2188 if (numeq < 1) 2189 tmpbuf[tmpbufpos++] = acc & 0xff; 2190 } 2191 c = nextChar(); 2192 } 2193 *size = tmpbufpos; 2194 if (*size == 0) { 2195 free(tmpbuf); 2196 return 0; 2197 } 2198 return tmpbuf; 2199 } 2200 2201 static void * 2202 getHexData(parser_state_t *state, unsigned int *size) 2203 { 2204 int c; 2205 unsigned char *d, *start, *lastStart; 2206 2207 start = lastStart = d = (unsigned char *)malloc(DATA_ALLOC_SIZE); 2208 c = currentChar(); 2209 2210 while (c != '<') { 2211 2212 if (isSpace(c)) while ((c = nextChar()) != 0 && isSpace(c)) {}; 2213 if (c == '\n') { 2214 state->lineNumber++; 2215 c = nextChar(); 2216 continue; 2217 } 2218 2219 // get high nibble 2220 if (isDigit(c)) { 2221 *d = (c - '0') << 4; 2222 } else if (isAlphaDigit(c)) { 2223 *d = (0xa + (c - 'a')) << 4; 2224 } else { 2225 goto error; 2226 } 2227 2228 // get low nibble 2229 c = nextChar(); 2230 if (isDigit(c)) { 2231 *d |= c - '0'; 2232 } else if (isAlphaDigit(c)) { 2233 *d |= 0xa + (c - 'a'); 2234 } else { 2235 goto error; 2236 } 2237 2238 d++; 2239 if ((d - lastStart) >= DATA_ALLOC_SIZE) { 2240 int oldsize = d - start; 2241 start = (unsigned char *)realloc(start, oldsize + DATA_ALLOC_SIZE); 2242 d = lastStart = start + oldsize; 2243 } 2244 c = nextChar(); 2245 } 2246 2247 *size = d - start; 2248 return start; 2249 2250 error: 2251 2252 *size = 0; 2253 free(start); 2254 return 0; 2255 } 2256 2257 static int 2258 yylex(YYSTYPE *lvalp, parser_state_t *state) 2259 { 2260 int c, i; 2261 int tagType; 2262 char tag[TAG_MAX_LENGTH]; 2263 int attributeCount; 2264 char attributes[TAG_MAX_ATTRIBUTES][TAG_MAX_LENGTH]; 2265 char values[TAG_MAX_ATTRIBUTES][TAG_MAX_LENGTH]; 2266 object_t *object; 2267 2268 top: 2269 c = currentChar(); 2270 2271 /* skip white space */ 2272 if (isSpace(c)) while ((c = nextChar()) != 0 && isSpace(c)) {}; 2273 2274 /* keep track of line number, don't return \n's */ 2275 if (c == '\n') { 2276 STATE->lineNumber++; 2277 (void)nextChar(); 2278 goto top; 2279 } 2280 2281 // end of the buffer? 2282 if (!c) return 0; 2283 2284 tagType = getTag(STATE, tag, &attributeCount, attributes, values); 2285 if (tagType == TAG_BAD) return SYNTAX_ERROR; 2286 if (tagType == TAG_IGNORE) goto top; 2287 2288 // handle allocation and check for "ID" and "IDREF" tags up front 2289 *lvalp = object = newObject(STATE); 2290 object->idref = -1; 2291 for (i=0; i < attributeCount; i++) { 2292 if (attributes[i][0] == 'I' && attributes[i][1] == 'D') { 2293 // check for idref's, note: we ignore the tag, for 2294 // this to work correctly, all idrefs must be unique 2295 // across the whole serialization 2296 if (attributes[i][2] == 'R' && attributes[i][3] == 'E' && 2297 attributes[i][4] == 'F' && !attributes[i][5]) { 2298 if (tagType != TAG_EMPTY) return SYNTAX_ERROR; 2299 object->idref = strtol(values[i], NULL, 0); 2300 return IDREF; 2301 } 2302 // check for id's 2303 if (!attributes[i][2]) { 2304 object->idref = strtol(values[i], NULL, 0); 2305 } else { 2306 return SYNTAX_ERROR; 2307 } 2308 } 2309 } 2310 2311 switch (*tag) { 2312 case 'a': 2313 if (!strcmp(tag, "array")) { 2314 if (tagType == TAG_EMPTY) { 2315 object->elements = NULL; 2316 return ARRAY; 2317 } 2318 return (tagType == TAG_START) ? '(' : ')'; 2319 } 2320 break; 2321 case 'd': 2322 if (!strcmp(tag, "dict")) { 2323 if (tagType == TAG_EMPTY) { 2324 object->elements = NULL; 2325 return DICTIONARY; 2326 } 2327 return (tagType == TAG_START) ? '{' : '}'; 2328 } 2329 if (!strcmp(tag, "data")) { 2330 unsigned int size; 2331 if (tagType == TAG_EMPTY) { 2332 object->data = NULL; 2333 object->size = 0; 2334 return DATA; 2335 } 2336 2337 bool isHexFormat = false; 2338 for (i=0; i < attributeCount; i++) { 2339 if (!strcmp(attributes[i], "format") && !strcmp(values[i], "hex")) { 2340 isHexFormat = true; 2341 break; 2342 } 2343 } 2344 // CF encoded is the default form 2345 if (isHexFormat) { 2346 object->data = getHexData(STATE, &size); 2347 } else { 2348 object->data = getCFEncodedData(STATE, &size); 2349 } 2350 object->size = size; 2351 if ((getTag(STATE, tag, &attributeCount, attributes, values) != TAG_END) || strcmp(tag, "data")) { 2352 return SYNTAX_ERROR; 2353 } 2354 return DATA; 2355 } 2356 break; 2357 case 'f': 2358 if (!strcmp(tag, "false")) { 2359 if (tagType == TAG_EMPTY) { 2360 object->number = 0; 2361 return BOOLEAN; 2362 } 2363 } 2364 break; 2365 case 'i': 2366 if (!strcmp(tag, "integer")) { 2367 object->size = 64; // default 2368 for (i=0; i < attributeCount; i++) { 2369 if (!strcmp(attributes[i], "size")) { 2370 object->size = strtoul(values[i], NULL, 0); 2371 } 2372 } 2373 if (tagType == TAG_EMPTY) { 2374 object->number = 0; 2375 return NUMBER; 2376 } 2377 object->number = getNumber(STATE); 2378 if ((getTag(STATE, tag, &attributeCount, attributes, values) != TAG_END) || strcmp(tag, "integer")) { 2379 return SYNTAX_ERROR; 2380 } 2381 return NUMBER; 2382 } 2383 break; 2384 case 'k': 2385 if (!strcmp(tag, "key")) { 2386 if (tagType == TAG_EMPTY) return SYNTAX_ERROR; 2387 object->string = getString(STATE); 2388 if (!object->string) { 2389 return SYNTAX_ERROR; 2390 } 2391 if ((getTag(STATE, tag, &attributeCount, attributes, values) != TAG_END) 2392 || strcmp(tag, "key")) { 2393 return SYNTAX_ERROR; 2394 } 2395 return KEY; 2396 } 2397 break; 2398 case 'p': 2399 if (!strcmp(tag, "plist")) { 2400 freeObject(STATE, object); 2401 goto top; 2402 } 2403 break; 2404 case 's': 2405 if (!strcmp(tag, "string")) { 2406 if (tagType == TAG_EMPTY) { 2407 object->string = (char *)malloc(1); 2408 object->string[0] = 0; 2409 return STRING; 2410 } 2411 object->string = getString(STATE); 2412 if (!object->string) { 2413 return SYNTAX_ERROR; 2414 } 2415 if ((getTag(STATE, tag, &attributeCount, attributes, values) != TAG_END) 2416 || strcmp(tag, "string")) { 2417 return SYNTAX_ERROR; 2418 } 2419 return STRING; 2420 } 2421 if (!strcmp(tag, "set")) { 2422 if (tagType == TAG_EMPTY) { 2423 object->elements = NULL; 2424 return SET;; 2425 } 2426 if (tagType == TAG_START) { 2427 return '['; 2428 } else { 2429 return ']'; 2430 } 2431 } 2432 break; 2433 case 't': 2434 if (!strcmp(tag, "true")) { 2435 if (tagType == TAG_EMPTY) { 2436 object->number = 1; 2437 return BOOLEAN; 2438 } 2439 } 2440 break; 2441 } 2442 2443 return SYNTAX_ERROR; 2444 } 2445 2446 // !@$&)(^Q$&*^!$(*!@$_(^%_(*Q#$(_*&!$_(*&!$_(*&!#$(*!@&^!@#%!_!# 2447 // !@$&)(^Q$&*^!$(*!@$_(^%_(*Q#$(_*&!$_(*&!$_(*&!#$(*!@&^!@#%!_!# 2448 // !@$&)(^Q$&*^!$(*!@$_(^%_(*Q#$(_*&!$_(*&!$_(*&!#$(*!@&^!@#%!_!# 2449 2450 // "java" like allocation, if this code hits a syntax error in the 2451 // the middle of the parsed string we just bail with pointers hanging 2452 // all over place, this code helps keeps it all together 2453 2454 //static int object_count = 0; 2455 2456 object_t * 2457 newObject(parser_state_t *state) 2458 { 2459 object_t *o; 2460 2461 if (state->freeObjects) { 2462 o = state->freeObjects; 2463 state->freeObjects = state->freeObjects->next; 2464 } else { 2465 o = (object_t *)malloc(sizeof(object_t)); 2466 // object_count++; 2467 bzero(o, sizeof(object_t)); 2468 o->free = state->objects; 2469 state->objects = o; 2470 } 2471 2472 return o; 2473 } 2474 2475 void 2476 freeObject(parser_state_t * state, object_t *o) 2477 { 2478 o->next = state->freeObjects; 2479 state->freeObjects = o; 2480 } 2481 2482 void 2483 cleanupObjects(parser_state_t *state) 2484 { 2485 object_t *t, *o = state->objects; 2486 2487 while (o) { 2488 if (o->object) { 2489 // printf("OSUnserializeXML: releasing object o=%x object=%x\n", (int)o, (int)o->object); 2490 o->object->release(); 2491 } 2492 if (o->data) { 2493 // printf("OSUnserializeXML: freeing object o=%x data=%x\n", (int)o, (int)o->data); 2494 free(o->data); 2495 } 2496 if (o->key) { 2497 // printf("OSUnserializeXML: releasing object o=%x key=%x\n", (int)o, (int)o->key); 2498 o->key->release(); 2499 } 2500 if (o->string) { 2501 // printf("OSUnserializeXML: freeing object o=%x string=%x\n", (int)o, (int)o->string); 2502 free(o->string); 2503 } 2504 2505 t = o; 2506 o = o->free; 2507 free(t); 2508 // object_count--; 2509 } 2510 // printf("object_count = %d\n", object_count); 2511 } 2512 2513 // !@$&)(^Q$&*^!$(*!@$_(^%_(*Q#$(_*&!$_(*&!$_(*&!#$(*!@&^!@#%!_!# 2514 // !@$&)(^Q$&*^!$(*!@$_(^%_(*Q#$(_*&!$_(*&!$_(*&!#$(*!@&^!@#%!_!# 2515 // !@$&)(^Q$&*^!$(*!@$_(^%_(*Q#$(_*&!$_(*&!$_(*&!#$(*!@&^!@#%!_!# 2516 2517 static void 2518 rememberObject(parser_state_t *state, int tag, OSObject *o) 2519 { 2520 char key[16]; 2521 snprintf(key, 16, "%u", tag); 2522 2523 // printf("remember key %s\n", key); 2524 2525 state->tags->setObject(key, o); 2526 } 2527 2528 static object_t * 2529 retrieveObject(parser_state_t *state, int tag) 2530 { 2531 OSObject *ref; 2532 object_t *o; 2533 char key[16]; 2534 snprintf(key, 16, "%u", tag); 2535 2536 // printf("retrieve key '%s'\n", key); 2537 2538 ref = state->tags->getObject(key); 2539 if (!ref) return 0; 2540 2541 o = newObject(state); 2542 o->object = ref; 2543 return o; 2544 } 2545 2546 // !@$&)(^Q$&*^!$(*!@$_(^%_(*Q#$(_*&!$_(*&!$_(*&!#$(*!@&^!@#%!_!# 2547 // !@$&)(^Q$&*^!$(*!@$_(^%_(*Q#$(_*&!$_(*&!$_(*&!#$(*!@&^!@#%!_!# 2548 // !@$&)(^Q$&*^!$(*!@$_(^%_(*Q#$(_*&!$_(*&!$_(*&!#$(*!@&^!@#%!_!# 2549 2550 object_t * 2551 buildDictionary(parser_state_t *state, object_t * header) 2552 { 2553 object_t *o, *t; 2554 int count = 0; 2555 OSDictionary *dict; 2556 2557 // get count and reverse order 2558 o = header->elements; 2559 header->elements = 0; 2560 while (o) { 2561 count++; 2562 t = o; 2563 o = o->next; 2564 2565 t->next = header->elements; 2566 header->elements = t; 2567 } 2568 2569 dict = OSDictionary::withCapacity(count); 2570 if (header->idref >= 0) rememberObject(state, header->idref, dict); 2571 2572 o = header->elements; 2573 while (o) { 2574 dict->setObject(o->key, o->object); 2575 2576 o->key->release(); 2577 o->object->release(); 2578 o->key = 0; 2579 o->object = 0; 2580 2581 t = o; 2582 o = o->next; 2583 freeObject(state, t); 2584 } 2585 o = header; 2586 o->object = dict; 2587 return o; 2588 }; 2589 2590 object_t * 2591 buildArray(parser_state_t *state, object_t * header) 2592 { 2593 object_t *o, *t; 2594 int count = 0; 2595 OSArray *array; 2596 2597 // get count and reverse order 2598 o = header->elements; 2599 header->elements = 0; 2600 while (o) { 2601 count++; 2602 t = o; 2603 o = o->next; 2604 2605 t->next = header->elements; 2606 header->elements = t; 2607 } 2608 2609 array = OSArray::withCapacity(count); 2610 if (header->idref >= 0) rememberObject(state, header->idref, array); 2611 2612 o = header->elements; 2613 while (o) { 2614 array->setObject(o->object); 2615 2616 o->object->release(); 2617 o->object = 0; 2618 2619 t = o; 2620 o = o->next; 2621 freeObject(state, t); 2622 } 2623 o = header; 2624 o->object = array; 2625 return o; 2626 }; 2627 2628 object_t * 2629 buildSet(parser_state_t *state, object_t *header) 2630 { 2631 object_t *o = buildArray(state, header); 2632 2633 OSArray *array = (OSArray *)o->object; 2634 OSSet *set = OSSet::withArray(array, array->getCapacity()); 2635 2636 // write over the reference created in buildArray 2637 if (header->idref >= 0) rememberObject(state, header->idref, set); 2638 2639 array->release(); 2640 o->object = set; 2641 return o; 2642 }; 2643 2644 object_t * 2645 buildString(parser_state_t *state, object_t *o) 2646 { 2647 OSString *string; 2648 2649 string = OSString::withCString(o->string); 2650 if (o->idref >= 0) rememberObject(state, o->idref, string); 2651 2652 free(o->string); 2653 o->string = 0; 2654 o->object = string; 2655 2656 return o; 2657 }; 2658 2659 object_t * 2660 buildData(parser_state_t *state, object_t *o) 2661 { 2662 OSData *data; 2663 2664 if (o->size) { 2665 data = OSData::withBytes(o->data, o->size); 2666 } else { 2667 data = OSData::withCapacity(0); 2668 } 2669 if (o->idref >= 0) rememberObject(state, o->idref, data); 2670 2671 if (o->size) free(o->data); 2672 o->data = 0; 2673 o->object = data; 2674 return o; 2675 }; 2676 2677 object_t * 2678 buildNumber(parser_state_t *state, object_t *o) 2679 { 2680 OSNumber *number = OSNumber::withNumber(o->number, o->size); 2681 2682 if (o->idref >= 0) rememberObject(state, o->idref, number); 2683 2684 o->object = number; 2685 return o; 2686 }; 2687 2688 object_t * 2689 buildBoolean(parser_state_t *state __unused, object_t *o) 2690 { 2691 o->object = ((o->number == 0) ? kOSBooleanFalse : kOSBooleanTrue); 2692 o->object->retain(); 2693 return o; 2694 }; 2695 2696 OSObject* 2697 OSUnserializeXML(const char *buffer, OSString **errorString) 2698 { 2699 OSObject *object; 2700 parser_state_t *state = (parser_state_t *)malloc(sizeof(parser_state_t)); 2701 2702 if ((!state) || (!buffer)) return 0; 2703 2704 // just in case 2705 if (errorString) *errorString = NULL; 2706 2707 state->parseBuffer = buffer; 2708 state->parseBufferIndex = 0; 2709 state->lineNumber = 1; 2710 state->objects = 0; 2711 state->freeObjects = 0; 2712 state->tags = OSDictionary::withCapacity(128); 2713 state->errorString = errorString; 2714 state->parsedObject = 0; 2715 2716 (void)yyparse((void *)state); 2717 2718 object = state->parsedObject; 2719 2720 cleanupObjects(state); 2721 state->tags->release(); 2722 free(state); 2723 2724 return object; 2725 } 2726 2727 2728 // 2729 // 2730 // 2731 // 2732 // 2733 // DO NOT EDIT OSUnserializeXML.cpp! 2734 // 2735 // this means you! 2736 // 2737 // 2738 // 2739 // 2740 // 2741 2742