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