]> git.saurik.com Git - apple/xnu.git/blob - libkern/c++/OSUnserialize.cpp
projects / apple / xnu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
xnu-1228.tar.gz
[apple/xnu.git] / libkern / c++ / OSUnserialize.cpp
1 /*
2 * Copyright (c) 2000-2006 Apple Computer, 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 /* OSUnserialize.y created by rsulack on Nov 21 1998 */
30
31 // "classic" parser for unserializing OSContainer objects
32 //
33 // XXX - this code should really be removed!
34 // - the XML format is now prefered
35 // - this code leaks on syntax errors, the XML doesn't
36 // - "classic" looks, reads, ... much better than XML :-(
37 // - well except the XML is more efficent on OSData
38 //
39 //
40 // to build :
41 // bison -p OSUnserialize OSUnserialize.y
42 // head -50 OSUnserialize.y > OSUnserialize.cpp
43 // sed -e "s/stdio.h/stddef.h/" < OSUnserialize.tab.c >> OSUnserialize.cpp
44 //
45 // when changing code check in both OSUnserialize.y and OSUnserialize.cpp
46 //
47 //
48 //
49 //
50 // DO NOT EDIT OSUnserialize.tab.cpp!
51 //
52 // this means you!
53 //
54 //
55 //
56 //
57
58 /* A Bison parser, made from OSUnserialize.y
59 by GNU Bison version 1.28 */
60
61 #define YYBISON 1 /* Identify Bison output. */
62
63 #define yyparse OSUnserializeparse
64 #define yylex OSUnserializelex
65 #define yyerror OSUnserializeerror
66 #define yylval OSUnserializelval
67 #define yychar OSUnserializechar
68 #define yydebug OSUnserializedebug
69 #define yynerrs OSUnserializenerrs
70 #define NUMBER 257
71 #define STRING 258
72 #define DATA 259
73 #define BOOLEAN 260
74 #define SYNTAX_ERROR 261
75
76 #line 54 "OSUnserialize.y"
77
78 #include <libkern/c++/OSMetaClass.h>
79 #include <libkern/c++/OSContainers.h>
80 #include <libkern/c++/OSLib.h>
81
82 typedef struct object {
83 struct object *next;
84 struct object *prev;
85 void *object;
86 int size; // for data
87 union {
88 void *key; // for dictionary
89 long long offset; // for offset
90 } u;
91
92 } object_t;
93
94 static int yyparse();
95 static int yyerror(char *s);
96 static int yylex();
97
98 static object_t * newObject();
99 static void freeObject(object_t *o);
100
101 static OSObject *buildOSDictionary(object_t *);
102 static OSObject *buildOSArray(object_t *);
103 static OSObject *buildOSSet(object_t *);
104 static OSObject *buildOSString(object_t *);
105 static OSObject *buildOSData(object_t *);
106 static OSObject *buildOSOffset(object_t *);
107 static OSObject *buildOSBoolean(object_t *o);
108
109 static void rememberObject(int, object_t *);
110 static OSObject *retrieveObject(int);
111
112 // temp variable to use during parsing
113 static object_t *o;
114
115 // resultant object of parsed text
116 static OSObject *parsedObject;
117
118 #define YYSTYPE object_t *
119
120 extern "C" {
121 extern void *kern_os_malloc(size_t size);
122 extern void *kern_os_realloc(void * addr, size_t size);
123 extern void kern_os_free(void * addr);
124 } /* extern "C" */
125
126 #define malloc(s) kern_os_malloc(s)
127 #define realloc(a, s) kern_os_realloc(a, s)
128 #define free(a) kern_os_free(a)
129
130 #ifndef YYSTYPE
131 #define YYSTYPE int
132 #endif
133
134 #ifndef __cplusplus
135 #ifndef __STDC__
136 #define const
137 #endif
138 #endif
139
140
141
142 #define YYFINAL 43
143 #define YYFLAG -32768
144 #define YYNTBASE 19
145
146 #define YYTRANSLATE(x) ((unsigned)(x) <= 261 ? yytranslate[x] : 31)
147
148 static const char yytranslate[] = { 0,
149 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
150 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
151 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
152 2, 2, 2, 2, 2, 2, 2, 2, 2, 13,
153 14, 2, 2, 17, 2, 2, 2, 2, 2, 2,
154 2, 2, 2, 2, 2, 2, 2, 18, 12, 2,
155 11, 2, 2, 8, 2, 2, 2, 2, 2, 2,
156 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
157 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
158 15, 2, 16, 2, 2, 2, 2, 2, 2, 2,
159 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
160 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
161 2, 2, 9, 2, 10, 2, 2, 2, 2, 2,
162 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
163 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
164 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
165 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
166 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
167 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
168 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
169 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
170 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
171 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
172 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
173 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
174 2, 2, 2, 2, 2, 1, 3, 4, 5, 6,
175 7
176 };
177
178 #if YYDEBUG != 0
179 static const short yyprhs[] = { 0,
180 0, 1, 3, 5, 7, 9, 11, 13, 15, 17,
181 19, 22, 26, 29, 33, 35, 38, 43, 46, 50,
182 53, 57, 59, 63, 67, 69, 71
183 };
184
185 static const short yyrhs[] = { -1,
186 20, 0, 7, 0, 21, 0, 24, 0, 25, 0,
187 29, 0, 28, 0, 27, 0, 30, 0, 8, 3,
188 0, 20, 8, 3, 0, 9, 10, 0, 9, 22,
189 10, 0, 23, 0, 22, 23, 0, 20, 11, 20,
190 12, 0, 13, 14, 0, 13, 26, 14, 0, 15,
191 16, 0, 15, 26, 16, 0, 20, 0, 26, 17,
192 20, 0, 3, 18, 3, 0, 5, 0, 4, 0,
193 6, 0
194 };
195
196 #endif
197
198 #if YYDEBUG != 0
199 static const short yyrline[] = { 0,
200 116, 117, 118, 121, 122, 123, 124, 125, 126, 127,
201 128, 137, 145, 146, 149, 150, 153, 163, 164, 167,
202 168, 171, 176, 187, 195, 200, 205
203 };
204 #endif
205
206
207 #if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
208
209 static const char * const yytname[] = { "$","error","$undefined.","NUMBER",
210 "STRING","DATA","BOOLEAN","SYNTAX_ERROR","'@'","'{'","'}'","'='","';'","'('",
211 "')'","'['","']'","','","':'","input","object","dict","pairs","pair","array",
212 "set","elements","offset","data","string","boolean", NULL
213 };
214 #endif
215
216 static const short yyr1[] = { 0,
217 19, 19, 19, 20, 20, 20, 20, 20, 20, 20,
218 20, 20, 21, 21, 22, 22, 23, 24, 24, 25,
219 25, 26, 26, 27, 28, 29, 30
220 };
221
222 static const short yyr2[] = { 0,
223 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,
224 2, 3, 2, 3, 1, 2, 4, 2, 3, 2,
225 3, 1, 3, 3, 1, 1, 1
226 };
227
228 static const short yydefact[] = { 1,
229 0, 26, 25, 27, 3, 0, 0, 0, 0, 2,
230 4, 5, 6, 9, 8, 7, 10, 0, 11, 13,
231 0, 0, 15, 18, 22, 0, 20, 0, 0, 24,
232 0, 14, 16, 19, 0, 21, 12, 0, 23, 17,
233 0, 0, 0
234 };
235
236 static const short yydefgoto[] = { 41,
237 21, 11, 22, 23, 12, 13, 26, 14, 15, 16,
238 17
239 };
240
241 static const short yypact[] = { 12,
242 -13,-32768,-32768,-32768,-32768, 9, 33, 46, -2, 2,
243 -32768,-32768,-32768,-32768,-32768,-32768,-32768, 25,-32768,-32768,
244 21, 59,-32768,-32768, 2, 16,-32768, 7, 31,-32768,
245 72,-32768,-32768,-32768, 72,-32768,-32768, 14, 2,-32768,
246 40, 44,-32768
247 };
248
249 static const short yypgoto[] = {-32768,
250 0,-32768,-32768, 23,-32768,-32768, 38,-32768,-32768,-32768,
251 -32768
252 };
253
254
255 #define YYLAST 87
256
257
258 static const short yytable[] = { 10,
259 1, 2, 3, 4, 18, 6, 7, 25, 25, 29,
260 8, 19, 9, 27, 1, 2, 3, 4, 5, 6,
261 7, 29, 36, 35, 8, 40, 9, 30, 29, 34,
262 38, 31, 35, 37, 39, 1, 2, 3, 4, 42,
263 6, 7, 20, 43, 33, 8, 28, 9, 1, 2,
264 3, 4, 0, 6, 7, 0, 0, 0, 8, 24,
265 9, 1, 2, 3, 4, 0, 6, 7, 32, 0,
266 0, 8, 0, 9, 1, 2, 3, 4, 0, 6,
267 7, 0, 0, 0, 8, 0, 9
268 };
269
270 static const short yycheck[] = { 0,
271 3, 4, 5, 6, 18, 8, 9, 8, 9, 8,
272 13, 3, 15, 16, 3, 4, 5, 6, 7, 8,
273 9, 8, 16, 17, 13, 12, 15, 3, 8, 14,
274 31, 11, 17, 3, 35, 3, 4, 5, 6, 0,
275 8, 9, 10, 0, 22, 13, 9, 15, 3, 4,
276 5, 6, -1, 8, 9, -1, -1, -1, 13, 14,
277 15, 3, 4, 5, 6, -1, 8, 9, 10, -1,
278 -1, 13, -1, 15, 3, 4, 5, 6, -1, 8,
279 9, -1, -1, -1, 13, -1, 15
280 };
281 /* -*-C-*- Note some compilers choke on comments on `#line' lines. */
282 #line 3 "/usr/share/bison.simple"
283 /* This file comes from bison-1.28. */
284
285 /* Skeleton output parser for bison,
286 Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
287
288 This program is free software; you can redistribute it and/or modify
289 it under the terms of the GNU General Public License as published by
290 the Free Software Foundation; either version 2, or (at your option)
291 any later version.
292
293 This program is distributed in the hope that it will be useful,
294 but WITHOUT ANY WARRANTY; without even the implied warranty of
295 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
296 GNU General Public License for more details.
297
298 You should have received a copy of the GNU General Public License
299 along with this program; if not, write to the Free Software
300 Foundation, Inc., 59 Temple Place - Suite 330,
301 Boston, MA 02111-1307, USA. */
302
303 /* As a special exception, when this file is copied by Bison into a
304 Bison output file, you may use that output file without restriction.
305 This special exception was added by the Free Software Foundation
306 in version 1.24 of Bison. */
307
308 /* This is the parser code that is written into each bison parser
309 when the %semantic_parser declaration is not specified in the grammar.
310 It was written by Richard Stallman by simplifying the hairy parser
311 used when %semantic_parser is specified. */
312
313 #ifndef YYSTACK_USE_ALLOCA
314 #ifdef alloca
315 #define YYSTACK_USE_ALLOCA
316 #else /* alloca not defined */
317 #ifdef __GNUC__
318 #define YYSTACK_USE_ALLOCA
319 #define alloca __builtin_alloca
320 #else /* not GNU C. */
321 #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386)) || defined (__arm)
322 #define YYSTACK_USE_ALLOCA
323 #include <alloca.h>
324 #else /* not sparc */
325 /* We think this test detects Watcom and Microsoft C. */
326 /* This used to test MSDOS, but that is a bad idea
327 since that symbol is in the user namespace. */
328 #if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)
329 #if 0 /* No need for malloc.h, which pollutes the namespace;
330 instead, just don't use alloca. */
331 #include <malloc.h>
332 #endif
333 #else /* not MSDOS, or __TURBOC__ */
334 #if defined(_AIX)
335 /* I don't know what this was needed for, but it pollutes the namespace.
336 So I turned it off. rms, 2 May 1997. */
337 /* #include <malloc.h> */
338 #pragma alloca
339 #define YYSTACK_USE_ALLOCA
340 #else /* not MSDOS, or __TURBOC__, or _AIX */
341 #if 0
342 #ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up,
343 and on HPUX 10. Eventually we can turn this on. */
344 #define YYSTACK_USE_ALLOCA
345 #define alloca __builtin_alloca
346 #endif /* __hpux */
347 #endif
348 #endif /* not _AIX */
349 #endif /* not MSDOS, or __TURBOC__ */
350 #endif /* not sparc */
351 #endif /* not GNU C */
352 #endif /* alloca not defined */
353 #endif /* YYSTACK_USE_ALLOCA not defined */
354
355 #ifdef YYSTACK_USE_ALLOCA
356 #define YYSTACK_ALLOC alloca
357 #else
358 #define YYSTACK_ALLOC malloc
359 #endif
360
361 /* Note: there must be only one dollar sign in this file.
362 It is replaced by the list of actions, each action
363 as one case of the switch. */
364
365 #define yyerrok (yyerrstatus = 0)
366 #define yyclearin (yychar = YYEMPTY)
367 #define YYEMPTY -2
368 #define YYEOF 0
369 #define YYACCEPT goto yyacceptlab
370 #define YYABORT goto yyabortlab
371 #define YYERROR goto yyerrlab1
372 /* Like YYERROR except do call yyerror.
373 This remains here temporarily to ease the
374 transition to the new meaning of YYERROR, for GCC.
375 Once GCC version 2 has supplanted version 1, this can go. */
376 #define YYFAIL goto yyerrlab
377 #define YYRECOVERING() (!!yyerrstatus)
378 #define YYBACKUP(token, value) \
379 do \
380 if (yychar == YYEMPTY && yylen == 1) \
381 { yychar = (token), yylval = (value); \
382 yychar1 = YYTRANSLATE (yychar); \
383 YYPOPSTACK; \
384 goto yybackup; \
385 } \
386 else \
387 { yyerror ("syntax error: cannot back up"); YYERROR; } \
388 while (0)
389
390 #define YYTERROR 1
391 #define YYERRCODE 256
392
393 #ifndef YYPURE
394 #define YYLEX yylex()
395 #endif
396
397 #ifdef YYPURE
398 #ifdef YYLSP_NEEDED
399 #ifdef YYLEX_PARAM
400 #define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM)
401 #else
402 #define YYLEX yylex(&yylval, &yylloc)
403 #endif
404 #else /* not YYLSP_NEEDED */
405 #ifdef YYLEX_PARAM
406 #define YYLEX yylex(&yylval, YYLEX_PARAM)
407 #else
408 #define YYLEX yylex(&yylval)
409 #endif
410 #endif /* not YYLSP_NEEDED */
411 #endif
412
413 /* If nonreentrant, generate the variables here */
414
415 #ifndef YYPURE
416
417 int yychar; /* the lookahead symbol */
418 YYSTYPE yylval; /* the semantic value of the */
419 /* lookahead symbol */
420
421 #ifdef YYLSP_NEEDED
422 YYLTYPE yylloc; /* location data for the lookahead */
423 /* symbol */
424 #endif
425
426 int yynerrs; /* number of parse errors so far */
427 #endif /* not YYPURE */
428
429 #if YYDEBUG != 0
430 int yydebug; /* nonzero means print parse trace */
431 /* Since this is uninitialized, it does not stop multiple parsers
432 from coexisting. */
433 #endif
434
435 /* YYINITDEPTH indicates the initial size of the parser's stacks */
436
437 #ifndef YYINITDEPTH
438 #define YYINITDEPTH 200
439 #endif
440
441 /* YYMAXDEPTH is the maximum size the stacks can grow to
442 (effective only if the built-in stack extension method is used). */
443
444 #if YYMAXDEPTH == 0
445 #undef YYMAXDEPTH
446 #endif
447
448 #ifndef YYMAXDEPTH
449 #define YYMAXDEPTH 10000
450 #endif
451 \f
452 /* Define __yy_memcpy. Note that the size argument
453 should be passed with type unsigned int, because that is what the non-GCC
454 definitions require. With GCC, __builtin_memcpy takes an arg
455 of type size_t, but it can handle unsigned int. */
456
457 #if __GNUC__ > 1 /* GNU C and GNU C++ define this. */
458 #define __yy_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT)
459 #else /* not GNU C or C++ */
460 #ifndef __cplusplus
461
462 /* This is the most reliable way to avoid incompatibilities
463 in available built-in functions on various systems. */
464 static void
465 __yy_memcpy (to, from, count)
466 char *to;
467 char *from;
468 unsigned int count;
469 {
470 register char *f = from;
471 register char *t = to;
472 register int i = count;
473
474 while (i-- > 0)
475 *t++ = *f++;
476 }
477
478 #else /* __cplusplus */
479
480 /* This is the most reliable way to avoid incompatibilities
481 in available built-in functions on various systems. */
482 static void
483 __yy_memcpy (char *to, char *from, unsigned int count)
484 {
485 register char *t = to;
486 register char *f = from;
487 register int i = count;
488
489 while (i-- > 0)
490 *t++ = *f++;
491 }
492
493 #endif
494 #endif
495 \f
496 #line 217 "/usr/share/bison.simple"
497
498 /* The user can define YYPARSE_PARAM as the name of an argument to be passed
499 into yyparse. The argument should have type void *.
500 It should actually point to an object.
501 Grammar actions can access the variable by casting it
502 to the proper pointer type. */
503
504 #ifdef YYPARSE_PARAM
505 #ifdef __cplusplus
506 #define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
507 #define YYPARSE_PARAM_DECL
508 #else /* not __cplusplus */
509 #define YYPARSE_PARAM_ARG YYPARSE_PARAM
510 #define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
511 #endif /* not __cplusplus */
512 #else /* not YYPARSE_PARAM */
513 #define YYPARSE_PARAM_ARG
514 #define YYPARSE_PARAM_DECL
515 #endif /* not YYPARSE_PARAM */
516
517 /* Prevent warning if -Wstrict-prototypes. */
518 #ifdef __GNUC__
519 #ifdef YYPARSE_PARAM
520 int yyparse (void *);
521 #else
522 int yyparse (void);
523 #endif
524 #endif
525
526 int
527 yyparse(YYPARSE_PARAM_ARG)
528 YYPARSE_PARAM_DECL
529 {
530 register int yystate;
531 register int yyn;
532 register short *yyssp;
533 register YYSTYPE *yyvsp;
534 int yyerrstatus; /* number of tokens to shift before error messages enabled */
535 int yychar1 = 0; /* lookahead token as an internal (translated) token number */
536
537 short yyssa[YYINITDEPTH]; /* the state stack */
538 YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */
539
540 short *yyss = yyssa; /* refer to the stacks thru separate pointers */
541 YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */
542
543 #ifdef YYLSP_NEEDED
544 YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */
545 YYLTYPE *yyls = yylsa;
546 YYLTYPE *yylsp;
547
548 #define YYPOPSTACK (yyvsp--, yyssp--, yylsp--)
549 #else
550 #define YYPOPSTACK (yyvsp--, yyssp--)
551 #endif
552
553 int yystacksize = YYINITDEPTH;
554 int yyfree_stacks = 0;
555
556 #ifdef YYPURE
557 int yychar;
558 YYSTYPE yylval;
559 int yynerrs;
560 #ifdef YYLSP_NEEDED
561 YYLTYPE yylloc;
562 #endif
563 #endif
564
565 YYSTYPE yyval; /* the variable used to return */
566 /* semantic values from the action */
567 /* routines */
568
569 int yylen;
570
571 #if YYDEBUG != 0
572 if (yydebug)
573 fprintf(stderr, "Starting parse\n");
574 #endif
575
576 yystate = 0;
577 yyerrstatus = 0;
578 yynerrs = 0;
579 yychar = YYEMPTY; /* Cause a token to be read. */
580
581 /* Initialize stack pointers.
582 Waste one element of value and location stack
583 so that they stay on the same level as the state stack.
584 The wasted elements are never initialized. */
585
586 yyssp = yyss - 1;
587 yyvsp = yyvs;
588 #ifdef YYLSP_NEEDED
589 yylsp = yyls;
590 #endif
591
592 /* Push a new state, which is found in yystate . */
593 /* In all cases, when you get here, the value and location stacks
594 have just been pushed. so pushing a state here evens the stacks. */
595 yynewstate:
596
597 *++yyssp = yystate;
598
599 if (yyssp >= yyss + yystacksize - 1)
600 {
601 /* Give user a chance to reallocate the stack */
602 /* Use copies of these so that the &'s don't force the real ones into memory. */
603 YYSTYPE *yyvs1 = yyvs;
604 short *yyss1 = yyss;
605 #ifdef YYLSP_NEEDED
606 YYLTYPE *yyls1 = yyls;
607 #endif
608
609 /* Get the current used size of the three stacks, in elements. */
610 int size = yyssp - yyss + 1;
611
612 #ifdef yyoverflow
613 /* Each stack pointer address is followed by the size of
614 the data in use in that stack, in bytes. */
615 #ifdef YYLSP_NEEDED
616 /* This used to be a conditional around just the two extra args,
617 but that might be undefined if yyoverflow is a macro. */
618 yyoverflow("parser stack overflow",
619 &yyss1, size * sizeof (*yyssp),
620 &yyvs1, size * sizeof (*yyvsp),
621 &yyls1, size * sizeof (*yylsp),
622 &yystacksize);
623 #else
624 yyoverflow("parser stack overflow",
625 &yyss1, size * sizeof (*yyssp),
626 &yyvs1, size * sizeof (*yyvsp),
627 &yystacksize);
628 #endif
629
630 yyss = yyss1; yyvs = yyvs1;
631 #ifdef YYLSP_NEEDED
632 yyls = yyls1;
633 #endif
634 #else /* no yyoverflow */
635 /* Extend the stack our own way. */
636 if (yystacksize >= YYMAXDEPTH)
637 {
638 yyerror("parser stack overflow");
639 if (yyfree_stacks)
640 {
641 free (yyss);
642 free (yyvs);
643 #ifdef YYLSP_NEEDED
644 free (yyls);
645 #endif
646 }
647 return 2;
648 }
649 yystacksize *= 2;
650 if (yystacksize > YYMAXDEPTH)
651 yystacksize = YYMAXDEPTH;
652 #ifndef YYSTACK_USE_ALLOCA
653 yyfree_stacks = 1;
654 #endif
655 yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));
656 __yy_memcpy ((char *)yyss, (char *)yyss1,
657 size * (unsigned int) sizeof (*yyssp));
658 yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));
659 __yy_memcpy ((char *)yyvs, (char *)yyvs1,
660 size * (unsigned int) sizeof (*yyvsp));
661 #ifdef YYLSP_NEEDED
662 yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));
663 __yy_memcpy ((char *)yyls, (char *)yyls1,
664 size * (unsigned int) sizeof (*yylsp));
665 #endif
666 #endif /* no yyoverflow */
667
668 yyssp = yyss + size - 1;
669 yyvsp = yyvs + size - 1;
670 #ifdef YYLSP_NEEDED
671 yylsp = yyls + size - 1;
672 #endif
673
674 #if YYDEBUG != 0
675 if (yydebug)
676 fprintf(stderr, "Stack size increased to %d\n", yystacksize);
677 #endif
678
679 if (yyssp >= yyss + yystacksize - 1)
680 YYABORT;
681 }
682
683 #if YYDEBUG != 0
684 if (yydebug)
685 fprintf(stderr, "Entering state %d\n", yystate);
686 #endif
687
688 goto yybackup;
689 yybackup:
690
691 /* Do appropriate processing given the current state. */
692 /* Read a lookahead token if we need one and don't already have one. */
693 /* yyresume: */
694
695 /* First try to decide what to do without reference to lookahead token. */
696
697 yyn = yypact[yystate];
698 if (yyn == YYFLAG)
699 goto yydefault;
700
701 /* Not known => get a lookahead token if don't already have one. */
702
703 /* yychar is either YYEMPTY or YYEOF
704 or a valid token in external form. */
705
706 if (yychar == YYEMPTY)
707 {
708 #if YYDEBUG != 0
709 if (yydebug)
710 fprintf(stderr, "Reading a token: ");
711 #endif
712 yychar = YYLEX;
713 }
714
715 /* Convert token to internal form (in yychar1) for indexing tables with */
716
717 if (yychar <= 0) /* This means end of input. */
718 {
719 yychar1 = 0;
720 yychar = YYEOF; /* Don't call YYLEX any more */
721
722 #if YYDEBUG != 0
723 if (yydebug)
724 fprintf(stderr, "Now at end of input.\n");
725 #endif
726 }
727 else
728 {
729 yychar1 = YYTRANSLATE(yychar);
730
731 #if YYDEBUG != 0
732 if (yydebug)
733 {
734 fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
735 /* Give the individual parser a way to print the precise meaning
736 of a token, for further debugging info. */
737 #ifdef YYPRINT
738 YYPRINT (stderr, yychar, yylval);
739 #endif
740 fprintf (stderr, ")\n");
741 }
742 #endif
743 }
744
745 yyn += yychar1;
746 if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
747 goto yydefault;
748
749 yyn = yytable[yyn];
750
751 /* yyn is what to do for this token type in this state.
752 Negative => reduce, -yyn is rule number.
753 Positive => shift, yyn is new state.
754 New state is final state => don't bother to shift,
755 just return success.
756 0, or most negative number => error. */
757
758 if (yyn < 0)
759 {
760 if (yyn == YYFLAG)
761 goto yyerrlab;
762 yyn = -yyn;
763 goto yyreduce;
764 }
765 else if (yyn == 0)
766 goto yyerrlab;
767
768 if (yyn == YYFINAL)
769 YYACCEPT;
770
771 /* Shift the lookahead token. */
772
773 #if YYDEBUG != 0
774 if (yydebug)
775 fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
776 #endif
777
778 /* Discard the token being shifted unless it is eof. */
779 if (yychar != YYEOF)
780 yychar = YYEMPTY;
781
782 *++yyvsp = yylval;
783 #ifdef YYLSP_NEEDED
784 *++yylsp = yylloc;
785 #endif
786
787 /* count tokens shifted since error; after three, turn off error status. */
788 if (yyerrstatus) yyerrstatus--;
789
790 yystate = yyn;
791 goto yynewstate;
792
793 /* Do the default action for the current state. */
794 yydefault:
795
796 yyn = yydefact[yystate];
797 if (yyn == 0)
798 goto yyerrlab;
799
800 /* Do a reduction. yyn is the number of a rule to reduce with. */
801 yyreduce:
802 yylen = yyr2[yyn];
803 if (yylen > 0)
804 yyval = yyvsp[1-yylen]; /* implement default value of the action */
805
806 #if YYDEBUG != 0
807 if (yydebug)
808 {
809 int i;
810
811 fprintf (stderr, "Reducing via rule %d (line %d), ",
812 yyn, yyrline[yyn]);
813
814 /* Print the symbols being reduced, and their result. */
815 for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
816 fprintf (stderr, "%s ", yytname[yyrhs[i]]);
817 fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
818 }
819 #endif
820
821
822 switch (yyn) {
823
824 case 1:
825 #line 116 "OSUnserialize.y"
826 { parsedObject = (OSObject *)NULL; YYACCEPT; ;
827 break;}
828 case 2:
829 #line 117 "OSUnserialize.y"
830 { parsedObject = (OSObject *)yyvsp[0]; YYACCEPT; ;
831 break;}
832 case 3:
833 #line 118 "OSUnserialize.y"
834 { yyerror("syntax error"); YYERROR; ;
835 break;}
836 case 4:
837 #line 121 "OSUnserialize.y"
838 { yyval = (object_t *)buildOSDictionary(yyvsp[0]); ;
839 break;}
840 case 5:
841 #line 122 "OSUnserialize.y"
842 { yyval = (object_t *)buildOSArray(yyvsp[0]); ;
843 break;}
844 case 6:
845 #line 123 "OSUnserialize.y"
846 { yyval = (object_t *)buildOSSet(yyvsp[0]); ;
847 break;}
848 case 7:
849 #line 124 "OSUnserialize.y"
850 { yyval = (object_t *)buildOSString(yyvsp[0]); ;
851 break;}
852 case 8:
853 #line 125 "OSUnserialize.y"
854 { yyval = (object_t *)buildOSData(yyvsp[0]); ;
855 break;}
856 case 9:
857 #line 126 "OSUnserialize.y"
858 { yyval = (object_t *)buildOSOffset(yyvsp[0]); ;
859 break;}
860 case 10:
861 #line 127 "OSUnserialize.y"
862 { yyval = (object_t *)buildOSBoolean(yyvsp[0]); ;
863 break;}
864 case 11:
865 #line 128 "OSUnserialize.y"
866 { yyval = (object_t *)retrieveObject(yyvsp[0]->u.offset);
867 if (yyval) {
868 ((OSObject *)yyval)->retain();
869 } else {
870 yyerror("forward reference detected");
871 YYERROR;
872 }
873 freeObject(yyvsp[0]);
874 ;
875 break;}
876 case 12:
877 #line 137 "OSUnserialize.y"
878 { yyval = yyvsp[-2];
879 rememberObject(yyvsp[0]->u.offset, yyvsp[-2]);
880 freeObject(yyvsp[0]);
881 ;
882 break;}
883 case 13:
884 #line 145 "OSUnserialize.y"
885 { yyval = NULL; ;
886 break;}
887 case 14:
888 #line 146 "OSUnserialize.y"
889 { yyval = yyvsp[-1]; ;
890 break;}
891 case 16:
892 #line 150 "OSUnserialize.y"
893 { yyvsp[0]->next = yyvsp[-1]; yyvsp[-1]->prev = yyvsp[0]; yyval = yyvsp[0]; ;
894 break;}
895 case 17:
896 #line 153 "OSUnserialize.y"
897 { yyval = newObject();
898 yyval->next = NULL;
899 yyval->prev = NULL;
900 yyval->u.key = yyvsp[-3];
901 yyval->object = yyvsp[-1];
902 ;
903 break;}
904 case 18:
905 #line 163 "OSUnserialize.y"
906 { yyval = NULL; ;
907 break;}
908 case 19:
909 #line 164 "OSUnserialize.y"
910 { yyval = yyvsp[-1]; ;
911 break;}
912 case 20:
913 #line 167 "OSUnserialize.y"
914 { yyval = NULL; ;
915 break;}
916 case 21:
917 #line 168 "OSUnserialize.y"
918 { yyval = yyvsp[-1]; ;
919 break;}
920 case 22:
921 #line 171 "OSUnserialize.y"
922 { yyval = newObject();
923 yyval->object = yyvsp[0];
924 yyval->next = NULL;
925 yyval->prev = NULL;
926 ;
927 break;}
928 case 23:
929 #line 176 "OSUnserialize.y"
930 { o = newObject();
931 o->object = yyvsp[0];
932 o->next = yyvsp[-2];
933 o->prev = NULL;
934 yyvsp[-2]->prev = o;
935 yyval = o;
936 ;
937 break;}
938 case 24:
939 #line 187 "OSUnserialize.y"
940 { yyval = yyvsp[-2];
941 yyval->size = yyvsp[0]->u.offset;
942 freeObject(yyvsp[0]);
943 ;
944 break;}
945 }
946 /* the action file gets copied in in place of this dollarsign */
947 #line 543 "/usr/share/bison.simple"
948 \f
949 yyvsp -= yylen;
950 yyssp -= yylen;
951 #ifdef YYLSP_NEEDED
952 yylsp -= yylen;
953 #endif
954
955 #if YYDEBUG != 0
956 if (yydebug)
957 {
958 short *ssp1 = yyss - 1;
959 fprintf (stderr, "state stack now");
960 while (ssp1 != yyssp)
961 fprintf (stderr, " %d", *++ssp1);
962 fprintf (stderr, "\n");
963 }
964 #endif
965
966 *++yyvsp = yyval;
967
968 #ifdef YYLSP_NEEDED
969 yylsp++;
970 if (yylen == 0)
971 {
972 yylsp->first_line = yylloc.first_line;
973 yylsp->first_column = yylloc.first_column;
974 yylsp->last_line = (yylsp-1)->last_line;
975 yylsp->last_column = (yylsp-1)->last_column;
976 yylsp->text = 0;
977 }
978 else
979 {
980 yylsp->last_line = (yylsp+yylen-1)->last_line;
981 yylsp->last_column = (yylsp+yylen-1)->last_column;
982 }
983 #endif
984
985 /* Now "shift" the result of the reduction.
986 Determine what state that goes to,
987 based on the state we popped back to
988 and the rule number reduced by. */
989
990 yyn = yyr1[yyn];
991
992 yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
993 if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
994 yystate = yytable[yystate];
995 else
996 yystate = yydefgoto[yyn - YYNTBASE];
997
998 goto yynewstate;
999
1000 yyerrlab: /* here on detecting error */
1001
1002 if (! yyerrstatus)
1003 /* If not already recovering from an error, report this error. */
1004 {
1005 ++yynerrs;
1006
1007 #ifdef YYERROR_VERBOSE
1008 yyn = yypact[yystate];
1009
1010 if (yyn > YYFLAG && yyn < YYLAST)
1011 {
1012 int size = 0;
1013 char *msg;
1014 int x, count, len;
1015
1016 count = 0;
1017 /* Start X at -yyn if nec to avoid negative indexes in yycheck. */
1018 for (x = (yyn < 0 ? -yyn : 0);
1019 x < (sizeof(yytname) / sizeof(char *)); x++)
1020 if (yycheck[x + yyn] == x)
1021 size += strlen(yytname[x]) + 15, count++;
1022 len = size + 15;
1023 msg = (char *) malloc(len);
1024 if (msg != 0)
1025 {
1026 strlcpy(msg, "parse error", len);
1027
1028 if (count < 5)
1029 {
1030 count = 0;
1031 for (x = (yyn < 0 ? -yyn : 0);
1032 x < (sizeof(yytname) / sizeof(char *)); x++)
1033 if (yycheck[x + yyn] == x)
1034 {
1035 strlcat(msg, count == 0 ? ", expecting `" : " or `",
1036 len);
1037 strlcat(msg, yytname[x], len);
1038 strlcat(msg, "'", len);
1039 count++;
1040 }
1041 }
1042 yyerror(msg);
1043 free(msg);
1044 }
1045 else
1046 yyerror ("parse error; also virtual memory exceeded");
1047 }
1048 else
1049 #endif /* YYERROR_VERBOSE */
1050 yyerror("parse error");
1051 }
1052
1053 goto yyerrlab1;
1054 yyerrlab1: /* here on error raised explicitly by an action */
1055
1056 if (yyerrstatus == 3)
1057 {
1058 /* if just tried and failed to reuse lookahead token after an error, discard it. */
1059
1060 /* return failure if at end of input */
1061 if (yychar == YYEOF)
1062 YYABORT;
1063
1064 #if YYDEBUG != 0
1065 if (yydebug)
1066 fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
1067 #endif
1068
1069 yychar = YYEMPTY;
1070 }
1071
1072 /* Else will try to reuse lookahead token
1073 after shifting the error token. */
1074
1075 yyerrstatus = 3; /* Each real token shifted decrements this */
1076
1077 goto yyerrhandle;
1078
1079 yyerrdefault: /* current state does not do anything special for the error token. */
1080
1081 #if 0
1082 /* This is wrong; only states that explicitly want error tokens
1083 should shift them. */
1084 yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/
1085 if (yyn) goto yydefault;
1086 #endif
1087
1088 yyerrpop: /* pop the current state because it cannot handle the error token */
1089
1090 if (yyssp == yyss) YYABORT;
1091 yyvsp--;
1092 yystate = *--yyssp;
1093 #ifdef YYLSP_NEEDED
1094 yylsp--;
1095 #endif
1096
1097 #if YYDEBUG != 0
1098 if (yydebug)
1099 {
1100 short *ssp1 = yyss - 1;
1101 fprintf (stderr, "Error: state stack now");
1102 while (ssp1 != yyssp)
1103 fprintf (stderr, " %d", *++ssp1);
1104 fprintf (stderr, "\n");
1105 }
1106 #endif
1107
1108 yyerrhandle:
1109
1110 yyn = yypact[yystate];
1111 if (yyn == YYFLAG)
1112 goto yyerrdefault;
1113
1114 yyn += YYTERROR;
1115 if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
1116 goto yyerrdefault;
1117
1118 yyn = yytable[yyn];
1119 if (yyn < 0)
1120 {
1121 if (yyn == YYFLAG)
1122 goto yyerrpop;
1123 yyn = -yyn;
1124 goto yyreduce;
1125 }
1126 else if (yyn == 0)
1127 goto yyerrpop;
1128
1129 if (yyn == YYFINAL)
1130 YYACCEPT;
1131
1132 #if YYDEBUG != 0
1133 if (yydebug)
1134 fprintf(stderr, "Shifting error token, ");
1135 #endif
1136
1137 *++yyvsp = yylval;
1138 #ifdef YYLSP_NEEDED
1139 *++yylsp = yylloc;
1140 #endif
1141
1142 yystate = yyn;
1143 goto yynewstate;
1144
1145 yyacceptlab:
1146 /* YYACCEPT comes here. */
1147 if (yyfree_stacks)
1148 {
1149 free (yyss);
1150 free (yyvs);
1151 #ifdef YYLSP_NEEDED
1152 free (yyls);
1153 #endif
1154 }
1155 return 0;
1156
1157 yyabortlab:
1158 /* YYABORT comes here. */
1159 if (yyfree_stacks)
1160 {
1161 free (yyss);
1162 free (yyvs);
1163 #ifdef YYLSP_NEEDED
1164 free (yyls);
1165 #endif
1166 }
1167 return 1;
1168 }
1169 #line 208 "OSUnserialize.y"
1170
1171
1172 static int lineNumber = 0;
1173 static const char *parseBuffer;
1174 static int parseBufferIndex;
1175
1176 #define currentChar() (parseBuffer[parseBufferIndex])
1177 #define nextChar() (parseBuffer[++parseBufferIndex])
1178 #define prevChar() (parseBuffer[parseBufferIndex - 1])
1179
1180 #define isSpace(c) ((c) == ' ' || (c) == '\t')
1181 #define isAlpha(c) (((c) >= 'A' && (c) <= 'Z') || ((c) >= 'a' && (c) <= 'z'))
1182 #define isDigit(c) ((c) >= '0' && (c) <= '9')
1183 #define isAlphaDigit(c) ((c) >= 'a' && (c) <= 'f')
1184 #define isHexDigit(c) (isDigit(c) || isAlphaDigit(c))
1185 #define isAlphaNumeric(c) (isAlpha(c) || isDigit(c) || ((c) == '-'))
1186
1187 static char yyerror_message[128];
1188
1189 int
1190 yyerror(char *s) /* Called by yyparse on error */
1191 {
1192 sprintf(yyerror_message, "OSUnserialize: %s near line %d\n", s, lineNumber);
1193 return 0;
1194 }
1195
1196 int
1197 yylex()
1198 {
1199 int c;
1200
1201 if (parseBufferIndex == 0) lineNumber = 1;
1202
1203 top:
1204 c = currentChar();
1205
1206 /* skip white space */
1207 if (isSpace(c)) while ((c = nextChar()) != 0 && isSpace(c)) {};
1208
1209 /* skip over comments */
1210 if (c == '#') while ((c = nextChar()) != 0 && c != '\n') {};
1211
1212 /* keep track of line number, don't return \n's */
1213 if (c == '\n') {
1214 lineNumber++;
1215 (void)nextChar();
1216 goto top;
1217 }
1218
1219 /* parse boolean */
1220 if (c == '.') {
1221 bool boolean = false;
1222 if (nextChar() == 't') {
1223 if (nextChar() != 'r') return SYNTAX_ERROR;
1224 if (nextChar() != 'u') return SYNTAX_ERROR;
1225 if (nextChar() != 'e') return SYNTAX_ERROR;
1226 boolean = true;
1227 } else {
1228 if (currentChar() != 'f') return SYNTAX_ERROR;
1229 if (nextChar() != 'a') return SYNTAX_ERROR;
1230 if (nextChar() != 'l') return SYNTAX_ERROR;
1231 if (nextChar() != 's') return SYNTAX_ERROR;
1232 if (nextChar() != 'e') return SYNTAX_ERROR;
1233 }
1234 if (nextChar() != '.') return SYNTAX_ERROR;
1235 /* skip over dot */
1236 (void)nextChar();
1237
1238 yylval = (object_t *)boolean;
1239 return BOOLEAN;
1240 }
1241
1242 /* parse unquoted string */
1243 if (isAlpha(c)) {
1244 int start, length;
1245 char * tempString;
1246
1247 start = parseBufferIndex;
1248 /* find end of string */
1249 while (isAlphaNumeric(c)) {
1250 c = nextChar();
1251 }
1252 length = parseBufferIndex - start;
1253
1254 /* copy to null terminated buffer */
1255 tempString = (char *)malloc(length + 1);
1256 if (tempString == 0) {
1257 printf("OSUnserialize: can't alloc temp memory\n");
1258 return 0;
1259 }
1260 bcopy(&parseBuffer[start], tempString, length);
1261 tempString[length] = 0;
1262 yylval = (object_t *)tempString;
1263 return STRING;
1264 }
1265
1266 /* parse quoted string */
1267 if (c == '"' || c == '\'') {
1268 int start, length;
1269 char * tempString;
1270 char quoteChar = c;
1271
1272 start = parseBufferIndex + 1; // skip quote
1273 /* find end of string, line, buffer */
1274 while ((c = nextChar()) != quoteChar) {
1275 if (c == '\\') c = nextChar();
1276 if (c == '\n') lineNumber++;
1277 if (c == 0) return SYNTAX_ERROR;
1278 }
1279 length = parseBufferIndex - start;
1280 /* skip over trailing quote */
1281 (void)nextChar();
1282 /* copy to null terminated buffer */
1283 tempString = (char *)malloc(length + 1);
1284 if (tempString == 0) {
1285 printf("OSUnserialize: can't alloc temp memory\n");
1286 return 0;
1287 }
1288
1289 int to = 0;
1290 for (int from=start; from < parseBufferIndex; from++) {
1291 // hack - skip over backslashes
1292 if (parseBuffer[from] == '\\') {
1293 length--;
1294 continue;
1295 }
1296 tempString[to] = parseBuffer[from];
1297 to++;
1298 }
1299 tempString[length] = 0;
1300 yylval = (object_t *)tempString;
1301 return STRING;
1302 }
1303
1304 /* process numbers */
1305 if (isDigit (c))
1306 {
1307 unsigned long long n = 0;
1308 int base = 10;
1309
1310 if (c == '0') {
1311 c = nextChar();
1312 if (c == 'x') {
1313 base = 16;
1314 c = nextChar();
1315 }
1316 }
1317 if (base == 10) {
1318 while(isDigit(c)) {
1319 n = (n * base + c - '0');
1320 c = nextChar();
1321 }
1322 } else {
1323 while(isHexDigit(c)) {
1324 if (isDigit(c)) {
1325 n = (n * base + c - '0');
1326 } else {
1327 n = (n * base + 0xa + c - 'a');
1328 }
1329 c = nextChar();
1330 }
1331 }
1332
1333 yylval = newObject();
1334 yylval->u.offset = n;
1335
1336 return NUMBER;
1337 }
1338
1339 #define OSDATA_ALLOC_SIZE 4096
1340
1341 /* process data */
1342 if (c == '<') {
1343 unsigned char *d, *start, *lastStart;
1344
1345 start = lastStart = d = (unsigned char *)malloc(OSDATA_ALLOC_SIZE);
1346 c = nextChar(); // skip over '<'
1347 while (c != 0 && c != '>') {
1348
1349 if (isSpace(c)) while ((c = nextChar()) != 0 && isSpace(c)) {};
1350 if (c == '#') while ((c = nextChar()) != 0 && c != '\n') {};
1351 if (c == '\n') {
1352 lineNumber++;
1353 c = nextChar();
1354 continue;
1355 }
1356
1357 // get high nibble
1358 if (!isHexDigit(c)) break;
1359 if (isDigit(c)) {
1360 *d = (c - '0') << 4;
1361 } else {
1362 *d = (0xa + (c - 'a')) << 4;
1363 }
1364
1365 // get low nibble
1366 c = nextChar();
1367 if (!isHexDigit(c)) break;
1368 if (isDigit(c)) {
1369 *d |= c - '0';
1370 } else {
1371 *d |= 0xa + (c - 'a');
1372 }
1373
1374 d++;
1375 if ((d - lastStart) >= OSDATA_ALLOC_SIZE) {
1376 int oldsize = d - start;
1377 start = (unsigned char *)realloc(start, oldsize + OSDATA_ALLOC_SIZE);
1378 d = lastStart = start + oldsize;
1379 }
1380 c = nextChar();
1381 }
1382 if (c != '>' ) {
1383 free(start);
1384 return SYNTAX_ERROR;
1385 }
1386
1387 // got it!
1388 yylval = newObject();
1389 yylval->object = start;
1390 yylval->size = d - start;
1391
1392 (void)nextChar(); // skip over '>'
1393 return DATA;
1394 }
1395
1396
1397 /* return single chars, move pointer to next char */
1398 (void)nextChar();
1399 return c;
1400 }
1401
1402 // !@$&)(^Q$&*^!$(*!@$_(^%_(*Q#$(_*&!$_(*&!$_(*&!#$(*!@&^!@#%!_!#
1403 // !@$&)(^Q$&*^!$(*!@$_(^%_(*Q#$(_*&!$_(*&!$_(*&!#$(*!@&^!@#%!_!#
1404 // !@$&)(^Q$&*^!$(*!@$_(^%_(*Q#$(_*&!$_(*&!$_(*&!#$(*!@&^!@#%!_!#
1405
1406 #ifdef DEBUG
1407 int debugUnserializeAllocCount = 0;
1408 #endif
1409
1410 object_t *
1411 newObject()
1412 {
1413 #ifdef DEBUG
1414 debugUnserializeAllocCount++;
1415 #endif
1416 return (object_t *)malloc(sizeof(object_t));
1417 }
1418
1419 void
1420 freeObject(object_t *o)
1421 {
1422 #ifdef DEBUG
1423 debugUnserializeAllocCount--;
1424 #endif
1425 free(o);
1426 }
1427
1428 static OSDictionary *tags;
1429
1430 static void
1431 rememberObject(int tag, object_t *o)
1432 {
1433 char key[16];
1434 sprintf(key, "%u", tag);
1435
1436 tags->setObject(key, (OSObject *)o);
1437 }
1438
1439 static OSObject *
1440 retrieveObject(int tag)
1441 {
1442 char key[16];
1443 sprintf(key, "%u", tag);
1444
1445 return tags->getObject(key);
1446 }
1447
1448 OSObject *
1449 buildOSDictionary(object_t *o)
1450 {
1451 object_t *temp, *last = o;
1452 int count = 0;
1453
1454 // get count and last object
1455 while (o) {
1456 count++;
1457 last = o;
1458 o = o->next;
1459 }
1460 o = last;
1461
1462 OSDictionary *d = OSDictionary::withCapacity(count);
1463
1464 while (o) {
1465 #ifdef metaclass_stuff_worksXXX
1466 if (((OSObject *)o->u.key)->metaCast("OSSymbol")) {
1467 // XXX the evil frontdoor
1468 d->setObject((OSSymbol *)o->u.key, (OSObject *)o->object);
1469 } else {
1470 // If it isn't a symbol, I hope it's a string!
1471 d->setObject((OSString *)o->u.key, (OSObject *)o->object);
1472 }
1473 #else
1474 d->setObject((OSString *)o->u.key, (OSObject *)o->object);
1475 #endif
1476 ((OSObject *)o->object)->release();
1477 ((OSObject *)o->u.key)->release();
1478 temp = o;
1479 o = o->prev;
1480 freeObject(temp);
1481 }
1482 return d;
1483 };
1484
1485 OSObject *
1486 buildOSArray(object_t *o)
1487 {
1488 object_t *temp, *last = o;
1489 int count = 0;
1490
1491 // get count and last object
1492 while (o) {
1493 count++;
1494 last = o;
1495 o = o->next;
1496 }
1497 o = last;
1498
1499 OSArray *a = OSArray::withCapacity(count);
1500
1501 while (o) {
1502 a->setObject((OSObject *)o->object);
1503 ((OSObject *)o->object)->release();
1504 temp = o;
1505 o = o->prev;
1506 freeObject(temp);
1507 }
1508 return a;
1509 };
1510
1511 OSObject *
1512 buildOSSet(object_t *o)
1513 {
1514 OSArray *a = (OSArray *)buildOSArray(o);
1515 OSSet *s = OSSet::withArray(a, a->getCapacity());
1516
1517 a->release();
1518 return s;
1519 };
1520
1521 OSObject *
1522 buildOSString(object_t *o)
1523 {
1524 OSString *s = OSString::withCString((char *)o);
1525
1526 free(o);
1527
1528 return s;
1529 };
1530
1531 OSObject *
1532 buildOSData(object_t *o)
1533 {
1534 OSData *d;
1535
1536 if (o->size) {
1537 d = OSData::withBytes(o->object, o->size);
1538 } else {
1539 d = OSData::withCapacity(0);
1540 }
1541 free(o->object);
1542 freeObject(o);
1543 return d;
1544 };
1545
1546 OSObject *
1547 buildOSOffset(object_t *o)
1548 {
1549 OSNumber *off = OSNumber::withNumber(o->u.offset, o->size);
1550 freeObject(o);
1551 return off;
1552 };
1553
1554 OSObject *
1555 buildOSBoolean(object_t *o)
1556 {
1557 OSBoolean *b = OSBoolean::withBoolean((bool)o);
1558 return b;
1559 };
1560
1561 __BEGIN_DECLS
1562 #include <kern/lock.h>
1563 __END_DECLS
1564
1565 static mutex_t *lock = 0;
1566
1567 OSObject*
1568 OSUnserialize(const char *buffer, OSString **errorString)
1569 {
1570 OSObject *object;
1571
1572 if (!lock) {
1573 lock = mutex_alloc(0);
1574 mutex_lock(lock);
1575 } else {
1576 mutex_lock(lock);
1577
1578 }
1579
1580 #ifdef DEBUG
1581 debugUnserializeAllocCount = 0;
1582 #endif
1583 yyerror_message[0] = 0; //just in case
1584 parseBuffer = buffer;
1585 parseBufferIndex = 0;
1586 tags = OSDictionary::withCapacity(128);
1587 if (yyparse() == 0) {
1588 object = parsedObject;
1589 if (errorString) *errorString = 0;
1590 } else {
1591 object = 0;
1592 if (errorString)
1593 *errorString = OSString::withCString(yyerror_message);
1594 }
1595
1596 tags->release();
1597 #ifdef DEBUG
1598 if (debugUnserializeAllocCount) {
1599 printf("OSUnserialize: allocation check failed, count = %d.\n",
1600 debugUnserializeAllocCount);
1601 }
1602 #endif
1603 mutex_unlock(lock);
1604
1605 return object;
1606 }
1607
1608
1609 //
1610 //
1611 //
1612 //
1613 //
1614 // DO NOT EDIT OSUnserialize.cpp!
1615 //
1616 // this means you!
1617 //
1618 //
1619 //
1620 //
1621 //
mirror of XNU