![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to OSUnserializeXML.y 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 OSUnserializeXML.y CVS log | Up to [Apple XNU] / XNU / libkern / c++ |
1.1 ! root 1: /* ! 2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * The contents of this file constitute Original Code as defined in and ! 7: * are subject to the Apple Public Source License Version 1.1 (the ! 8: * "License"). You may not use this file except in compliance with the ! 9: * License. Please obtain a copy of the License at ! 10: * http://www.apple.com/publicsource and read it before using this file. ! 11: * ! 12: * This Original Code and all software distributed under the License are ! 13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 17: * License for the specific language governing rights and limitations ! 18: * under the License. ! 19: * ! 20: * @APPLE_LICENSE_HEADER_END@ ! 21: */ ! 22: ! 23: /* OSUnserializeXML.y created by rsulack on Tue Oct 12 1999 */ ! 24: ! 25: // XML parser for unserializing OSContainer objects ! 26: // ! 27: // to build : ! 28: // bison -p OSUnserializeXML OSUnserializeXML.y ! 29: // sed -e "s/stdio.h/stddef.h/" < OSUnserializeXML.tab.c > OSUnserializeXML.cpp ! 30: // ! 31: // when changing code check in both OSUnserializeXML.y and OSUnserializeXML.cpp ! 32: // ! 33: // ! 34: // ! 35: // ! 36: // ! 37: // ! 38: // ! 39: // DO NOT EDIT OSUnserializeXML.cpp! ! 40: // ! 41: // this means you! ! 42: // ! 43: // ! 44: // ! 45: // ! 46: // ! 47: ! 48: ! 49: %{ ! 50: #include <string.h> ! 51: #include <libkern/c++/OSMetaClass.h> ! 52: #include <libkern/c++/OSContainers.h> ! 53: #include <libkern/c++/OSLib.h> ! 54: ! 55: typedef struct object { ! 56: struct object *next; ! 57: struct object *free; ! 58: struct object *elements; ! 59: OSObject *object; ! 60: const OSSymbol *key; // for dictionary ! 61: int size; ! 62: void *data; // for data ! 63: char *string; // for string & symbol ! 64: long long number; // for number ! 65: int idref; ! 66: } object_t; ! 67: ! 68: static int yyparse(); ! 69: static int yyerror(char *s); ! 70: static int yylex(); ! 71: ! 72: static object_t * newObject(); ! 73: static void freeObject(object_t *o); ! 74: ! 75: static object_t *buildOSDictionary(object_t *); ! 76: static object_t *buildOSArray(object_t *); ! 77: static object_t *buildOSSet(object_t *); ! 78: static object_t *buildOSString(object_t *); ! 79: static object_t *buildKey(object_t *); ! 80: static object_t *buildOSData(object_t *); ! 81: static object_t *buildOSNumber(object_t *); ! 82: static object_t *buildOSBoolean(object_t *o); ! 83: ! 84: static void rememberObject(int, OSObject *); ! 85: static object_t *retrieveObject(int); ! 86: ! 87: // resultant object of parsed text ! 88: static OSObject *parsedObject; ! 89: ! 90: #define YYSTYPE object_t * ! 91: ! 92: extern "C" { ! 93: extern void *kern_os_malloc(size_t size); ! 94: extern void *kern_os_realloc(void * addr, size_t size); ! 95: extern void kern_os_free(void * addr); ! 96: ! 97: //XXX shouldn't have to define these ! 98: extern long strtol(const char *, char **, int); ! 99: extern unsigned long strtoul(const char *, char **, int); ! 100: ! 101: } /* extern "C" */ ! 102: ! 103: #define malloc(s) kern_os_malloc(s) ! 104: #define realloc(a, s) kern_os_realloc(a, s) ! 105: #define free(a) kern_os_free(a) ! 106: ! 107: %} ! 108: %token KEY ! 109: %token NUMBER ! 110: %token STRING ! 111: %token DATA ! 112: %token IDREF ! 113: %token BOOLEAN ! 114: %token SYNTAX_ERROR ! 115: %% /* Grammar rules and actions follow */ ! 116: ! 117: input: /* empty */ { parsedObject = (OSObject *)NULL; YYACCEPT; } ! 118: | object { parsedObject = $1->object; ! 119: $1->object = 0; ! 120: freeObject($1); ! 121: YYACCEPT; ! 122: } ! 123: | SYNTAX_ERROR { ! 124: yyerror("syntax error"); ! 125: YYERROR; ! 126: } ! 127: ; ! 128: ! 129: object: dict { $$ = buildOSDictionary($1); } ! 130: | array { $$ = buildOSArray($1); } ! 131: | set { $$ = buildOSSet($1); } ! 132: | string { $$ = buildOSString($1); } ! 133: | data { $$ = buildOSData($1); } ! 134: | number { $$ = buildOSNumber($1); } ! 135: | boolean { $$ = buildOSBoolean($1); } ! 136: | idref { $$ = retrieveObject($1->idref); ! 137: if ($$) { ! 138: $$->object->retain(); ! 139: } else { ! 140: yyerror("forward reference detected"); ! 141: YYERROR; ! 142: } ! 143: freeObject($1); ! 144: } ! 145: ; ! 146: ! 147: //------------------------------------------------------------------------------ ! 148: ! 149: dict: '{' '}' { $$ = $1; ! 150: $$->elements = NULL; ! 151: } ! 152: | '{' pairs '}' { $$ = $1; ! 153: $$->elements = $2; ! 154: } ! 155: ; ! 156: ! 157: pairs: pair ! 158: | pairs pair { $$ = $2; ! 159: $$->next = $1; ! 160: } ! 161: ; ! 162: ! 163: pair: key object { $$ = $1; ! 164: $$->next = NULL; ! 165: $$->object = $2->object; ! 166: $2->object = 0; ! 167: freeObject($2); ! 168: } ! 169: ; ! 170: ! 171: key: KEY { $$ = buildKey($1); } ! 172: ; ! 173: ! 174: //------------------------------------------------------------------------------ ! 175: ! 176: array: '(' ')' { $$ = $1; ! 177: $$->elements = NULL; ! 178: } ! 179: | '(' elements ')' { $$ = $1; ! 180: $$->elements = $2; ! 181: } ! 182: ; ! 183: ! 184: set: '[' ']' { $$ = $1; ! 185: $$->elements = NULL; ! 186: } ! 187: | '[' elements ']' { $$ = $1; ! 188: $$->elements = $2; ! 189: } ! 190: ; ! 191: ! 192: elements: object { $$ = $1; ! 193: $$->next = NULL; ! 194: } ! 195: | elements object { $$ = $2; ! 196: $$->next = $1; ! 197: } ! 198: ; ! 199: ! 200: //------------------------------------------------------------------------------ ! 201: ! 202: number: NUMBER ! 203: ; ! 204: ! 205: data: DATA ! 206: ; ! 207: ! 208: string: STRING ! 209: ; ! 210: ! 211: idref: IDREF ! 212: ; ! 213: ! 214: boolean: BOOLEAN ! 215: ; ! 216: ! 217: %% ! 218: ! 219: static int lineNumber = 0; ! 220: static const char *parseBuffer; ! 221: static int parseBufferIndex; ! 222: ! 223: #define currentChar() (parseBuffer[parseBufferIndex]) ! 224: #define nextChar() (parseBuffer[++parseBufferIndex]) ! 225: #define prevChar() (parseBuffer[parseBufferIndex - 1]) ! 226: ! 227: #define isSpace(c) ((c) == ' ' || (c) == '\t') ! 228: #define isAlpha(c) (((c) >= 'A' && (c) <= 'Z') || ((c) >= 'a' && (c) <= 'z')) ! 229: #define isDigit(c) ((c) >= '0' && (c) <= '9') ! 230: #define isAlphaDigit(c) ((c) >= 'a' && (c) <= 'f') ! 231: #define isHexDigit(c) (isDigit(c) || isAlphaDigit(c)) ! 232: #define isAlphaNumeric(c) (isAlpha(c) || isDigit(c) || ((c) == '-')) ! 233: ! 234: static char yyerror_message[128]; ! 235: ! 236: int ! 237: yyerror(char *s) /* Called by yyparse on error */ ! 238: { ! 239: sprintf(yyerror_message, "OSUnserializeXML: %s near line %d\n", s, lineNumber); ! 240: return 0; ! 241: } ! 242: ! 243: #define TAG_MAX_LENGTH 32 ! 244: #define TAG_MAX_ATTRIBUTES 32 ! 245: #define TAG_BAD 0 ! 246: #define TAG_START 1 ! 247: #define TAG_END 2 ! 248: #define TAG_EMPTY 3 ! 249: #define TAG_COMMENT 4 ! 250: ! 251: static int ! 252: getTag(char tag[TAG_MAX_LENGTH], ! 253: int *attributeCount, ! 254: char attributes[TAG_MAX_ATTRIBUTES][TAG_MAX_LENGTH], ! 255: char values[TAG_MAX_ATTRIBUTES][TAG_MAX_LENGTH] ) ! 256: { ! 257: int length = 0;; ! 258: int c = currentChar(); ! 259: int tagType = TAG_START; ! 260: ! 261: *attributeCount = 0; ! 262: ! 263: if (c != '<') return TAG_BAD; ! 264: c = nextChar(); // skip '<' ! 265: ! 266: if (c == '?' || c == '!') { ! 267: while ((c = nextChar()) != 0) { ! 268: if (c == '\n') lineNumber++; ! 269: if (c == '>') { ! 270: (void)nextChar(); ! 271: return TAG_COMMENT; ! 272: } ! 273: } ! 274: } ! 275: ! 276: if (c == '/') { ! 277: c = nextChar(); // skip '/' ! 278: tagType = TAG_END; ! 279: } ! 280: if (!isAlpha(c)) return TAG_BAD; ! 281: ! 282: /* find end of tag while copying it */ ! 283: while (isAlphaNumeric(c)) { ! 284: tag[length++] = c; ! 285: c = nextChar(); ! 286: if (length >= (TAG_MAX_LENGTH - 1)) return TAG_BAD; ! 287: } ! 288: ! 289: tag[length] = 0; ! 290: ! 291: //printf("tag %s, type %d\n", tag, tagType); ! 292: ! 293: // look for attributes of the form attribute = "value" ... ! 294: while ((c != '>') && (c != '/')) { ! 295: while (isSpace(c)) c = nextChar(); ! 296: ! 297: length = 0; ! 298: while (isAlphaNumeric(c)) { ! 299: attributes[*attributeCount][length++] = c; ! 300: if (length >= (TAG_MAX_LENGTH - 1)) return TAG_BAD; ! 301: c = nextChar(); ! 302: } ! 303: attributes[*attributeCount][length] = 0; ! 304: ! 305: while (isSpace(c)) c = nextChar(); ! 306: ! 307: if (c != '=') return TAG_BAD; ! 308: c = nextChar(); ! 309: ! 310: while (isSpace(c)) c = nextChar(); ! 311: ! 312: if (c != '"') return TAG_BAD; ! 313: c = nextChar(); ! 314: length = 0; ! 315: while (c != '"') { ! 316: values[*attributeCount][length++] = c; ! 317: if (length >= (TAG_MAX_LENGTH - 1)) return TAG_BAD; ! 318: c = nextChar(); ! 319: } ! 320: values[*attributeCount][length] = 0; ! 321: ! 322: c = nextChar(); // skip closing quote ! 323: ! 324: //printf(" attribute '%s' = '%s', nextchar = '%c'\n", attributes[*attributeCount], values[*attributeCount], c); ! 325: ! 326: (*attributeCount)++; ! 327: if (*attributeCount >= TAG_MAX_ATTRIBUTES) return TAG_BAD; ! 328: } ! 329: ! 330: if (c == '/') { ! 331: c = nextChar(); // skip '/' ! 332: tagType = TAG_EMPTY; ! 333: } ! 334: if (c != '>') return TAG_BAD; ! 335: c = nextChar(); // skip '>' ! 336: ! 337: return tagType; ! 338: } ! 339: ! 340: static char * ! 341: getString() ! 342: { ! 343: int c = currentChar(); ! 344: ! 345: int start, length, i, j;; ! 346: char * tempString; ! 347: ! 348: start = parseBufferIndex; ! 349: /* find end of string */ ! 350: ! 351: while (c != 0) { ! 352: if (c == '\n') lineNumber++; ! 353: if (c == '<') { ! 354: break; ! 355: } ! 356: c = nextChar(); ! 357: } ! 358: ! 359: if (c != '<') return 0; ! 360: ! 361: length = parseBufferIndex - start; ! 362: ! 363: /* copy to null terminated buffer */ ! 364: tempString = (char *)malloc(length + 1); ! 365: if (tempString == 0) { ! 366: printf("OSUnserializeXML: can't alloc temp memory\n"); ! 367: return 0; ! 368: } ! 369: ! 370: // copy out string in tempString ! 371: // "&" -> '&', "<" -> '<', ">" -> '>' ! 372: ! 373: i = j = 0; ! 374: while (i < length) { ! 375: c = parseBuffer[start + i++]; ! 376: if (c != '&') { ! 377: tempString[j++] = c; ! 378: } else { ! 379: if ((i+3) > length) goto error; ! 380: c = parseBuffer[start + i++]; ! 381: if (c == 'l') { ! 382: if (parseBuffer[start + i++] != 't') goto error; ! 383: if (parseBuffer[start + i++] != ';') goto error; ! 384: tempString[j++] = '<'; ! 385: continue; ! 386: } ! 387: if (c == 'g') { ! 388: if (parseBuffer[start + i++] != 't') goto error; ! 389: if (parseBuffer[start + i++] != ';') goto error; ! 390: tempString[j++] = '>'; ! 391: continue; ! 392: } ! 393: if ((i+3) > length) goto error; ! 394: if (c == 'a') { ! 395: if (parseBuffer[start + i++] != 'm') goto error; ! 396: if (parseBuffer[start + i++] != 'p') goto error; ! 397: if (parseBuffer[start + i++] != ';') goto error; ! 398: tempString[j++] = '&'; ! 399: continue; ! 400: } ! 401: goto error; ! 402: } ! 403: } ! 404: tempString[j] = 0; ! 405: ! 406: //printf("string %s\n", tempString); ! 407: ! 408: return tempString; ! 409: ! 410: error: ! 411: if (tempString) free(tempString); ! 412: return 0; ! 413: } ! 414: ! 415: static long long ! 416: getNumber() ! 417: { ! 418: unsigned long long n = 0; ! 419: int base = 10; ! 420: int c = currentChar(); ! 421: ! 422: if (!isDigit (c)) return 0; ! 423: ! 424: if (c == '0') { ! 425: c = nextChar(); ! 426: if (c == 'x') { ! 427: base = 16; ! 428: c = nextChar(); ! 429: } ! 430: } ! 431: if (base == 10) { ! 432: while(isDigit(c)) { ! 433: n = (n * base + c - '0'); ! 434: c = nextChar(); ! 435: } ! 436: } else { ! 437: while(isHexDigit(c)) { ! 438: if (isDigit(c)) { ! 439: n = (n * base + c - '0'); ! 440: } else { ! 441: n = (n * base + 0xa + c - 'a'); ! 442: } ! 443: c = nextChar(); ! 444: } ! 445: } ! 446: //printf("number 0x%x\n", (unsigned long)n); ! 447: return n; ! 448: } ! 449: ! 450: // taken from CFXMLParsing/CFPropertyList.c ! 451: ! 452: static const signed char __CFPLDataDecodeTable[128] = { ! 453: /* 000 */ -1, -1, -1, -1, -1, -1, -1, -1, ! 454: /* 010 */ -1, -1, -1, -1, -1, -1, -1, -1, ! 455: /* 020 */ -1, -1, -1, -1, -1, -1, -1, -1, ! 456: /* 030 */ -1, -1, -1, -1, -1, -1, -1, -1, ! 457: /* ' ' */ -1, -1, -1, -1, -1, -1, -1, -1, ! 458: /* '(' */ -1, -1, -1, 62, -1, -1, -1, 63, ! 459: /* '0' */ 52, 53, 54, 55, 56, 57, 58, 59, ! 460: /* '8' */ 60, 61, -1, -1, -1, 0, -1, -1, ! 461: /* '@' */ -1, 0, 1, 2, 3, 4, 5, 6, ! 462: /* 'H' */ 7, 8, 9, 10, 11, 12, 13, 14, ! 463: /* 'P' */ 15, 16, 17, 18, 19, 20, 21, 22, ! 464: /* 'X' */ 23, 24, 25, -1, -1, -1, -1, -1, ! 465: /* '`' */ -1, 26, 27, 28, 29, 30, 31, 32, ! 466: /* 'h' */ 33, 34, 35, 36, 37, 38, 39, 40, ! 467: /* 'p' */ 41, 42, 43, 44, 45, 46, 47, 48, ! 468: /* 'x' */ 49, 50, 51, -1, -1, -1, -1, -1 ! 469: }; ! 470: ! 471: #define OSDATA_ALLOC_SIZE 4096 ! 472: ! 473: static void * ! 474: getData(unsigned int *size) ! 475: { ! 476: int numeq = 0, acc = 0, cntr = 0; ! 477: int tmpbufpos = 0, tmpbuflen = 0; ! 478: unsigned char *tmpbuf = (unsigned char *)malloc(OSDATA_ALLOC_SIZE); ! 479: ! 480: int c = currentChar(); ! 481: *size = 0; ! 482: ! 483: while (c != '<') { ! 484: c &= 0x7f; ! 485: if (c == 0) { ! 486: free(tmpbuf); ! 487: return 0; ! 488: } ! 489: if (c == '=') numeq++; else numeq = 0; ! 490: if (c == '\n') lineNumber++; ! 491: if (__CFPLDataDecodeTable[c] < 0) { ! 492: c = nextChar(); ! 493: continue; ! 494: } ! 495: cntr++; ! 496: acc <<= 6; ! 497: acc += __CFPLDataDecodeTable[c]; ! 498: if (0 == (cntr & 0x3)) { ! 499: if (tmpbuflen <= tmpbufpos + 2) { ! 500: tmpbuflen += OSDATA_ALLOC_SIZE; ! 501: tmpbuf = (unsigned char *)realloc(tmpbuf, tmpbuflen); ! 502: } ! 503: tmpbuf[tmpbufpos++] = (acc >> 16) & 0xff; ! 504: if (numeq < 2) ! 505: tmpbuf[tmpbufpos++] = (acc >> 8) & 0xff; ! 506: if (numeq < 1) ! 507: tmpbuf[tmpbufpos++] = acc & 0xff; ! 508: } ! 509: c = nextChar(); ! 510: } ! 511: *size = tmpbufpos; ! 512: return tmpbuf; ! 513: } ! 514: ! 515: static int ! 516: yylex() ! 517: { ! 518: int c; ! 519: int tagType; ! 520: char tag[TAG_MAX_LENGTH]; ! 521: int attributeCount; ! 522: char attributes[TAG_MAX_ATTRIBUTES][TAG_MAX_LENGTH]; ! 523: char values[TAG_MAX_ATTRIBUTES][TAG_MAX_LENGTH]; ! 524: ! 525: if (parseBufferIndex == 0) lineNumber = 1; ! 526: ! 527: top: ! 528: c = currentChar(); ! 529: ! 530: /* skip white space */ ! 531: if (isSpace(c)) while ((c = nextChar()) != 0 && isSpace(c)) {}; ! 532: ! 533: /* keep track of line number, don't return \n's */ ! 534: if (c == '\n') { ! 535: lineNumber++; ! 536: (void)nextChar(); ! 537: goto top; ! 538: } ! 539: ! 540: if (!c || c == ',') { ! 541: (void)nextChar(); ! 542: return c; ! 543: } ! 544: ! 545: tagType = getTag(tag, &attributeCount, attributes, values); ! 546: if (tagType == TAG_BAD) return SYNTAX_ERROR; ! 547: if (tagType == TAG_COMMENT) goto top; ! 548: ! 549: // this code handles empty tags, for idrefs we ignore the tag ! 550: // for this to work all idrefs must be unique across the whole serialization ! 551: if (tagType == TAG_EMPTY) { ! 552: if (!strcmp(tag, "true") || !strcmp(tag, "false")) { ! 553: yylval = newObject(); ! 554: yylval->number = *tag == 't'; ! 555: return BOOLEAN; ! 556: } ! 557: for (int i=0; i < attributeCount; i++) { ! 558: if (!strcmp(attributes[i], "IDREF")) { ! 559: yylval = newObject(); ! 560: yylval->idref = strtol(values[i], NULL, 0); ! 561: return IDREF; ! 562: } ! 563: } ! 564: return SYNTAX_ERROR; ! 565: } ! 566: ! 567: // handle allocation and check of "ID" tag up front ! 568: yylval = newObject(); ! 569: yylval->idref = -1; ! 570: for (int i=0; i < attributeCount; i++) { ! 571: if (attributes[i][0] == 'I' && attributes[i][1] == 'D' && !attributes[i][2]) { ! 572: yylval->idref = strtol(values[i], NULL, 0); ! 573: } ! 574: } ! 575: ! 576: switch (*tag) { ! 577: case 'a': ! 578: if (!strcmp(tag, "array")) { ! 579: return (tagType == TAG_START) ? '(' : ')'; ! 580: } ! 581: break; ! 582: case 'd': ! 583: if (!strcmp(tag, "dict")) { ! 584: return (tagType == TAG_START) ? '{' : '}'; ! 585: } ! 586: if (!strcmp(tag, "data")) { ! 587: unsigned int size; ! 588: yylval->data = getData(&size); ! 589: yylval->size = size; ! 590: if ((getTag(tag, &attributeCount, attributes, values) != TAG_END) || strcmp(tag, "data")) { ! 591: return SYNTAX_ERROR; ! 592: } ! 593: return DATA; ! 594: } ! 595: break; ! 596: case 'i': ! 597: if (!strcmp(tag, "integer")) { ! 598: yylval->number = getNumber(); ! 599: yylval->size = 64; // default ! 600: for (int i=0; i < attributeCount; i++) { ! 601: if (!strcmp(attributes[i], "size")) { ! 602: yylval->size = strtoul(values[i], NULL, 0); ! 603: } ! 604: } ! 605: if ((getTag(tag, &attributeCount, attributes, values) != TAG_END) || strcmp(tag, "integer")) { ! 606: return SYNTAX_ERROR; ! 607: } ! 608: return NUMBER; ! 609: } ! 610: break; ! 611: case 'k': ! 612: if (!strcmp(tag, "key")) { ! 613: yylval->string = getString(); ! 614: if (!yylval->string) { ! 615: return SYNTAX_ERROR; ! 616: } ! 617: if ((getTag(tag, &attributeCount, attributes, values) != TAG_END) ! 618: || strcmp(tag, "key")) { ! 619: return SYNTAX_ERROR; ! 620: } ! 621: return KEY; ! 622: } ! 623: break; ! 624: case 'p': ! 625: if (!strcmp(tag, "plist")) { ! 626: freeObject(yylval); ! 627: goto top; ! 628: } ! 629: break; ! 630: case 's': ! 631: if (!strcmp(tag, "string")) { ! 632: yylval->string = getString(); ! 633: if (!yylval->string) { ! 634: return SYNTAX_ERROR; ! 635: } ! 636: if ((getTag(tag, &attributeCount, attributes, values) != TAG_END) ! 637: || strcmp(tag, "string")) { ! 638: return SYNTAX_ERROR; ! 639: } ! 640: return STRING; ! 641: } ! 642: if (!strcmp(tag, "set")) { ! 643: if (tagType == TAG_START) { ! 644: return '['; ! 645: } else { ! 646: return ']'; ! 647: } ! 648: } ! 649: break; ! 650: ! 651: default: ! 652: // XXX should we ignore invalid tags? ! 653: return SYNTAX_ERROR; ! 654: break; ! 655: } ! 656: ! 657: return 0; ! 658: } ! 659: ! 660: // !@$&)(^Q$&*^!$(*!@$_(^%_(*Q#$(_*&!$_(*&!$_(*&!#$(*!@&^!@#%!_!# ! 661: // !@$&)(^Q$&*^!$(*!@$_(^%_(*Q#$(_*&!$_(*&!$_(*&!#$(*!@&^!@#%!_!# ! 662: // !@$&)(^Q$&*^!$(*!@$_(^%_(*Q#$(_*&!$_(*&!$_(*&!#$(*!@&^!@#%!_!# ! 663: ! 664: // "java" like allocation, if this code hits a syntax error in the ! 665: // the middle of the parsed string we just bail with pointers hanging ! 666: // all over place, so this code helps keeps all together ! 667: ! 668: static object_t *objects = 0; ! 669: static object_t *freeObjects = 0; ! 670: ! 671: object_t * ! 672: newObject() ! 673: { ! 674: object_t *o; ! 675: ! 676: if (freeObjects) { ! 677: o = freeObjects; ! 678: freeObjects = freeObjects->next; ! 679: } else { ! 680: o = (object_t *)malloc(sizeof(object_t)); ! 681: bzero(o, sizeof(object_t)); ! 682: o->free = objects; ! 683: objects = o; ! 684: } ! 685: ! 686: return o; ! 687: } ! 688: ! 689: void ! 690: freeObject(object_t *o) ! 691: { ! 692: o->next = freeObjects; ! 693: freeObjects = o; ! 694: } ! 695: ! 696: void ! 697: cleanupObjects() ! 698: { ! 699: object_t *t, *o = objects; ! 700: ! 701: while (o) { ! 702: if (o->object) { ! 703: printf("OSUnserializeXML: releasing object o=%x object=%x\n", (int)o, (int)o->object); ! 704: o->object->release(); ! 705: } ! 706: if (o->data) { ! 707: printf("OSUnserializeXML: freeing object o=%x data=%x\n", (int)o, (int)o->data); ! 708: free(o->data); ! 709: } ! 710: if (o->key) { ! 711: printf("OSUnserializeXML: releasing object o=%x key=%x\n", (int)o, (int)o->key); ! 712: o->key->release(); ! 713: } ! 714: if (o->string) { ! 715: printf("OSUnserializeXML: freeing object o=%x string=%x\n", (int)o, (int)o->string); ! 716: free(o->string); ! 717: } ! 718: ! 719: t = o; ! 720: o = o->free; ! 721: free(t); ! 722: } ! 723: } ! 724: ! 725: // !@$&)(^Q$&*^!$(*!@$_(^%_(*Q#$(_*&!$_(*&!$_(*&!#$(*!@&^!@#%!_!# ! 726: // !@$&)(^Q$&*^!$(*!@$_(^%_(*Q#$(_*&!$_(*&!$_(*&!#$(*!@&^!@#%!_!# ! 727: // !@$&)(^Q$&*^!$(*!@$_(^%_(*Q#$(_*&!$_(*&!$_(*&!#$(*!@&^!@#%!_!# ! 728: ! 729: static OSDictionary *tags; ! 730: ! 731: static void ! 732: rememberObject(int tag, OSObject *o) ! 733: { ! 734: char key[16]; ! 735: sprintf(key, "%u", tag); ! 736: ! 737: //printf("remember key %s\n", key); ! 738: ! 739: tags->setObject(key, o); ! 740: } ! 741: ! 742: static object_t * ! 743: retrieveObject(int tag) ! 744: { ! 745: char key[16]; ! 746: sprintf(key, "%u", tag); ! 747: ! 748: //printf("retrieve key '%s'\n", key); ! 749: ! 750: OSObject *ref = tags->getObject(key); ! 751: if (!ref) return 0; ! 752: ! 753: object_t *o = newObject(); ! 754: o->object = ref; ! 755: return o; ! 756: } ! 757: ! 758: // !@$&)(^Q$&*^!$(*!@$_(^%_(*Q#$(_*&!$_(*&!$_(*&!#$(*!@&^!@#%!_!# ! 759: // !@$&)(^Q$&*^!$(*!@$_(^%_(*Q#$(_*&!$_(*&!$_(*&!#$(*!@&^!@#%!_!# ! 760: // !@$&)(^Q$&*^!$(*!@$_(^%_(*Q#$(_*&!$_(*&!$_(*&!#$(*!@&^!@#%!_!# ! 761: ! 762: object_t * ! 763: buildOSDictionary(object_t * header) ! 764: { ! 765: object_t *o, *t; ! 766: int count = 0; ! 767: ! 768: // get count and reverse order ! 769: o = header->elements; ! 770: header->elements = 0; ! 771: while (o) { ! 772: count++; ! 773: t = o; ! 774: o = o->next; ! 775: ! 776: t->next = header->elements; ! 777: header->elements = t; ! 778: } ! 779: ! 780: OSDictionary *d = OSDictionary::withCapacity(count); ! 781: ! 782: if (header->idref >= 0) rememberObject(header->idref, d); ! 783: ! 784: o = header->elements; ! 785: while (o) { ! 786: d->setObject(o->key, o->object); ! 787: o->object->release(); ! 788: o->object = 0; ! 789: o->key->release(); ! 790: o->key = 0; ! 791: t = o; ! 792: o = o->next; ! 793: freeObject(t); ! 794: } ! 795: o = header; ! 796: o->object = d; ! 797: return o; ! 798: }; ! 799: ! 800: object_t * ! 801: buildOSArray(object_t * header) ! 802: { ! 803: object_t *o, *t; ! 804: int count = 0; ! 805: ! 806: // get count and reverse order ! 807: o = header->elements; ! 808: header->elements = 0; ! 809: while (o) { ! 810: count++; ! 811: t = o; ! 812: o = o->next; ! 813: ! 814: t->next = header->elements; ! 815: header->elements = t; ! 816: } ! 817: ! 818: OSArray *a = OSArray::withCapacity(count); ! 819: ! 820: if (header->idref >= 0) rememberObject(header->idref, a); ! 821: ! 822: o = header->elements; ! 823: while (o) { ! 824: a->setObject(o->object); ! 825: o->object->release(); ! 826: o->object = 0; ! 827: t = o; ! 828: o = o->next; ! 829: freeObject(t); ! 830: } ! 831: o = header; ! 832: o->object = a; ! 833: return o; ! 834: }; ! 835: ! 836: object_t * ! 837: buildOSSet(object_t *o) ! 838: { ! 839: o = buildOSArray(o); ! 840: OSArray *a = (OSArray *)o->object; ! 841: ! 842: OSSet *s = OSSet::withArray(a, a->getCapacity()); ! 843: ! 844: //write over reference created in array ! 845: if (o->idref >= 0) rememberObject(o->idref, s); ! 846: ! 847: a->release(); ! 848: o->object = s; ! 849: return o; ! 850: }; ! 851: ! 852: object_t * ! 853: buildOSString(object_t *o) ! 854: { ! 855: OSString *s = OSString::withCString(o->string); ! 856: ! 857: if (o->idref >= 0) rememberObject(o->idref, s); ! 858: ! 859: free(o->string); ! 860: o->string = 0; ! 861: o->object = s; ! 862: ! 863: return o; ! 864: }; ! 865: ! 866: object_t * ! 867: buildKey(object_t *o) ! 868: { ! 869: const OSSymbol *s = OSSymbol::withCString(o->string); ! 870: ! 871: free(o->string); ! 872: o->string = 0; ! 873: o->key = s; ! 874: ! 875: return o; ! 876: }; ! 877: ! 878: object_t * ! 879: buildOSData(object_t *o) ! 880: { ! 881: OSData *d; ! 882: ! 883: if (o->size) { ! 884: d = OSData::withBytes(o->data, o->size); ! 885: free(o->data); ! 886: } else { ! 887: d = OSData::withCapacity(0); ! 888: } ! 889: if (o->idref >= 0) rememberObject(o->idref, d); ! 890: ! 891: o->data = 0; ! 892: o->object = d; ! 893: return o; ! 894: }; ! 895: ! 896: object_t * ! 897: buildOSNumber(object_t *o) ! 898: { ! 899: OSNumber *n = OSNumber::withNumber(o->number, o->size); ! 900: ! 901: if (o->idref >= 0) rememberObject(o->idref, n); ! 902: ! 903: o->object = n; ! 904: return o; ! 905: }; ! 906: ! 907: object_t * ! 908: buildOSBoolean(object_t *o) ! 909: { ! 910: OSBoolean *b = OSBoolean::withBoolean(o->number != 0); ! 911: o->object = b; ! 912: return o; ! 913: }; ! 914: ! 915: __BEGIN_DECLS ! 916: #include <kern/lock.h> ! 917: __END_DECLS ! 918: ! 919: static mutex_t *lock = 0; ! 920: ! 921: OSObject* ! 922: OSUnserializeXML(const char *buffer, OSString **errorString) ! 923: { ! 924: OSObject *object; ! 925: ! 926: if (!lock) { ! 927: lock = mutex_alloc(ETAP_IO_AHA); ! 928: _mutex_lock(lock); ! 929: } else { ! 930: _mutex_lock(lock); ! 931: ! 932: } ! 933: ! 934: objects = 0; ! 935: freeObjects = 0; ! 936: yyerror_message[0] = 0; //just in case ! 937: parseBuffer = buffer; ! 938: parseBufferIndex = 0; ! 939: tags = OSDictionary::withCapacity(128); ! 940: if (yyparse() == 0) { ! 941: object = parsedObject; ! 942: if (errorString) *errorString = 0; ! 943: } else { ! 944: object = 0; ! 945: if (errorString) ! 946: *errorString = OSString::withCString(yyerror_message); ! 947: } ! 948: ! 949: cleanupObjects(); ! 950: tags->release(); ! 951: mutex_unlock(lock); ! 952: ! 953: return object; ! 954: } ! 955: ! 956: ! 957: // ! 958: // ! 959: // ! 960: // ! 961: // ! 962: // DO NOT EDIT OSUnserializeXML.cpp! ! 963: // ! 964: // this means you! ! 965: // ! 966: // ! 967: // ! 968: // ! 969: //
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.