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