Chameleon

Chameleon Svn Source Tree

Root/trunk/i386/libsaio/xml.c

1/*␊
2 * Copyright (c) 2003 Apple Computer, Inc. All rights reserved.␊
3 *␊
4 * @APPLE_LICENSE_HEADER_START@␊
5 *␊
6 * Portions Copyright (c) 2003 Apple Computer, Inc. All Rights␊
7 * Reserved.␊
8 * The contents of this file constitute Original Code as defined in and␊
9 * are subject to the Apple Public Source License Version 2.0 (the␊
10 * "License"). You may not use this file except in compliance with the␊
11 * License. Please obtain a copy of the License at␊
12 * http://www.apple.com/publicsource and read it before using this file.␊
13 *␊
14 * This Original Code and all software distributed under the License are␊
15 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER␊
16 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,␊
17 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,␊
18 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the␊
19 * License for the specific language governing rights and limitations␊
20 * under the License.␊
21 *␊
22 * @APPLE_LICENSE_HEADER_END@␊
23 */␊
24␊
25#include "bootstruct.h"␊
26#include "libsaio.h"␊
27#include "sl.h"␊
28#include "xml.h"␊
29␊
30string_ref *ref_strings = NULL;␊
31␊
32/// TODO: remove below␊
33static char *buffer_start = NULL;␊
34// TODO: redo the next two functions␊
35void SaveRefString(char *string, int id)␊
36{␊
37␉//printf("Adding Ref String %d (%s)\n", id, string);␊
38␉string_ref *tmp = ref_strings;␊
39␉while(tmp)␊
40␉{␊
41␉␉if(tmp->id == id)␊
42␉␉{␊
43␉␉␉tmp->string = malloc(strlen(string)+1);␊
44␉␉␉snprintf(tmp->string, strlen(string)+1,"%s", string);␊
45␉␉␉return;␊
46␉␉}␊
47␉␉tmp = tmp->next;␊
48␉}␊
49␊
50␉string_ref *new_ref = malloc(sizeof(string_ref));␊
51␉new_ref->string = malloc(strlen(string)+1);␊
52␉snprintf(new_ref->string, (strlen(string)+1)* sizeof(char),"%s", string);␊
53␉new_ref->id = id;␊
54␉new_ref->next = ref_strings;␊
55␉ref_strings = new_ref;␊
56}␊
57␊
58char *GetRefString(int id)␊
59{␊
60␉string_ref *tmp = ref_strings;␊
61␉while(tmp)␊
62␉{␊
63␉␉if(tmp->id == id) return tmp->string;␊
64␉␉tmp = tmp->next;␊
65␉}␊
66␉//verbose("Unable to locate Ref String %d\n", id);␊
67␉return "Unknown";␊
68}␊
69␊
70struct Module {␊
71␉struct Module *nextModule;␊
72␉long␉␉willLoad;␊
73␉TagPtr␉␉dict;␊
74␉char␉␉*plistAddr;␊
75␉long␉␉plistLength;␊
76␉char␉␉*driverPath;␊
77};␊
78typedef struct Module Module, *ModulePtr;␊
79␊
80struct DriverInfo {␊
81␉char␉*plistAddr;␊
82␉long␉plistLength;␊
83␉void␉*moduleAddr;␊
84␉long␉moduleLength;␊
85};␊
86typedef struct DriverInfo DriverInfo, *DriverInfoPtr;␊
87␊
88#define kDriverPackageSignature1 'MKXT'␊
89#define kDriverPackageSignature2 'MOSX'␊
90␊
91struct DriversPackage {␊
92␉unsigned long signature1;␊
93␉unsigned long signature2;␊
94␉unsigned long length;␊
95␉unsigned long adler32;␊
96␉unsigned long version;␊
97␉unsigned long numDrivers;␊
98␉unsigned long reserved1;␊
99␉unsigned long reserved2;␊
100};␊
101typedef struct DriversPackage DriversPackage;␊
102␊
103enum {␊
104␉kCFBundleType2,␊
105␉kCFBundleType3␊
106};␊
107␊
108␊
109#define DOFREE 1␊
110␊
111static long ParseTagList(char *buffer, TagPtr *tag, long type, long empty);␊
112static long ParseTagKey(char *buffer, TagPtr *tag);␊
113static long ParseTagString(char *buffer, TagPtr *tag);␊
114static long ParseTagInteger(char *buffer, TagPtr *tag);␊
115static long ParseTagData(char *buffer, TagPtr *tag);␊
116static long ParseTagDate(char *buffer, TagPtr *tag);␊
117//static long ParseTagBoolean(char *buffer, TagPtr *tag, long type);␊
118static long GetNextTag(char *buffer, char **tag, long *start);␊
119static long FixDataMatchingTag(char *buffer, char *tag);␊
120static TagPtr NewTag(void);␊
121static char *NewSymbol(char *string);␊
122#if DOFREE␊
123static void FreeSymbol(char *string);␊
124#endif␊
125␊
126␊
127//==========================================================================␊
128// XMLGetProperty␊
129␊
130TagPtr XMLGetProperty(TagPtr dict, const char *key)␊
131{␊
132␉TagPtr tagList, tag;␊
133␊
134␉if (dict->type != kTagTypeDict)␊
135␉{␊
136␉␉return 0;␊
137␉}␊
138␊
139␉tag = 0;␊
140␉tagList = dict->tag;␊
141␉while (tagList) {␊
142␉␉tag = tagList;␊
143␉␉tagList = tag->tagNext;␊
144␊
145␉␉if ((tag->type != kTagTypeKey) || (tag->string == 0))␊
146␉␉{␊
147␉␉␉continue;␊
148␉␉}␊
149␊
150␉␉if (!strcmp(tag->string, key))␊
151␉␉{␊
152␉␉␉return tag->tag;␊
153␉␉}␊
154␉}␊
155␉return 0;␊
156}␊
157␊
158//==========================================================================␊
159// XMLGetProperty␊
160␊
161TagPtr XMLGetKey( TagPtr dict, int id )␊
162{␊
163␉TagPtr tagList, tag;␊
164␊
165␉if (dict->type != kTagTypeDict)␊
166␉{␊
167␉␉return 0;␊
168␉}␊
169␊
170␉tag = 0;␊
171␉int element = 0;␊
172␉tagList = dict->tag;␊
173␉while (tagList && element != id)␊
174␉{␊
175␉␉tag = tagList;␊
176␉␉tagList = tag->tagNext;␊
177␊
178␉␉if ((tag->type != kTagTypeKey) || (tag->string == 0))␊
179␉␉{␊
180␉␉␉continue;␊
181␉␉}␊
182␊
183 ␉element++;␊
184␉␉if(id == element)␊
185␉␉{␊
186␉␉␉return tag;␊
187␉␉}␊
188␊
189␉}␊
190␉return 0;␊
191}␊
192␊
193TagPtr XMLGetValueForKey(TagPtr key)␊
194{␊
195␉if (!key || key->type != kTagTypeKey)␊
196␉{␊
197␉␉return 0;␊
198␉}␊
199␊
200␉return key->tag;␊
201}␊
202␊
203␊
204// XMLGetTag(int index)␊
205␊
206// XMLTagCount( TagPtr dict )␊
207int XMLTagCount( TagPtr dict )␊
208{␊
209␉int count = 0;␊
210␉TagPtr tagList, tag;␊
211␊
212␉if (dict->type != kTagTypeDict && dict->type != kTagTypeArray)␊
213␉{␊
214␉␉return 0;␊
215␉}␊
216␊
217␉tag = 0;␊
218␉tagList = dict->tag;␊
219␉while (tagList)␊
220␉{␊
221␉␉tag = tagList;␊
222␉␉tagList = tag->tagNext;␊
223␊
224␉␉if (((tag->type != kTagTypeKey) && ((tag->string == 0) || (tag->string[0] == 0)))␊
225␉␉␉&& (dict->type != kTagTypeArray)␉// If we are an array, any element is valid␊
226␉␉␉)␊
227␉␉{␊
228␉␉␉continue;␊
229␉␉}␊
230␊
231␉␉//if(tag->type == kTagTypeKey) printf("Located key %s\n", tag->string);␊
232␊
233␉␉count++;␊
234␉}␊
235␊
236␉return count;␊
237}␊
238␊
239TagPtr XMLGetElement( TagPtr dict, int id )␊
240{␊
241␉if(dict->type != kTagTypeArray)␊
242␉{␊
243␉␉return 0;␊
244␉}␊
245␊
246␉int element = 0;␊
247␉TagPtr tmp = dict->tag;␊
248␊
249␉while(element < id)␊
250␉{␊
251␉␉element++;␊
252␉␉tmp = tmp->tagNext;␊
253␉}␊
254␊
255␉return tmp;␊
256}␊
257␊
258/* Function for basic XML character entities parsing */␊
259␊
260char *XMLDecode(const char* src)␊
261{␊
262␉typedef const struct XMLEntity {␊
263␉␉const char *name;␊
264␉␉size_t nameLen;␊
265␉␉char value;␊
266␉} XMLEntity;␊
267␊
268␉/* This is ugly, but better than specifying the lengths by hand */␊
269␉#define _e(str,c) {str,sizeof(str)-1,c}␊
270␉const XMLEntity ents[] = {␊
271␉␉_e("quot;",'"'), _e("apos;",'\''),␊
272␉␉_e("lt;", '<'), _e("gt;", '>'),␊
273␉␉_e("amp;", '&')␊
274␉};␊
275␊
276␉size_t len;␊
277␉const char *s;␊
278␉char *out, *o;␊
279␊
280␉if ( !src || !(len = strlen(src)) || !(out = malloc(len+1)) )␊
281␉{␊
282␉␉return 0;␊
283␉}␊
284␊
285␉o = out;␊
286␉s = src;␊
287␉while (s <= src+len) /* Make sure the terminator is also copied */␊
288␉{␊
289␉␉if ( *s == '&' )␊
290␉␉{␊
291␉␉␉bool entFound = false;␊
292␉␉␉int i;␊
293␊
294␉␉␉s++;␊
295␉␉␉for ( i = 0; i < sizeof(ents)/sizeof(ents[0]); i++)␊
296␉␉␉{␊
297␉␉␉␉if ( strncmp(s, ents[i].name, ents[i].nameLen) == 0 )␊
298␉␉␉␉{␊
299␉␉␉␉␉entFound = true;␊
300␉␉␉␉␉break;␊
301␉␉␉␉}␊
302␉␉␉}␊
303␉␉␉if ( entFound )␊
304␉␉␉{␊
305␉␉␉␉*o++ = ents[i].value;␊
306␉␉␉␉s += ents[i].nameLen;␊
307␊
308␉␉␉continue;␊
309␉␉␉}␊
310␉␉}␊
311␊
312␉*o++ = *s++;␊
313␉}␊
314␊
315␉return out;␊
316}␊
317␊
318//==========================================================================␊
319// XMLParseFile␊
320// Expects to see one dictionary in the XML file, the final pos will be returned␊
321// If the pos is not equal to the strlen, then there are multiple dicts␊
322// Puts the first dictionary it finds in the␊
323// tag pointer and returns the end of the dic, or returns -1 if not found.␊
324//␊
325long XMLParseFile( char * buffer, TagPtr *dict )␊
326{␊
327␉long␉length;␊
328␉long␉pos = 0;␊
329␉TagPtr␉tag;␊
330␉char␉*configBuffer;␊
331␊
332␉int strlength = strlen(buffer);␊
333␉configBuffer = malloc(strlength+1);␊
334␉bcopy(buffer, configBuffer, strlength);␊
335␊
336␉configBuffer[strlength] = 0;␊
337␊
338␉buffer_start = configBuffer;␊
339␊
340␉while (1)␊
341␉{␊
342␉␉length = XMLParseNextTag(configBuffer + pos, &tag);␊
343␉␉if (length == -1) break;␊
344␊
345␉␉pos += length;␊
346␊
347␉␉if (tag == 0)␊
348␉␉{␊
349␉␉␉continue;␊
350␉␉}␊
351␊
352␉␉if (tag->type == kTagTypeDict)␊
353␉␉{␊
354␉␉␉break;␊
355␉␉}␊
356␊
357␉␉XMLFreeTag(tag);␊
358␉}␊
359␉free(configBuffer);␊
360␉if (length < 0)␊
361␉{␊
362␉␉return -1;␊
363␉}␊
364␉*dict = tag;␊
365␉return pos;␊
366}␊
367␊
368//==========================================================================␊
369// ParseNextTag␊
370// TODO: cleanup␊
371long XMLParseNextTag( char *buffer, TagPtr *tag )␊
372{␊
373␉long␉length = 0;␊
374␉long␉pos = 0;␊
375␊
376␊
377␉char␉*tagName;␊
378␊
379␉length = GetNextTag(buffer, &tagName, 0);␊
380␉if (length == -1)␊
381␉{␊
382␉␉return -1;␊
383␉}␊
384␊
385␉pos = length;␊
386␉if (!strncmp(tagName, kXMLTagPList, 6))␊
387␉{␊
388␉␉length = 0;␊
389 // just a header; nothing to parse␊
390 // return-via-reference tag should be left alone␊
391␉}␊
392␉/***** dict ****/␊
393␉else if (!strncmp(tagName, kXMLTagDict, sizeof(kXMLTagDict)))␊
394␉{␊
395␉␉length = ParseTagList(buffer + pos, tag, kTagTypeDict, 0);␊
396␉}␊
397␉else if (!strncmp(tagName, kXMLTagDict, strlen(kXMLTagDict)) && tagName[strlen(tagName)-1] == '/')␊
398␉{␊
399␉␉length = ParseTagList(buffer + pos, tag, kTagTypeDict, 1);␊
400␉}␊
401␉else if (!strncmp(tagName, kXMLTagDict " ", strlen(kXMLTagDict " ")))␊
402␉{␊
403␉␉length = ParseTagList(buffer + pos, tag, kTagTypeDict, 0);␊
404␉}␊
405␉/***** key ****/␊
406␉else if (!strncmp(tagName, kXMLTagKey, sizeof(kXMLTagKey)))␊
407␉{␊
408␉␉length = ParseTagKey(buffer + pos, tag);␊
409␉}␊
410␊
411␉/***** string ****/␊
412␉else if (!strncmp(tagName, kXMLTagString, sizeof(kXMLTagString)))␊
413␉{␊
414␉␉length = ParseTagString(buffer + pos, tag);␊
415␉}␊
416␉else if (!strncmp(tagName, kXMLTagString " ", strlen(kXMLTagString " ")))␊
417␉{␊
418␉␉// TODO: save tag if if found␊
419␉␉if(!strncmp(tagName + strlen(kXMLTagString " "), kXMLStringID, strlen(kXMLStringID)))␊
420␉␉{␊
421␉␉␉// ID=␊
422␉␉␉int id = 0;␊
423␉␉␉int cnt = strlen(kXMLTagString " " kXMLStringID "\"") + 1;␊
424␉␉␉while ((tagName[cnt] != '\0') && (tagName[cnt] != '"')) cnt++;␊
425␉␉␉tagName[cnt] = 0;␊
426␉␉␉char* val = tagName + strlen(kXMLTagString " " kXMLStringID "\"");␊
427␉␉␉while(*val)␊
428␉␉␉{␊
429␉␉␉␉if ((*val >= '0' && *val <= '9'))␉// 0 - 9␊
430␉␉␉␉{␊
431␉␉␉␉␉id = (id * 10) + (*val++ - '0');␊
432␉␉␉␉}␊
433␉␉␉␉else␊
434␉␉␉␉{␊
435␉␉␉␉␉printf("ParseStringID error (0x%x)\n", *val);␊
436␉␉␉␉␉getchar();␊
437␉␉␉␉␉return -1;␊
438␉␉␉␉}␊
439␉␉␉}␊
440␉␉␉length = ParseTagString(buffer + pos, tag);␊
441␊
442␉␉␉SaveRefString(buffer + pos, id);␊
443␉␉}␊
444␉␉else if(!strncmp(tagName + strlen(kXMLTagString " "), kXMLStringIDRef, strlen(kXMLStringIDRef)))␊
445␉␉{␊
446␉␉␉// IDREF=␊
447␉␉␉int id = 0;␊
448␉␉␉int cnt = strlen(kXMLTagString " " kXMLStringIDRef "\"") + 1;␊
449␉␉␉while ((tagName[cnt] != '\0') && (tagName[cnt] != '"')) cnt++;␊
450␉␉␉tagName[cnt] = 0;␊
451␉␉␉char* val = tagName + strlen(kXMLTagString " " kXMLStringIDRef "\"");␊
452␉␉␉while(*val)␊
453␉␉␉{␊
454␉␉␉␉if ((*val >= '0' && *val <= '9'))␉// 0 - 9␊
455␉␉␉␉{␊
456␉␉␉␉␉id = (id * 10) + (*val++ - '0');␊
457␉␉␉␉}␊
458␉␉␉␉else␊
459␉␉␉␉{␊
460␉␉␉␉␉printf("ParseStringIDREF error (0x%x)\n", *val);␊
461␉␉␉␉␉getchar();␊
462␉␉␉␉␉return -1;␊
463␉␉␉␉}␊
464␉␉␉}␊
465␉␉␉char* str = GetRefString(id);␊
466␊
467␉␉␉TagPtr tmpTag = NewTag();␊
468␉␉␉tmpTag->type = kTagTypeString;␊
469␉␉␉tmpTag->string = str;␊
470␉␉␉tmpTag->tag = 0;␊
471␉␉␉tmpTag->tagNext = 0;␊
472␉␉␉tmpTag->offset = buffer_start ? buffer - buffer_start + pos : 0;␊
473␉␉␉*tag = tmpTag;␊
474␊
475␉␉␉length = 0;␊
476␉␉␉//printf("Located IDREF, id = %d, string = %s\n", id, str);␊
477␉␉}␊
478␉}␊
479␊
480␉/***** integer ****/␊
481␉else if (!strncmp(tagName, kXMLTagInteger, sizeof(kXMLTagInteger)))␊
482␉{␊
483␉␉length = ParseTagInteger(buffer + pos, tag);␊
484␉}␊
485␉else if (!strncmp(tagName, kXMLTagInteger " ", strlen(kXMLTagInteger " ")))␊
486␉{␊
487␉␉if(!strncmp(tagName + strlen(kXMLTagInteger " "), kXMLStringID, strlen(kXMLStringID)))␊
488␉␉{␊
489␉␉␉// ID=␊
490␉␉␉int id = 0;␊
491␉␉␉int cnt = strlen(kXMLTagInteger " " kXMLStringID "\"") + 1;␊
492␉␉␉while ((tagName[cnt] != '\0') && (tagName[cnt] != '"')) cnt++;␊
493␉␉␉tagName[cnt] = 0;␊
494␉␉␉char* val = tagName + strlen(kXMLTagInteger " " kXMLStringID "\"");␊
495␉␉␉while(*val)␊
496␉␉␉{␊
497␉␉␉␉if ((*val >= '0' && *val <= '9'))␉// 0 - 9␊
498␉␉␉␉{␊
499␉␉␉␉␉id = (id * 10) + (*val++ - '0');␊
500␉␉␉␉}␊
501␉␉␉␉else␊
502␉␉␉␉{␊
503␉␉␉␉␉printf("ParseIntegerID error (0x%x)\n", *val);␊
504␉␉␉␉␉getchar();␊
505␉␉␉␉␉return -1;␊
506␉␉␉␉}␊
507␉␉␉}␊
508␉␉␉length = ParseTagInteger(buffer + pos, tag);␊
509␊
510␉␉␉SaveRefString((*tag)->string, id);␊
511␉␉}␊
512␉␉else if(!strncmp(tagName + strlen(kXMLTagInteger " "), kXMLStringIDRef, strlen(kXMLStringIDRef)))␊
513␉␉{␊
514␉␉␉// IDREF=␊
515␉␉␉int id = 0;␊
516␉␉␉int cnt = strlen(kXMLTagInteger " " kXMLStringIDRef "\"") + 1;␊
517␉␉␉while ((tagName[cnt] != '\0') && (tagName[cnt] != '"')) cnt++;␊
518␉␉␉tagName[cnt] = 0;␊
519␉␉␉char* val = tagName + strlen(kXMLTagInteger " " kXMLStringIDRef "\"");␊
520␉␉␉while(*val)␊
521␉␉␉{␊
522␉␉␉␉if ((*val >= '0' && *val <= '9'))␉// 0 - 9␊
523␉␉␉␉{␊
524␉␉␉␉␉id = (id * 10) + (*val++ - '0');␊
525␉␉␉␉}␊
526␉␉␉␉else␊
527␉␉␉␉{␊
528␉␉␉␉␉printf("ParseStringIDREF error (0x%x)\n", *val);␊
529␉␉␉␉␉getchar();␊
530␉␉␉␉␉return -1;␊
531␉␉␉␉}␊
532␉␉␉}␊
533␉␉␉int integer = (int)GetRefString(id);␊
534␊
535␉␉␉TagPtr tmpTag = NewTag();␊
536␉␉␉tmpTag->type = kTagTypeInteger;␊
537␉␉␉tmpTag->string = (char*) integer;␊
538␉␉␉tmpTag->tag = 0;␊
539␉␉␉tmpTag->tagNext = 0;␊
540␉␉␉tmpTag->offset = buffer_start ? buffer - buffer_start + pos : 0;␊
541␊
542␉␉␉*tag = tmpTag;␊
543␊
544␉␉␉length = 0;␊
545␉␉␉//printf("Located IDREF, id = %d, string = %s\n", id, str);␊
546␉␉}␊
547␉␉else␊
548␉␉{␊
549␉␉␉length = ParseTagInteger(buffer + pos, tag);␊
550␉␉}␊
551␉}␊
552␊
553␊
554␉/***** false ****/␊
555␉else if (!strncmp(tagName, kXMLTagFalse, sizeof(kXMLTagFalse)))␊
556␉{␊
557␉␉length = ParseTagBoolean(buffer + pos, tag, kTagTypeFalse);␊
558␉}␊
559␊
560␉/***** true ****/␊
561␉else if (!strncmp(tagName, kXMLTagTrue, sizeof(kXMLTagTrue)))␊
562␉{␊
563␉␉length = ParseTagBoolean(buffer + pos, tag, kTagTypeTrue);␊
564␉}␊
565␊
566␉/***** plist ****/␊
567␊
568␊
569␉/***** dict ****/␊
570␊
571␊
572␉/***** data ****/␊
573␉else if (!strncmp(tagName, kXMLTagData, sizeof(kXMLTagData)))␊
574␉{␊
575␉␉length = ParseTagData(buffer + pos, tag);␊
576␉}␊
577␉else if (!strncmp(tagName, kXMLTagData " ", strlen(kXMLTagData " ")))␊
578␉{␊
579␉␉length = ParseTagData(buffer + pos, tag);␊
580␉}␊
581␊
582␉else if (!strncmp(tagName, kXMLTagDate, sizeof(kXMLTagDate)))␊
583␉{␊
584␉␉length = ParseTagDate(buffer + pos, tag);␊
585␉}␊
586␊
587␉/***** date ****/␊
588␉else if (!strncmp(tagName, kXMLTagDate " ", strlen(kXMLTagDate " ")))␊
589␉{␊
590␉␉length = ParseTagDate(buffer + pos, tag);␊
591␉}␊
592␉/***** array ****/␊
593␉else if (!strncmp(tagName, kXMLTagArray, sizeof(kXMLTagArray) ))␊
594␉{␊
595␉␉length = ParseTagList(buffer + pos, tag, kTagTypeArray, 0);␊
596␉}␊
597␉else if (!strncmp(tagName, kXMLTagArray " ", strlen(kXMLTagArray " ")))␊
598␉{␊
599␉␉length = ParseTagList(buffer + pos, tag, kTagTypeArray, 0);␊
600␉}␊
601␉else if (!strncmp(tagName, kXMLTagArray "/", strlen(kXMLTagArray "/")))␊
602␉{␊
603␉␉length = ParseTagList(buffer + pos, tag, kTagTypeArray, 1);␊
604␉}␊
605␊
606␉/***** unknown ****/␊
607␉else␊
608␉{␊
609␉␉// it wasn't parsed so we consumed no additional characters␊
610␉␉*tag = 0;␊
611␉␉length = 0;␊
612␉}␊
613␊
614␉if (length == -1)␊
615␉{␊
616␉␉return -1;␊
617␉}␊
618␊
619␉return pos + length;␊
620}␊
621␊
622//==========================================================================␊
623// ParseTagList␊
624␊
625static long ParseTagList( char *buffer, TagPtr *tag, long type, long empty )␊
626{␊
627␉long␉␉pos = 0;␊
628␉long␉␉length = 0;␊
629␉TagPtr␉␉tagList = 0;␊
630␉TagPtr␉␉tmpTag;␊
631␊
632 ␊
633␉if (!empty)␊
634␉{␊
635␉␉while (1)␊
636␉␉{␊
637␉␉␉length = XMLParseNextTag(buffer + pos, &tmpTag);␊
638␉␉␉if (length == -1)␊
639␉␉␉{␊
640␉␉␉␉break;␊
641␉␉␉}␊
642␊
643␉␉␉pos += length;␊
644 ␊
645␉␉␉// detect end of list␊
646␉␉␉if (tmpTag == 0)␊
647␉␉␉{␊
648␉␉␉␉break;␊
649␉␉␉}␊
650␉␉␉tmpTag->tagNext = tagList;␊
651␉␉␉tagList = tmpTag;␊
652␉␉}␊
653␊
654␉␉if (length == -1)␊
655␉␉{␊
656␉␉␉XMLFreeTag(tagList);␊
657␉␉␉return -1;␊
658␉␉}␊
659␉}␊
660 ␊
661␉tmpTag = NewTag();␊
662␉if (tmpTag == 0)␊
663␉{␊
664␉␉XMLFreeTag(tagList);␊
665␉␉return -1;␊
666␉}␊
667␊
668␉tmpTag->type = type;␊
669␉tmpTag->string = 0;␊
670␉tmpTag->offset = buffer_start ? buffer - buffer_start : 0;␊
671␉tmpTag->tag = tagList;␊
672␉tmpTag->tagNext = 0;␊
673␊
674␉*tag = tmpTag;␊
675␊
676␉return pos;␊
677}␊
678␊
679//==========================================================================␊
680// ParseTagKey␊
681␊
682static long ParseTagKey( char *buffer, TagPtr *tag )␊
683{␊
684␉long␉␉length = 0;␊
685␉long␉␉length2 = 0;␊
686␉char␉␉*string;␊
687␉TagPtr␉␉tmpTag;␊
688␉TagPtr␉␉subTag;␊
689 ␊
690␉length = FixDataMatchingTag(buffer, kXMLTagKey);␊
691␉if (length == -1)␊
692␉{␊
693␉␉return -1;␊
694␉}␊
695 ␊
696␉length2 = XMLParseNextTag(buffer + length, &subTag);␊
697␉if (length2 == -1)␊
698␉{␊
699␉␉return -1;␊
700␉}␊
701␊
702␉tmpTag = NewTag();␊
703␉if (tmpTag == 0)␊
704␉{␊
705␉␉XMLFreeTag(subTag);␊
706␉␉return -1;␊
707␉}␊
708 ␊
709␉string = NewSymbol(buffer);␊
710␉if (string == 0)␊
711␉{␊
712␉␉XMLFreeTag(subTag);␊
713␉␉XMLFreeTag(tmpTag);␊
714␉␉return -1;␊
715␉}␊
716 ␊
717␉tmpTag->type = kTagTypeKey;␊
718␉tmpTag->string = string;␊
719␉tmpTag->tag = subTag;␊
720␉tmpTag->offset = buffer_start ? buffer - buffer_start: 0;␊
721␉tmpTag->tagNext = 0;␊
722 ␊
723␉*tag = tmpTag;␊
724␊
725␉return length + length2;␊
726}␊
727␊
728//==========================================================================␊
729// ParseTagString␊
730␊
731static long ParseTagString( char *buffer, TagPtr *tag )␊
732{␊
733␉long␉␉length = 0;␊
734␉char␉␉*string;␊
735 ␊
736␉length = FixDataMatchingTag(buffer, kXMLTagString);␊
737␉if (length == -1)␊
738␉{␊
739␉␉return -1;␊
740␉}␊
741 ␊
742␉TagPtr tmpTag = NewTag();␊
743␉if (tmpTag == 0)␊
744␉{␊
745␉␉return -1;␊
746␉}␊
747␊
748␉string = NewSymbol(buffer);␊
749␉if (string == 0)␊
750␉{␊
751␉␉XMLFreeTag(tmpTag);␊
752␉␉return -1;␊
753␉}␊
754 ␊
755␉tmpTag->type = kTagTypeString;␊
756␉tmpTag->string = string;␊
757␉tmpTag->tag = 0;␊
758␉tmpTag->tagNext = 0;␊
759␉tmpTag->offset = buffer_start ? buffer - buffer_start: 0;␊
760␊
761␉*tag = tmpTag;␊
762␉return length;␊
763}␊
764␊
765//==========================================================================␊
766// ParseTagInteger␊
767␊
768static long ParseTagInteger( char *buffer, TagPtr *tag )␊
769{␊
770␉long length, integer;␊
771␉bool negative = false;␊
772␉TagPtr tmpTag;␊
773␉char* val = buffer;␊
774␉int size;␊
775␊
776␉if(buffer[0] == '<')␊
777␉{␊
778␉␉printf("Warning integer is non existant\n");␊
779␉␉getchar();␊
780␉␉tmpTag = NewTag();␊
781␉␉tmpTag->type = kTagTypeInteger;␊
782␉␉tmpTag->string = 0;␊
783␉␉tmpTag->tag = 0;␊
784␉␉tmpTag->offset = 0;␊
785␉␉tmpTag->tagNext = 0;␊
786␉␉␊
787␉␉*tag = tmpTag;␊
788␉␉␊
789␉␉return 0;␊
790␉}␊
791␊
792␉size = length = FixDataMatchingTag(buffer, kXMLTagInteger);␊
793␉if (length == -1)␊
794␉{␊
795␉␉return -1;␊
796␉}␊
797␊
798␉tmpTag = NewTag();␊
799␊
800␉if (tmpTag == 0)␊
801␉{␊
802␉␉return -1;␊
803␉}␊
804␉integer = 0;␊
805␊
806␉if(size > 1 && (val[1] == 'x' || val[1] == 'X'))␉// Hex value␊
807␉{␊
808␉␉val += 2;␊
809␉␉while(*val)␊
810␉␉{␉␉␉␊
811␉␉␉if ((*val >= '0' && *val <= '9'))␉// 0 - 9␊
812␉␉␉{␊
813␉␉␉␉integer = (integer * 16) + (*val++ - '0');␊
814␉␉␉}␊
815␉␉␉else if ((*val >= 'a' && *val <= 'f'))␉// a - f␊
816␉␉␉{␊
817␉␉␉␉integer = (integer * 16) + (*val++ - 'a' + 10);␊
818␉␉␉}␊
819␉␉␉else if ((*val >= 'A' && *val <= 'F'))␉// A - F␊
820␉␉␉{␊
821␉␉␉␉integer = (integer * 16) + (*val++ - 'A' + 10);␊
822␉␉␉}␊
823␉␉␉else␊
824␉␉␉{␊
825␉␉␉␉printf("ParseTagInteger hex error (0x%x) in buffer %s\n", *val, buffer);␊
826␉␉␉␉getchar();␊
827␉␉␉␉XMLFreeTag(tmpTag);␊
828␉␉␉␉return -1;␊
829␉␉␉}␊
830␉␉}␊
831␉}␊
832␉else if ( size )␉// Decimal value␊
833␉{␊
834␉␉if (*val == '-')␊
835␉␉{␊
836␉␉␉negative = true;␊
837␉␉␉val++;␊
838␉␉␉size--;␊
839␉␉}␊
840␉␉␊
841␉␉for (integer = 0; size > 0; size--)␊
842␉␉{␊
843␉␉␉if(*val) // UGLY HACK, fix me.␊
844␉␉␉{␊
845␉␉␉␉if (*val < '0' || *val > '9')␊
846␉␉␉␉{␊
847␉␉␉␉␉printf("ParseTagInteger decimal error (0x%x) in buffer %s\n", *val, buffer);␊
848␉␉␉␉␉getchar();␊
849␉␉␉␉␉return -1;␊
850␉␉␉␉}␊
851␊
852␉␉␉␉integer = (integer * 10) + (*val++ - '0');␊
853␉␉␉}␊
854␉␉}␊
855␉␉␊
856␉␉if (negative) {␊
857␉␉␉integer = -integer;␊
858␉␉}␊
859␉}␊
860␊
861␉tmpTag->type = kTagTypeInteger;␊
862␉tmpTag->string = (char *)integer;␊
863␉tmpTag->tag = 0;␊
864␉tmpTag->offset = buffer_start ? buffer - buffer_start: 0;␊
865␉tmpTag->tagNext = 0;␊
866␊
867␉*tag = tmpTag;␊
868␊
869␉return length;␊
870}␊
871␊
872//==========================================================================␊
873// ParseTagData␊
874␊
875static long ParseTagData( char *buffer, TagPtr *tag )␊
876{␊
877␉int␉␉actuallen = 0;␊
878␉long␉␉length = 0;␊
879␉TagPtr␉␉tmpTag;␊
880␉char␉␉*string;␊
881␊
882␉length = FixDataMatchingTag(buffer, kXMLTagData);␊
883␉if (length == -1)␊
884␉{␊
885␉␉return -1;␊
886␉}␊
887␊
888␉tmpTag = NewTag();␊
889␉if (tmpTag == 0)␊
890␉{␊
891␉␉return -1;␊
892␉}␊
893␊
894␉//printf("ParseTagData unimplimented\n");␊
895␉//printf("Data: %s\n", buffer);␊
896␉//␉getchar();␊
897␊
898␉string = BASE64Decode(buffer, strlen(buffer), &actuallen);␊
899␉tmpTag->type = kTagTypeData;␊
900␉tmpTag->string = string;␊
901␊
902␉tmpTag->tag = 0;␊
903␉tmpTag->offset = actuallen; // buffer_start ? buffer - buffer_start: 0;␊
904␊
905␉tmpTag->tagNext = 0;␊
906␊
907␉*tag = tmpTag;␊
908␊
909␉return length;␊
910}␊
911␊
912//==========================================================================␊
913// ParseTagDate␊
914␊
915static long ParseTagDate( char *buffer, TagPtr *tag )␊
916{␊
917␉long␉␉length = 0;␊
918␉TagPtr␉␉tmpTag;␊
919␊
920␉length = FixDataMatchingTag(buffer, kXMLTagDate);␊
921␉if (length == -1)␊
922␉{␊
923␉␉return -1;␊
924␉}␊
925␊
926␉tmpTag = NewTag();␊
927␉if (tmpTag == 0)␊
928␉{␊
929␉␉return -1;␊
930␉}␊
931␊
932␉printf("ParseTagDate unimplimented\n");␊
933␉getchar();␊
934␊
935␉tmpTag->type = kTagTypeDate;␊
936␉tmpTag->string = 0;␊
937␉tmpTag->tag = 0;␊
938␉tmpTag->tagNext = 0;␊
939␉tmpTag->offset = buffer_start ? buffer - buffer_start: 0;␊
940␊
941␉*tag = tmpTag;␊
942␊
943␉return length;␊
944}␊
945␊
946//==========================================================================␊
947// ParseTagBoolean␊
948␊
949long ParseTagBoolean( char *buffer, TagPtr *tag, long type )␊
950{␊
951␉TagPtr tmpTag;␊
952␊
953␉tmpTag = NewTag();␊
954␉if (tmpTag == 0)␊
955␉{␊
956␉␉return -1;␊
957␉}␊
958␊
959␉tmpTag->type = type;␊
960␉tmpTag->string = 0;␊
961␉tmpTag->tag = 0;␊
962␉tmpTag->tagNext = 0;␊
963␉tmpTag->offset = buffer_start ? buffer - buffer_start: 0;␊
964␊
965␉*tag = tmpTag;␊
966␊
967␉return 0;␊
968}␊
969␊
970//==========================================================================␊
971// GetNextTag␊
972␊
973static long GetNextTag( char *buffer, char **tag, long *start )␊
974{␊
975␉long␉cnt;␊
976␉long␉cnt2;␊
977␊
978␉if (tag == 0)␊
979␉{␊
980␉␉return -1;␊
981␉}␊
982␊
983␉// Find the start of the tag.␊
984␉cnt = 0;␊
985␉while ((buffer[cnt] != '\0') && (buffer[cnt] != '<'))␊
986␉{␊
987␉␉cnt++;␊
988␉}␊
989␊
990␉if (buffer[cnt] == '\0')␊
991␉{␊
992␉␉return -1;␊
993␉}␊
994␉// Find the end of the tag.␊
995␉cnt2 = cnt + 1;␊
996␉while ((buffer[cnt2] != '\0') && (buffer[cnt2] != '>'))␊
997␉{␊
998␉␉cnt2++;␊
999␉}␊
1000␊
1001␉if (buffer[cnt2] == '\0')␊
1002␉{␊
1003␉␉return -1;␊
1004␉}␊
1005␊
1006␉// Fix the tag data.␊
1007␉*tag = buffer + cnt + 1;␊
1008␉buffer[cnt2] = '\0';␊
1009␉if (start)␊
1010␉{␊
1011␉␉*start = cnt;␊
1012␉}␊
1013␊
1014␉return cnt2 + 1;␊
1015}␊
1016␊
1017//==========================================================================␊
1018// FixDataMatchingTag␊
1019// Modifies 'buffer' to add a '\0' at the end of the tag matching 'tag'.␊
1020// Returns the length of the data found, counting the end tag,␊
1021// or -1 if the end tag was not found.␊
1022␊
1023static long FixDataMatchingTag( char *buffer, char *tag )␊
1024{␊
1025␉long␉length;␊
1026␉long␉start;␊
1027␉long␉stop;␊
1028␉char␉*endTag;␊
1029␊
1030␉start = 0;␊
1031␉while (1)␊
1032␉{␊
1033␉␉length = GetNextTag(buffer + start, &endTag, &stop);␊
1034␉␉if (length == -1)␊
1035␉␉{␊
1036␉␉␉return -1;␊
1037␉␉}␊
1038␊
1039␉␉if ((*endTag == '/') && !strcmp(endTag + 1, tag))␊
1040␉␉{␊
1041␉␉␉break;␊
1042␉␉}␊
1043␊
1044␉␉start += length;␊
1045␉}␊
1046␊
1047␉buffer[start + stop] = '\0';␊
1048␊
1049␉return start + length;␊
1050}␊
1051␊
1052//==========================================================================␊
1053// NewTag␊
1054␊
1055#define kTagsPerBlock (0x1000)␊
1056␊
1057static TagPtr gTagsFree;␊
1058␊
1059static TagPtr NewTag( void )␊
1060{␊
1061␉long␉␉cnt;␊
1062␉TagPtr␉␉tag;␊
1063 ␊
1064␉if (gTagsFree == 0)␊
1065␉{␊
1066␉␉tag = (TagPtr)malloc(kTagsPerBlock *sizeof(Tag));␊
1067␉␉if (tag == 0)␊
1068␉␉{␊
1069␉␉␉return 0;␊
1070␉␉}␊
1071␊
1072␉␉// Initalize the new tags.␊
1073␉␉for (cnt = 0; cnt < kTagsPerBlock; cnt++)␊
1074␉␉{␊
1075␉␉␉tag[cnt].type = kTagTypeNone;␊
1076␉␉␉tag[cnt].string = 0;␊
1077␉␉␉tag[cnt].tag = 0;␊
1078␉␉␉tag[cnt].tagNext = tag + cnt + 1;␊
1079␉␉}␊
1080␉␉tag[kTagsPerBlock - 1].tagNext = 0;␊
1081␊
1082␉␉gTagsFree = tag;␊
1083␉}␊
1084␊
1085␉tag = gTagsFree;␊
1086␉gTagsFree = tag->tagNext;␊
1087␊
1088␉return tag;␊
1089}␊
1090␊
1091//==========================================================================␊
1092// XMLFreeTag␊
1093␊
1094void XMLFreeTag( TagPtr tag )␊
1095{␊
1096#if DOFREE␊
1097␉if (tag == 0)␊
1098␉{␊
1099␉␉return;␊
1100␉}␊
1101 ␊
1102␉if (!XMLIsInteger(tag) && tag->string)␊
1103␉{␊
1104␉␉FreeSymbol(tag->string);␊
1105␉}␊
1106␊
1107␉XMLFreeTag(tag->tag);␊
1108␉XMLFreeTag(tag->tagNext);␊
1109 ␊
1110␉// Clear and free the tag.␊
1111␉tag->type = kTagTypeNone;␊
1112␉tag->string = 0;␊
1113␉tag->tag = 0;␊
1114␉tag->offset = 0;␊
1115␉tag->tagNext = gTagsFree;␊
1116␉gTagsFree = tag;␊
1117#else␊
1118␉return;␊
1119#endif␊
1120}␊
1121␊
1122//==========================================================================␊
1123// Symbol object.␊
1124␊
1125struct Symbol␊
1126{␊
1127␉long refCount;␊
1128␉struct Symbol *next;␊
1129␉char string[];␊
1130};␊
1131typedef struct Symbol Symbol, *SymbolPtr;␊
1132␊
1133static SymbolPtr FindSymbol(char *string, SymbolPtr *prevSymbol);␊
1134␊
1135static SymbolPtr gSymbolsHead;␊
1136␊
1137//==========================================================================␊
1138// NewSymbol␊
1139␊
1140static char *NewSymbol( char *string )␊
1141{␊
1142␉static SymbolPtr lastGuy = 0;␊
1143␊
1144␉SymbolPtr␉symbol;␊
1145␊
1146␉// Look for string in the list of symbols.␊
1147␉symbol = FindSymbol(string, 0);␊
1148␊
1149␉// Add the new symbol.␊
1150␉if (symbol == 0)␊
1151␉{␊
1152␉␉symbol = (SymbolPtr)malloc(sizeof(Symbol) + 1 + strlen(string));␊
1153␉␉if (symbol == 0)␊
1154␉␉{␉//return 0;␊
1155␉␉␉stop("NULL symbol!");␊
1156␉␉}␊
1157␊
1158␉␉// Set the symbol's data.␊
1159␉␉symbol->refCount = 0;␊
1160␉␉strcpy(symbol->string, string);␊
1161␊
1162␉␉// Add the symbol to the list.␊
1163␉␉symbol->next = gSymbolsHead;␊
1164␉␉gSymbolsHead = symbol;␊
1165␉}␊
1166␊
1167␉// Update the refCount and return the string.␊
1168␉symbol->refCount++;␊
1169␊
1170␉if (lastGuy && lastGuy->next != 0)␊
1171␉{␊
1172␉␉stop("last guy not last!");␊
1173␉}␊
1174␊
1175␉return symbol->string;␊
1176}␊
1177␊
1178//==========================================================================␊
1179// FreeSymbol␊
1180␊
1181#if DOFREE␊
1182static void FreeSymbol( char *string )␊
1183{␊
1184␉SymbolPtr symbol, prev;␊
1185␉prev = 0;␊
1186␊
1187␉// Look for string in the list of symbols.␊
1188␉symbol = FindSymbol(string, &prev);␊
1189␉if (symbol == 0)␊
1190␉{␊
1191␉␉return;␊
1192␉}␊
1193␊
1194␉// Update the refCount.␊
1195␉symbol->refCount--;␊
1196␊
1197␉if (symbol->refCount != 0)␊
1198␉{␊
1199␉␉return;␊
1200␉}␊
1201␊
1202␉// Remove the symbol from the list.␊
1203␉if (prev != 0)␊
1204␉{␊
1205␉␉prev->next = symbol->next;␊
1206␉}␊
1207␉else␊
1208␉{␊
1209␉␉gSymbolsHead = symbol->next;␊
1210␉}␊
1211␊
1212␉// Free the symbol's memory.␊
1213␉free(symbol);␊
1214}␊
1215#endif␊
1216␊
1217//==========================================================================␊
1218// FindSymbol␊
1219␊
1220static SymbolPtr FindSymbol( char *string, SymbolPtr *prevSymbol )␊
1221{␊
1222␉SymbolPtr symbol, prev;␊
1223␊
1224␉symbol = gSymbolsHead;␊
1225␉prev = 0;␊
1226 ␊
1227␉while (symbol != NULL)␊
1228␉{␊
1229␉␉if (!strcmp(symbol->string, string))␊
1230␉␉{␊
1231␉␉␉break;␊
1232␉␉}␊
1233 ␊
1234␉␉prev = symbol;␊
1235␉␉symbol = symbol->next;␊
1236␉}␊
1237 ␊
1238␉if ((symbol != 0) && (prevSymbol != 0))␊
1239␉{␊
1240␉␉*prevSymbol = prev;␊
1241␉}␊
1242␊
1243␉return symbol;␊
1244}␊
1245␊
1246bool XMLIsType(TagPtr dict, enum xmltype type)␊
1247{␊
1248␉if(!dict)␊
1249␉{␊
1250␉␉return (type == kTagTypeNone);␊
1251␉}␊
1252␉return (dict->type == type);␊
1253}␊
1254␊
1255/*** Cast functions ***/␊
1256bool XMLIsArray(TagPtr entry)␊
1257{␊
1258␉return entry && (entry->type == kTagTypeArray);␊
1259}␊
1260␊
1261TagPtr XMLCastArray(TagPtr dict)␊
1262{␊
1263␉if(!dict)␊
1264␉{␊
1265␉␉return NULL;␊
1266␉}␊
1267␊
1268␉if(dict->type == kTagTypeArray)␊
1269␉{␊
1270␉␉return dict;␊
1271␉} else {␊
1272␉␉return NULL;␊
1273␉}␊
1274}␊
1275␊
1276bool XMLIsDict(TagPtr entry)␊
1277{␊
1278 return entry && (entry->type == kTagTypeDict);␊
1279}␊
1280␊
1281bool XMLIsData(TagPtr entry)␊
1282{␊
1283␉return entry && (entry->type == kTagTypeData);␊
1284}␊
1285␊
1286TagPtr XMLCastDict(TagPtr dict)␊
1287{␊
1288␉if(!dict)␊
1289␉{␊
1290␉␉return NULL;␊
1291␉}␊
1292␊
1293␉if(dict->type == kTagTypeDict)␊
1294␉{␊
1295␉␉return dict;␊
1296␉}␊
1297␉else␊
1298␉{␊
1299␉␉return NULL;␊
1300␉}␊
1301}␊
1302␊
1303bool XMLIsString(TagPtr entry)␊
1304{␊
1305 return entry && ((entry->type == kTagTypeString) || (entry->type == kTagTypeKey));␊
1306}␊
1307␊
1308char *XMLCastString(TagPtr dict)␊
1309{␊
1310␉if(!dict)␊
1311␉{␊
1312␉␉return NULL;␊
1313␉}␊
1314␊
1315␉if((dict->type == kTagTypeString) || (dict->type == kTagTypeKey))␊
1316␉{␊
1317␉␉return dict->string;␊
1318␉}␊
1319␊
1320␉return NULL;␊
1321}␊
1322␊
1323char *XMLCastData(TagPtr dict, int* length)␊
1324{␊
1325␉if(!dict)␊
1326␉{␊
1327␉␉return NULL;␊
1328␉}␊
1329␊
1330␉if((dict->type == kTagTypeData) || (dict->type == kTagTypeKey))␊
1331␉{␊
1332␉␉*length = dict->offset;␊
1333␉␉return dict->string;␊
1334␉}␊
1335␉*length = 0;␊
1336␉return NULL;␊
1337}␊
1338␊
1339␊
1340long XMLCastStringOffset(TagPtr dict)␊
1341{␊
1342␉if(dict && ((dict->type == kTagTypeString) || (dict->type == kTagTypeKey)))␊
1343␉{␊
1344␉␉return dict->offset;␊
1345␉}␊
1346␉else␊
1347␉{␊
1348␉␉return -1;␊
1349␉}␊
1350}␊
1351␊
1352bool XMLIsBoolean(TagPtr entry)␊
1353{␊
1354␉return entry && ((entry->type == kTagTypeTrue) || (entry->type == kTagTypeFalse));␊
1355}␊
1356␊
1357bool XMLCastBoolean(TagPtr dict)␊
1358{␊
1359␉if(!dict)␊
1360␉{␊
1361␉␉return false;␊
1362␉}␊
1363␊
1364␉if(dict->type == kTagTypeTrue)␊
1365␉{␊
1366␉␉return true;␊
1367␉}␊
1368␉return false;␊
1369}␊
1370␊
1371bool XMLIsInteger(TagPtr entry)␊
1372{␊
1373 return entry && (entry->type == kTagTypeInteger);␊
1374}␊
1375␊
1376int XMLCastInteger(TagPtr dict)␊
1377{␊
1378␉if(!dict)␊
1379␉{␊
1380␉␉//printf("XMLCastInteger: null dict\n");␊
1381␉␉return 0;␊
1382␉}␊
1383␊
1384␉if(dict->type == kTagTypeInteger)␊
1385␉{␊
1386␉␉return (int)(dict->string);␊
1387␉}␊
1388␉return 0;␊
1389}␊
1390␊
1391bool XMLAddTagToDictionary(TagPtr dict, char *key, TagPtr value)␊
1392{␊
1393␉if (!dict || dict->type != kTagTypeDict)␊
1394␉{␊
1395␉␉return false;␊
1396␉}␊
1397␊
1398␉TagPtr tmpTag;␊
1399␉char* string;␊
1400␊
1401␉tmpTag = NewTag();␊
1402␉if (tmpTag == 0)␊
1403␉{␊
1404␉␉return false;␊
1405␉}␊
1406␊
1407␉string = NewSymbol(key);␊
1408␉if (string == 0)␊
1409␉{␊
1410␉␉XMLFreeTag(tmpTag);␊
1411␉␉return false;␊
1412␉}␊
1413␊
1414␉tmpTag->type = kTagTypeKey;␊
1415␉tmpTag->string = string;␊
1416␉tmpTag->tag = value;␊
1417␉tmpTag->offset = 0;␊
1418␉tmpTag->tagNext = 0;␊
1419␊
1420␉TagPtr tagList = dict->tag;␊
1421␉if(!tagList)␊
1422␉{␊
1423␉␉// First tag␊
1424␉␉dict->tag = tmpTag;␊
1425␉␉return true;␊
1426␉}␊
1427␉while(tagList && tagList->tagNext) tagList = tagList->tagNext;␊
1428␉if(tagList)␊
1429␉{␊
1430␉␉tagList->tagNext = tmpTag;␊
1431␉␉return true;␊
1432␉}␊
1433␊
1434␉XMLFreeTag(tmpTag);␊
1435␉return false;␊
1436}␊
1437

Archive Download this file

Revision: 2618