Chameleon

Chameleon Svn Source Tree

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

Archive Download this file

Revision: 2341