Routino SVN Repository Browser

Check out the latest version of Routino: svn co http://routino.org/svn/trunk routino

/[routino]/trunk/src/xmlparse.l
ViewVC logotype

Contents of /trunk/src/xmlparse.l

Parent Directory Parent Directory | Revision Log Revision Log

Revision 389 - (show annotations) (download)
Fri May 14 17:55:56 2010 UTC (14 years, 10 months ago) by amb
File size: 23630 byte(s) 
Allow empty strings to be returned.
1 %{
2 /***************************************
3 $Header: /home/amb/CVS/routino/src/xmlparse.l,v 1.14 2010-05-14 17:55:56 amb Exp $
4
5 A simple generic XML parser where the structure comes from the function parameters.
6 Not intended to be fully conforming to XML staandard or a validating parser but
7 sufficient to parse OSM XML and simple program configuration files.
8
9 Part of the Routino routing software.
10 ******************/ /******************
11 This file Copyright 2010 Andrew M. Bishop
12
13 This program is free software: you can redistribute it and/or modify
14 it under the terms of the GNU Affero General Public License as published by
15 the Free Software Foundation, either version 3 of the License, or
16 (at your option) any later version.
17
18 This program is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU Affero General Public License for more details.
22
23 You should have received a copy of the GNU Affero General Public License
24 along with this program. If not, see <http://www.gnu.org/licenses/>.
25 ***************************************/
26
27
28 #include <stdio.h>
29 #include <stdlib.h>
30 #include <ctype.h>
31 #include <string.h>
32
33 #include "xmlparse.h"
34
35
36 /* Parser outputs */
37
38 #define LEX_EOF 0
39
40 #define LEX_TAG_BEGIN 1
41 #define LEX_XML_DECL_BEGIN 2
42 #define LEX_TAG_POP 3
43 #define LEX_TAG_PUSH 4
44 #define LEX_XML_DECL_FINISH 6
45 #define LEX_TAG_FINISH 7
46 #define LEX_ATTR_KEY 8
47 #define LEX_ATTR_VAL 9
48
49 #define LEX_ERROR 100
50
51 #define LEX_ERROR_TAG_START 101
52 #define LEX_ERROR_XML_DECL_START 102
53 #define LEX_ERROR_TAG 103
54 #define LEX_ERROR_XML_DECL 104
55 #define LEX_ERROR_ATTR 105
56 #define LEX_ERROR_END_TAG 106
57 #define LEX_ERROR_COMMENT 107
58 #define LEX_ERROR_CLOSE 108
59 #define LEX_ERROR_ATTR_VAL 109
60 #define LEX_ERROR_ENTITY_REF 110
61 #define LEX_ERROR_CHAR_REF 111
62
63 #define LEX_ERROR_UNEXP_TAG 201
64 #define LEX_ERROR_UNBALANCED 202
65 #define LEX_ERROR_NO_START 203
66 #define LEX_ERROR_UNEXP_ATT 204
67 #define LEX_ERROR_UNEXP_EOF 205
68 #define LEX_ERROR_XML_NOT_FIRST 206
69
70 #define LEX_ERROR_CALLBACK 255
71
72
73 /* Lexer definitions */
74
75 #define YY_SKIP_YYWRAP 1 /* Remove error with prototype of ..._yywrap */
76 #ifndef yywrap
77 /*+ Needed in lex but does nothing. +*/
78 #define yywrap() 1
79 #endif
80
81 /*+ Reset the current string. +*/
82 #define reset_string \
83 if(!string) string=(char*)malloc(16); \
84 *string=0; \
85 stringused=0;
86
87 /*+ append information to the current string. +*/
88 #define append_string(xx) \
89 newlen=strlen(xx); \
90 if((stringused+newlen)>=stringlen) \
91 string=(char*)realloc((void*)string,stringlen=(stringused+newlen+16)); \
92 strcpy(string+stringused,xx); \
93 stringused+=newlen;
94
95 #define YY_NO_INPUT
96
97
98 /* Lexer functions and variables */
99
100 extern int yylex(void);
101
102 static char *yylval=NULL;
103
104 static int xmlparse_options;
105
106 %}
107
108 %option 8bit
109 %option pointer
110 %option batch
111 %option yylineno
112
113 %option nodefault
114 %option perf-report
115 %option fast
116 %option nounput
117
118
119 /* Grammar based on http://www.w3.org/TR/2004/REC-xml-20040204/ but for ASCII not Unicode. */
120
121 S [ \t\r\n]
122
123 letter [a-zA-Z]
124 digit [0-9]
125 xdigit [a-fA-F0-9]
126
127 namechar ({letter}|{digit}|[-._:])
128 name ({letter}|[_:]){namechar}*
129
130 entityref &{name};
131 charref &#({digit}+|x{xdigit}+);
132
133
134 %x COMMENT
135 %x CDATA
136 %x DOCTYPE
137 %x XML_DECL_START XML_DECL
138 %x TAG_START TAG
139 %x ATTR_KEY ATTR_VAL
140 %x END_TAG1 END_TAG2
141 %x DQUOTED SQUOTED
142
143 %%
144 /* Must use static variables since the parser returns often. */
145 static char *string=NULL;
146 static int stringlen=0,stringused=0;
147 static int after_attr=0;
148 int newlen;
149 int doctype_depth=0;
150
151 /* Handle top level entities */
152
153 "<!--" { BEGIN(COMMENT); }
154 "<![CDATA[" { BEGIN(CDATA); }
155 "<!DOCTYPE" { BEGIN(DOCTYPE); doctype_depth=0; }
156 "</" { BEGIN(END_TAG1); }
157 "<?" { BEGIN(XML_DECL_START); }
158 "<" { BEGIN(TAG_START); }
159 ">" { return(LEX_ERROR_CLOSE); }
160 [^<>]+ { }
161
162 /* Comments */
163
164 <COMMENT>"--->" { return(LEX_ERROR_COMMENT); }
165 <COMMENT>"-->" { BEGIN(INITIAL); }
166 <COMMENT>"--"[^->]+ { }
167 <COMMENT>[^-]+ { }
168 <COMMENT>"-" { }
169
170 /* CDATA */
171
172 <CDATA>"]]>" { BEGIN(INITIAL); }
173 <CDATA>"]" { }
174 <CDATA>[^]]+ { }
175
176 /* CDATA */
177
178 <DOCTYPE>"<" { doctype_depth++; }
179 <DOCTYPE>">" { if(doctype_depth==0) BEGIN(INITIAL); else doctype_depth--; }
180 <DOCTYPE>[^<>]+ { }
181
182 /* XML Declaration start */
183
184 <XML_DECL_START>{name} { BEGIN(XML_DECL); yylval=yytext; return(LEX_XML_DECL_BEGIN); }
185 <XML_DECL_START>.|\n { return(LEX_ERROR_XML_DECL_START); }
186
187 /* Tag middle */
188
189 <XML_DECL>"?>" { BEGIN(INITIAL); return(LEX_XML_DECL_FINISH); }
190 <XML_DECL>{S}+ { }
191 <XML_DECL>{name} { after_attr=XML_DECL; BEGIN(ATTR_KEY); yylval=yytext; return(LEX_ATTR_KEY); }
192 <XML_DECL>.|\n { return(LEX_ERROR_XML_DECL); }
193
194 /* Any tag start */
195
196 <TAG_START>{name} { BEGIN(TAG); yylval=yytext; return(LEX_TAG_BEGIN); }
197 <TAG_START>.|\n { return(LEX_ERROR_TAG_START); }
198
199 /* End-tag start */
200
201 <END_TAG1>{name} { BEGIN(END_TAG2); yylval=yytext; return(LEX_TAG_POP); }
202 <END_TAG1>.|\n { return(LEX_ERROR_END_TAG); }
203
204 <END_TAG2>">" { BEGIN(INITIAL); }
205 <END_TAG2>.|\n { return(LEX_ERROR_END_TAG); }
206
207 /* Any tag middle */
208
209 <TAG>"/>" { BEGIN(INITIAL); return(LEX_TAG_FINISH); }
210 <TAG>">" { BEGIN(INITIAL); return(LEX_TAG_PUSH); }
211 <TAG>{S}+ { }
212 <TAG>{name} { after_attr=TAG; BEGIN(ATTR_KEY); yylval=yytext; return(LEX_ATTR_KEY); }
213 <TAG>.|\n { return(LEX_ERROR_TAG); }
214
215 /* Attributes */
216
217 <ATTR_KEY>= { BEGIN(ATTR_VAL); }
218 <ATTR_KEY>.|\n { return(LEX_ERROR_ATTR); }
219
220 <ATTR_VAL>\" { BEGIN(DQUOTED); reset_string; }
221 <ATTR_VAL>\' { BEGIN(SQUOTED); reset_string; }
222 <ATTR_VAL>.|\n { return(LEX_ERROR_ATTR); }
223
224 /* Quoted strings */
225
226 <DQUOTED>\" { BEGIN(after_attr); yylval=string; return(LEX_ATTR_VAL); }
227 <DQUOTED>{entityref} { if(xmlparse_options&XMLPARSE_RETURN_ATTR_ENCODED) {append_string(yytext);}
228 else { const char *str=ParseXML_Decode_Entity_Ref(yytext); if(str) {append_string(str);} else {yylval=yytext; return(LEX_ERROR_ENTITY_REF);} } }
229 <DQUOTED>{charref} { if(xmlparse_options&XMLPARSE_RETURN_ATTR_ENCODED) {append_string(yytext);}
230 else { const char *str=ParseXML_Decode_Char_Ref(yytext); if(str) {append_string(str);} else {yylval=yytext; return(LEX_ERROR_CHAR_REF);} } }
231 <DQUOTED>[<>&] { yylval=yytext; return(LEX_ERROR_ATTR_VAL); }
232 <DQUOTED>[^<>&\"]+ { append_string(yytext); }
233
234 <SQUOTED>\' { BEGIN(after_attr); yylval=string; return(LEX_ATTR_VAL); }
235 <SQUOTED>{entityref} { if(xmlparse_options&XMLPARSE_RETURN_ATTR_ENCODED) {append_string(yytext);}
236 else { const char *str=ParseXML_Decode_Entity_Ref(yytext); if(str) {append_string(str);} else {yylval=yytext; return(LEX_ERROR_ENTITY_REF);} } }
237 <SQUOTED>{charref} { if(xmlparse_options&XMLPARSE_RETURN_ATTR_ENCODED) {append_string(yytext);}
238 else { const char *str=ParseXML_Decode_Char_Ref(yytext); if(str) {append_string(str);} else {yylval=yytext; return(LEX_ERROR_CHAR_REF);} } }
239 <SQUOTED>[<>&] { yylval=yytext; return(LEX_ERROR_ATTR_VAL); }
240 <SQUOTED>[^<>&\']+ { append_string(yytext); }
241
242 /* End of file */
243
244 <<EOF>> { free(string); string=NULL; stringlen=stringused=0; BEGIN(INITIAL); return(LEX_EOF); }
245
246 %%
247
248
249 /*++++++++++++++++++++++++++++++++++++++
250 A function to call the callback function with the parameters needed.
251
252 int call_callback Returns 1 if the callback returned with an error.
253
254 const char *name The name of the tag.
255
256 int (*callback)() The callback function.
257
258 int type The type of tag (start and/or end).
259
260 int nattributes The number of attributes collected.
261
262 char *attributes[XMLPARSE_MAX_ATTRS] The list of attributes.
263 ++++++++++++++++++++++++++++++++++++++*/
264
265 static inline int call_callback(const char *name,int (*callback)(),int type,int nattributes,char *attributes[XMLPARSE_MAX_ATTRS])
266 {
267 switch(nattributes)
268 {
269 case 0: return (*callback)(name,type);
270 case 1: return (*callback)(name,type,attributes[0]);
271 case 2: return (*callback)(name,type,attributes[0],attributes[1]);
272 case 3: return (*callback)(name,type,attributes[0],attributes[1],attributes[2]);
273 case 4: return (*callback)(name,type,attributes[0],attributes[1],attributes[2],attributes[3]);
274 case 5: return (*callback)(name,type,attributes[0],attributes[1],attributes[2],attributes[3],attributes[4]);
275 case 6: return (*callback)(name,type,attributes[0],attributes[1],attributes[2],attributes[3],attributes[4],attributes[5]);
276 case 7: return (*callback)(name,type,attributes[0],attributes[1],attributes[2],attributes[3],attributes[4],attributes[5],attributes[6]);
277 case 8: return (*callback)(name,type,attributes[0],attributes[1],attributes[2],attributes[3],attributes[4],attributes[5],attributes[6],attributes[7]);
278 case 9: return (*callback)(name,type,attributes[0],attributes[1],attributes[2],attributes[3],attributes[4],attributes[5],attributes[6],attributes[7],attributes[8]);
279 case 10: return (*callback)(name,type,attributes[0],attributes[1],attributes[2],attributes[3],attributes[4],attributes[5],attributes[6],attributes[7],attributes[8],attributes[9]);
280 case 11: return (*callback)(name,type,attributes[0],attributes[1],attributes[2],attributes[3],attributes[4],attributes[5],attributes[6],attributes[7],attributes[8],attributes[9],attributes[10]);
281 case 12: return (*callback)(name,type,attributes[0],attributes[1],attributes[2],attributes[3],attributes[4],attributes[5],attributes[6],attributes[7],attributes[8],attributes[9],attributes[10],attributes[11]);
282 case 13: return (*callback)(name,type,attributes[0],attributes[1],attributes[2],attributes[3],attributes[4],attributes[5],attributes[6],attributes[7],attributes[8],attributes[9],attributes[10],attributes[11],attributes[12]);
283 case 14: return (*callback)(name,type,attributes[0],attributes[1],attributes[2],attributes[3],attributes[4],attributes[5],attributes[6],attributes[7],attributes[8],attributes[9],attributes[10],attributes[11],attributes[12],attributes[13]);
284 case 15: return (*callback)(name,type,attributes[0],attributes[1],attributes[2],attributes[3],attributes[4],attributes[5],attributes[6],attributes[7],attributes[8],attributes[9],attributes[10],attributes[11],attributes[12],attributes[13],attributes[14]);
285 case 16: return (*callback)(name,type,attributes[0],attributes[1],attributes[2],attributes[3],attributes[4],attributes[5],attributes[6],attributes[7],attributes[8],attributes[9],attributes[10],attributes[11],attributes[12],attributes[13],attributes[14],attributes[15]);
286
287 default:
288 fprintf(stderr,"XML Parser: Error on line %d: too many attributes for tag '%s' source code needs changing.\n",yylineno,name);
289 exit(1);
290 }
291 }
292
293
294 /*++++++++++++++++++++++++++++++++++++++
295 Parse the XML and call the functions for each tag as seen.
296
297 int ParseXML Returns 0 if OK or something else in case of an error.
298
299 FILE *file The file to parse.
300
301 xmltag **tags The array of pointers to tags for the top level.
302
303 int options A list of XML Parser options OR-ed together.
304 ++++++++++++++++++++++++++++++++++++++*/
305
306 int ParseXML(FILE *file,xmltag **tags,int options)
307 {
308 int yychar,i;
309
310 char *attributes[XMLPARSE_MAX_ATTRS]={NULL};
311 int attribute=0;
312
313 int stackdepth=0,stackused=0;
314 xmltag ***tags_stack=NULL;
315 xmltag **tag_stack=NULL;
316 xmltag *tag=NULL;
317
318 /* The actual parser. */
319
320 xmlparse_options=options;
321
322 yyin=file;
323
324 yyrestart(yyin);
325
326 BEGIN(INITIAL);
327
328 do
329 {
330 yychar=yylex();
331
332 switch(yychar)
333 {
334 /* The start of a tag for an XML declaration */
335
336 case LEX_XML_DECL_BEGIN:
337
338 if(tag_stack)
339 {
340 fprintf(stderr,"XML Parser: Error on line %d: XML declaration not before all other tags.\n",yylineno);
341 yychar=LEX_ERROR_XML_NOT_FIRST;
342 break;
343 }
344
345 /* The start of a tag for an element */
346
347 case LEX_TAG_BEGIN:
348
349 tag=NULL;
350
351 for(i=0;tags[i];i++)
352 if(!strcasecmp(yylval,tags[i]->name))
353 {
354 tag=tags[i];
355
356 for(i=0;i<tag->nattributes;i++)
357 if(attributes[i])
358 {
359 free(attributes[i]);
360 attributes[i]=NULL;
361 }
362
363 break;
364 }
365
366 if(tag==NULL)
367 {
368 fprintf(stderr,"XML Parser: Error on line %d: unexpected tag '%s'.\n",yylineno,yylval);
369 yychar=LEX_ERROR_UNEXP_TAG;
370 }
371
372 break;
373
374 /* The end of the start-tag for an element */
375
376 case LEX_TAG_PUSH:
377
378 if(stackused==stackdepth)
379 {
380 tag_stack =(xmltag**) realloc((void*)tag_stack ,(stackdepth+=8)*sizeof(xmltag*));
381 tags_stack=(xmltag***)realloc((void*)tags_stack,(stackdepth+=8)*sizeof(xmltag**));
382 }
383
384 tag_stack [stackused]=tag;
385 tags_stack[stackused]=tags;
386 stackused++;
387
388 if(tag->callback)
389 if(call_callback(tag->name,tag->callback,XMLPARSE_TAG_START,tag->nattributes,attributes))
390 yychar=LEX_ERROR_CALLBACK;
391
392 tags=tag->subtags;
393
394 break;
395
396 /* The end of the empty-element-tag for an XML declaration */
397
398 case LEX_XML_DECL_FINISH:
399
400 /* The end of the empty-element-tag for an element */
401
402 case LEX_TAG_FINISH:
403
404 if(tag->callback)
405 if(call_callback(tag->name,tag->callback,XMLPARSE_TAG_START|XMLPARSE_TAG_END,tag->nattributes,attributes))
406 yychar=LEX_ERROR_CALLBACK;
407
408 if(stackused>0)
409 tag=tag_stack[stackused-1];
410 else
411 tag=NULL;
412
413 break;
414
415 /* The end of the end-tag for an element */
416
417 case LEX_TAG_POP:
418
419 stackused--;
420 tags=tags_stack[stackused];
421 tag =tag_stack [stackused];
422
423 if(strcmp(tag->name,yylval))
424 {
425 fprintf(stderr,"XML Parser: Error on line %d: end tag '</%s>' doesn't match start tag '<%s ...>'.\n",yylineno,yylval,tag->name);
426 yychar=LEX_ERROR_UNBALANCED;
427 }
428
429 if(stackused<0)
430 {
431 fprintf(stderr,"XML Parser: Error on line %d: end tag '</%s>' seen but there was no start tag '<%s ...>'.\n",yylineno,yylval,yylval);
432 yychar=LEX_ERROR_NO_START;
433 }
434
435 for(i=0;i<tag->nattributes;i++)
436 if(attributes[i])
437 {
438 free(attributes[i]);
439 attributes[i]=NULL;
440 }
441
442 if(tag->callback)
443 if(call_callback(tag->name,tag->callback,XMLPARSE_TAG_END,tag->nattributes,attributes))
444 yychar=LEX_ERROR_CALLBACK;
445
446 if(stackused>0)
447 tag=tag_stack[stackused-1];
448 else
449 tag=NULL;
450
451 break;
452
453 /* An attribute key */
454
455 case LEX_ATTR_KEY:
456
457 attribute=-1;
458
459 for(i=0;i<tag->nattributes;i++)
460 if(!strcasecmp(yylval,tag->attributes[i]))
461 {
462 attribute=i;
463
464 break;
465 }
466
467 if(attribute==-1)
468 {
469 if((options&XMLPARSE_UNKNOWN_ATTRIBUTES)==XMLPARSE_UNKNOWN_ATTR_ERROR ||
470 ((options&XMLPARSE_UNKNOWN_ATTRIBUTES)==XMLPARSE_UNKNOWN_ATTR_ERRNONAME && !strchr(yylval,':')))
471 {
472 fprintf(stderr,"XML Parser: Error on line %d: unexpected attribute '%s' for tag '%s'.\n",yylineno,yylval,tag->name);
473 yychar=LEX_ERROR_UNEXP_ATT;
474 }
475 else if((options&XMLPARSE_UNKNOWN_ATTRIBUTES)==XMLPARSE_UNKNOWN_ATTR_WARN)
476 fprintf(stderr,"XML Parser: Warning on line %d: unexpected attribute '%s' for tag '%s'.\n",yylineno,yylval,tag->name);
477 }
478
479 break;
480
481 /* An attribute value */
482
483 case LEX_ATTR_VAL:
484
485 if(tag->callback && attribute!=-1 && yylval)
486 attributes[attribute]=strcpy(malloc(strlen(yylval)+1),yylval);
487
488 break;
489
490 /* End of file */
491
492 case LEX_EOF:
493
494 if(tag)
495 {
496 fprintf(stderr,"XML Parser: Error on line %d: end of file seen without end tag '</%s>'.\n",yylineno,tag->name);
497 yychar=LEX_ERROR_UNEXP_EOF;
498 }
499
500 break;
501
502 case LEX_ERROR_TAG_START:
503 fprintf(stderr,"XML Parser: Error on line %d: character '<' seen not at start of tag.\n",yylineno);
504 break;
505
506 case LEX_ERROR_XML_DECL_START:
507 fprintf(stderr,"XML Parser: Error on line %d: characters '<?' seen not at start of XML declaration.\n",yylineno);
508 break;
509
510 case LEX_ERROR_TAG:
511 fprintf(stderr,"XML Parser: Error on line %d: invalid character seen inside tag '<%s...>'.\n",yylineno,tag->name);
512 break;
513
514 case LEX_ERROR_XML_DECL:
515 fprintf(stderr,"XML Parser: Error on line %d: invalid character seen inside XML declaration '<?%s...>'.\n",yylineno,tag->name);
516 break;
517
518 case LEX_ERROR_ATTR:
519 fprintf(stderr,"XML Parser: Error on line %d: invalid attribute definition seen in tag.\n",yylineno);
520 break;
521
522 case LEX_ERROR_END_TAG:
523 fprintf(stderr,"XML Parser: Error on line %d: invalid character seen in end-tag.\n",yylineno);
524 break;
525
526 case LEX_ERROR_COMMENT:
527 fprintf(stderr,"XML Parser: Error on line %d: invalid comment seen.\n",yylineno);
528 break;
529
530 case LEX_ERROR_CLOSE:
531 fprintf(stderr,"XML Parser: Error on line %d: character '>' seen not at end of tag.\n",yylineno);
532 break;
533
534 case LEX_ERROR_ATTR_VAL:
535 fprintf(stderr,"XML Parser: Error on line %d: invalid character '%s' seen in attribute value.\n",yylineno,yylval);
536 break;
537
538 case LEX_ERROR_ENTITY_REF:
539 fprintf(stderr,"XML Parser: Error on line %d: invalid entity reference '%s' seen in attribute value.\n",yylineno,yylval);
540 break;
541
542 case LEX_ERROR_CHAR_REF:
543 fprintf(stderr,"XML Parser: Error on line %d: invalid character reference '%s' seen in attribute value.\n",yylineno,yylval);
544 break;
545 }
546 }
547 while(yychar>LEX_EOF && yychar<LEX_ERROR);
548
549 /* Delete the tagdata */
550
551 for(i=0;i<XMLPARSE_MAX_ATTRS;i++)
552 if(attributes[i])
553 free(attributes[i]);
554
555 if(stackdepth)
556 free(tags_stack);
557
558 return(yychar);
559 }
560
561
562 /*++++++++++++++++++++++++++++++++++++++
563 Return the current parser line number.
564
565 unsigned long ParseXML_LineNumber Returns the line number.
566 ++++++++++++++++++++++++++++++++++++++*/
567
568 unsigned long ParseXML_LineNumber(void)
569 {
570 return(yylineno);
571 }
572
573
574 /*++++++++++++++++++++++++++++++++++++++
575 Convert an XML entity reference into an ASCII string.
576
577 char *ParseXML_Decode_Entity_Ref Returns a pointer to the replacement decoded string.
578
579 const char *string The entity reference string.
580 ++++++++++++++++++++++++++++++++++++++*/
581
582 char *ParseXML_Decode_Entity_Ref(const char *string)
583 {
584 if(!strcmp(string,"&amp;")) return("&");
585 if(!strcmp(string,"&lt;")) return("<");
586 if(!strcmp(string,"&gt;")) return(">");
587 if(!strcmp(string,"&apos;")) return("'");
588 if(!strcmp(string,"&quot;")) return("\"");
589 return(NULL);
590 }
591
592
593 /*++++++++++++++++++++++++++++++++++++++
594 Convert an XML character reference into an ASCII string.
595
596 char *ParseXML_Decode_Char_Ref Returns a pointer to the replacement decoded string.
597
598 const char *string The character reference string.
599 ++++++++++++++++++++++++++++++++++++++*/
600
601 char *ParseXML_Decode_Char_Ref(const char *string)
602 {
603 static char result[2]=" ";
604 long int val;
605
606 if(string[2]=='x') val=strtol(string+3,NULL,16);
607 else val=strtol(string+2,NULL,10);
608
609 if(val<0 || val>255)
610 return(NULL);
611
612 result[0]=val&0xff;
613
614 return(result);
615 }
616
617
618 /*++++++++++++++++++++++++++++++++++++++
619 Convert a string into something that is safe to output in an XML file.
620
621 char *ParseXML_Encode_Safe_XML Returns a pointer to the replacement encoded string (or the original if no change needed).
622
623 const char *string The string to convert.
624 ++++++++++++++++++++++++++++++++++++++*/
625
626 char *ParseXML_Encode_Safe_XML(const char *string)
627 {
628 static const char hexstring[17]="0123456789ABCDEF";
629 int i=0,j=0,len;
630 char *result;
631
632 for(i=0;string[i];i++)
633 if(string[i]=='<' || string[i]=='>' || string[i]=='&' || string[i]=='\'' || string[i]=='"' || string[i]<32 || string[i]>126)
634 break;
635
636 if(!string[i])
637 return((char*)string);
638
639 len=i+256-6;
640
641 result=(char*)malloc(len+7);
642 strncpy(result,string,i);
643
644 do
645 {
646 for(;j<len && string[i];i++)
647 if(string[i]=='<')
648 {
649 result[j++]='&';
650 result[j++]='l';
651 result[j++]='t';
652 result[j++]=';';
653 }
654 else if(string[i]=='>')
655 {
656 result[j++]='&';
657 result[j++]='g';
658 result[j++]='t';
659 result[j++]=';';
660 }
661 else if(string[i]=='&')
662 {
663 result[j++]='&';
664 result[j++]='a';
665 result[j++]='m';
666 result[j++]='p';
667 result[j++]=';';
668 }
669 else if(string[i]=='\'')
670 {
671 result[j++]='&';
672 result[j++]='a';
673 result[j++]='p';
674 result[j++]='o';
675 result[j++]='s';
676 result[j++]=';';
677 }
678 else if(string[i]=='"')
679 {
680 result[j++]='&';
681 result[j++]='q';
682 result[j++]='u';
683 result[j++]='o';
684 result[j++]='t';
685 result[j++]=';';
686 }
687 else if(string[i]<32 || string[i]>126)
688 {
689 result[j++]='&';
690 result[j++]='#';
691 result[j++]='x';
692 result[j++]=hexstring[(string[i]&0xf0)>>4];
693 result[j++]=hexstring[ string[i]&0x0f ];
694 result[j++]=';';
695 }
696 else
697 result[j++]=string[i];
698
699 if(string[i]) /* Not finished */
700 {
701 len+=256;
702 result=(char*)realloc((void*)result,len+7);
703 }
704 }
705 while(string[i]);
706
707 result[j]=0;
708
709 return(result);
710 }
711
712
713 /*++++++++++++++++++++++++++++++++++++++
714 Convert a string to a integer (checking that it really is a integer).
715
716 int ParseXML_GetInteger Returns 1 if a integer could be found or 0 otherwise.
717
718 const char *string The string to be parsed.
719
720 int *number Returns the number.
721 ++++++++++++++++++++++++++++++++++++++*/
722
723 int ParseXML_GetInteger(const char *string,int *number)
724 {
725 const char *p=string;
726
727 if(*p=='-' || *p=='+')
728 p++;
729
730 while(isdigit(*p))
731 p++;
732
733 if(*p)
734 return(0);
735
736 *number=atoi(string);
737
738 return(1);
739 }
740
741
742 /*++++++++++++++++++++++++++++++++++++++
743 Convert a string to a floating point number (checking that it really is a number).
744
745 int ParseXML_GetFloating Returns 1 if a number could be found or 0 otherwise.
746
747 const char *string The string to be parsed.
748
749 int *number Returns the number.
750 ++++++++++++++++++++++++++++++++++++++*/
751
752 int ParseXML_GetFloating(const char *string,double *number)
753 {
754 const char *p=string;
755
756 if(*p=='-' || *p=='+')
757 p++;
758
759 while(isdigit(*p) || *p=='.')
760 p++;
761
762 if(*p)
763 return(0);
764
765 *number=atof(string);
766
767 return(1);
768 }

Properties

Name Value
cvs:description A simple generic XML parser.
Index: This Site Routino Software Download Source Code Documentation XML Files Links
Index: View SVN Development Recent changes Development (destination-access branch) Version 3.4.1 (destination-access branch) Version 3.4.1 Version 3.4 (destination-access branch) Version 3.4 Version 3.3.3 (destination-access branch) Version 3.3.3 Version 3.3.2 (destination-access branch) Version 3.3.2 Version 3.3.1 (destination-access branch) Version 3.3.1 Version 3.3 (destination-access branch) Version 3.3 Version 3.2 Version 3.1.1 Version 3.1 Version 3.0 Version 2.7.3 Version 2.7.2 Version 2.7.1 Version 2.7 Version 2.6 Version 2.5.1 Version 2.5 Version 2.4.1 Version 2.4 Version 2.3.2 Version 2.3.1 Version 2.3 Version 2.2 Version 2.1.2 Version 2.1.1 Version 2.1 Version 2.0.3 Version 2.0.2 Version 2.0.1 Version 2.0 Version 1.5.1 Version 1.5 Version 1.4.1 Version 1.4 Version 1.3 Version 1.2 Version 1.1 Version 1.0
Powered by ViewVC 1.3.0-dev ViewVC Help
© Andrew M. Bishop = < amb @ ... >
Root