Fix compilation warning (const variables)
[vlc.git] / modules / codec / cmml / xtag.c
1 /*****************************************************************************
2  * xlist.c : a trivial parser for XML-like tags
3  *****************************************************************************
4  * Copyright (C) 2003-2004 Commonwealth Scientific and Industrial Research
5  *                         Organisation (CSIRO) Australia
6  * Copyright (C) 2000-2004 the VideoLAN team
7  *
8  * $Id$
9  *
10  * Authors: Conrad Parker <Conrad.Parker@csiro.au>
11  *          Andre Pang <Andre.Pang@csiro.au>
12  *
13  * This program is free software; you can redistribute it and/or modify
14  * it under the terms of the GNU General Public License as published by
15  * the Free Software Foundation; either version 2 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 General Public License for more details.
22  *
23  * You should have received a copy of the GNU General Public License
24  * along with this program; if not, write to the Free Software
25  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
26  *****************************************************************************/
27 #ifdef HAVE_CONFIG_H
28 # include "config.h"
29 #endif
30
31 #include <vlc_common.h>
32
33 #include <ctype.h>
34 #include <stdarg.h>
35 #include <stdio.h>
36 #include <stdlib.h>
37 #include <string.h>
38
39 #include "xlist.h"
40
41 #include <assert.h>
42
43 #undef XTAG_DEBUG
44
45 #undef MIN
46 #define MIN(a,b) ((a)<(b)?(a):(b))
47
48 #undef MAX
49 #define MAX(a,b) ((a)>(b)?(a):(b))
50
51 typedef struct _XTag XTag;
52 typedef struct _XAttribute XAttribute;
53 typedef struct _XTagParser XTagParser;
54
55 /*
56  * struct _XTag is kind of a union ... it normally represents a whole
57  * tag (and its children), but it could alternatively represent some
58  * PCDATA. Basically, if tag->pcdata is non-NULL, interpret only it and
59  * ignore the name, attributes and inner_tags.
60  */
61 struct _XTag {
62   char * name;
63   char * pcdata;
64   XTag * parent;
65   XList * attributes;
66   XList * children;
67   XList * current_child;
68 };
69
70 struct _XAttribute {
71   char * name;
72   char * value;
73 };
74
75 struct _XTagParser {
76   int valid; /* boolean */
77   XTag * current_tag;
78   char * start;
79   char * end;
80 };
81
82 void   xtag_free (XTag * xtag);
83 XTag * xtag_new_parse (const char * s, int n);
84 char * xtag_get_name (XTag * xtag);
85 char * xtag_get_pcdata (XTag * xtag);
86 char * xtag_get_attribute (XTag * xtag, const char* attribute);
87 XTag * xtag_first_child (XTag * xtag, const char * name);
88 XTag * xtag_next_child (XTag * xtag, char * name);
89 int    xtag_snprint (char * buf, int n, XTag * xtag);
90
91 /* Character classes */
92 #define X_NONE           0
93 #define X_WHITESPACE  1<<0
94 #define X_OPENTAG     1<<1
95 #define X_CLOSETAG    1<<2
96 #define X_DQUOTE      1<<3
97 #define X_SQUOTE      1<<4
98 #define X_EQUAL       1<<5
99 #define X_SLASH       1<<6
100
101 static int
102 xtag_cin (char c, int char_class)
103 {
104   if (char_class & X_WHITESPACE)
105     if (isspace(c)) return true;
106
107   if (char_class & X_OPENTAG)
108     if (c == '<') return true;
109
110   if (char_class & X_CLOSETAG)
111     if (c == '>') return true;
112
113   if (char_class & X_DQUOTE)
114     if (c == '"') return true;
115
116   if (char_class & X_SQUOTE)
117     if (c == '\'') return true;
118
119   if (char_class & X_EQUAL)
120     if (c == '=') return true;
121
122   if (char_class & X_SLASH)
123     if (c == '/') return true;
124
125   return false;
126 }
127
128 static int
129 xtag_index (XTagParser * parser, int char_class)
130 {
131   char * s;
132   int i;
133
134   s = parser->start;
135
136   for (i = 0; s[i] && s != parser->end; i++) {
137     if (xtag_cin(s[i], char_class)) return i;
138   }
139
140   return -1;
141 }
142
143 static void
144 xtag_skip_over (XTagParser * parser, int char_class)
145 {
146   char * s;
147   int i;
148
149   if (!parser->valid) return;
150
151   s = (char *)parser->start;
152
153   for (i = 0; s[i] && s != parser->end; i++) {
154     if (!xtag_cin(s[i], char_class)) {
155       parser->start = &s[i];
156       return;
157     }
158   }
159
160   return;
161 }
162
163 static void
164 xtag_skip_whitespace (XTagParser * parser)
165 {
166   xtag_skip_over (parser, X_WHITESPACE);
167 }
168
169 #if 0
170 static void
171 xtag_skip_to (XTagParser * parser, int char_class)
172 {
173   char * s;
174   int i;
175
176   if (!parser->valid) return;
177
178   s = (char *)parser->start;
179
180   for (i = 0; s[i] && s != parser->end; i++) {
181     if (xtag_cin(s[i], char_class)) {
182       parser->start = &s[i];
183       return;
184     }
185   }
186
187   return;
188 }
189 #endif
190
191 static char *
192 xtag_slurp_to (XTagParser * parser, int good_end, int bad_end)
193 {
194   char * s, * ret;
195   int xi;
196
197   if (!parser->valid) return NULL;
198
199   s = parser->start;
200
201   xi = xtag_index (parser, good_end | bad_end);
202
203   if (xi > 0 && xtag_cin (s[xi], good_end)) {
204     ret = malloc (xi+1);
205     strncpy (ret, s, xi);
206     ret[xi] = '\0';
207     parser->start = &s[xi];
208     return ret;
209   }
210
211   return NULL;
212 }
213
214 static int
215 xtag_assert_and_pass (XTagParser * parser, int char_class)
216 {
217   char * s;
218
219   if (!parser->valid) return false;
220
221   s = parser->start;
222
223   if (!xtag_cin (s[0], char_class)) {
224     parser->valid = false;
225     return false;
226   }
227
228   parser->start = &s[1];
229
230   return true;
231 }
232
233 static char *
234 xtag_slurp_quoted (XTagParser * parser)
235 {
236   char * s, * ret;
237   int quote = X_DQUOTE; /* quote char to match on */
238   int xi;
239
240   if (!parser->valid) return NULL;
241
242   xtag_skip_whitespace (parser);
243
244   s = parser->start;
245
246   if (xtag_cin (s[0], X_SQUOTE)) quote = X_SQUOTE;
247
248   if (!xtag_assert_and_pass (parser, quote)) return NULL;
249
250   s = parser->start;
251
252   for (xi = 0; s[xi]; xi++) {
253     if (xtag_cin (s[xi], quote)) {
254       if (!(xi > 1 && s[xi-1] == '\\')) break;
255     }
256   }
257
258   ret = malloc (xi+1);
259   strncpy (ret, s, xi);
260   ret[xi] = '\0';
261   parser->start = &s[xi];
262
263   if (!xtag_assert_and_pass (parser, quote)) return NULL;
264
265   return ret;
266 }
267
268 static XAttribute *
269 xtag_parse_attribute (XTagParser * parser)
270 {
271   XAttribute * attr;
272   char * name, * value;
273   char * s;
274
275   if (!parser->valid) return NULL;
276
277   xtag_skip_whitespace (parser);
278  
279   name = xtag_slurp_to (parser, X_WHITESPACE | X_EQUAL, X_SLASH | X_CLOSETAG);
280
281   if (name == NULL) return NULL;
282
283   xtag_skip_whitespace (parser);
284   s = parser->start;
285
286   if (!xtag_assert_and_pass (parser, X_EQUAL)) {
287 #ifdef XTAG_DEBUG
288     printf ("xtag: attr failed EQUAL on <%s>\n", name);
289 #endif
290     goto err_free_name;
291   }
292
293   xtag_skip_whitespace (parser);
294
295   value = xtag_slurp_quoted (parser);
296
297   if (value == NULL) {
298 #ifdef XTAG_DEBUG
299     printf ("Got NULL quoted attribute value\n");
300 #endif
301     goto err_free_name;
302   }
303
304   attr = malloc (sizeof (*attr));
305   attr->name = name;
306   attr->value = value;
307
308   return attr;
309
310  err_free_name:
311   free (name);
312
313   parser->valid = false;
314
315   return NULL;
316 }
317
318 static XTag *
319 xtag_parse_tag (XTagParser * parser)
320 {
321   XTag * tag, * inner;
322   XAttribute * attr;
323   char * name;
324   char * pcdata;
325   char * s;
326
327   if (!parser->valid) return NULL;
328
329   if ((pcdata = xtag_slurp_to (parser, X_OPENTAG, X_NONE)) != NULL) {
330     tag = malloc (sizeof (*tag));
331     tag->name = NULL;
332     tag->pcdata = pcdata;
333     tag->parent = parser->current_tag;
334     tag->attributes = NULL;
335     tag->children = NULL;
336     tag->current_child = NULL;
337
338     return tag;
339   }
340
341   s = parser->start;
342
343   /* if this starts a close tag, return NULL and let the parent take it */
344   if (xtag_cin (s[0], X_OPENTAG) && xtag_cin (s[1], X_SLASH))
345     return NULL;
346
347   if (!xtag_assert_and_pass (parser, X_OPENTAG)) return NULL;
348
349   name = xtag_slurp_to (parser, X_WHITESPACE | X_SLASH | X_CLOSETAG, X_NONE);
350
351   if (name == NULL) return NULL;
352
353 #ifdef XTAG_DEBUG
354   printf ("<%s ...\n", name);
355 #endif
356
357   tag = malloc (sizeof (*tag));
358   tag->name = name;
359   tag->pcdata = NULL;
360   tag->parent = parser->current_tag;
361   tag->attributes = NULL;
362   tag->children = NULL;
363   tag->current_child = NULL;
364
365   s = parser->start;
366
367   if (xtag_cin (s[0], X_WHITESPACE)) {
368     while ((attr = xtag_parse_attribute (parser)) != NULL) {
369       tag->attributes = xlist_append (tag->attributes, attr);
370     }
371   }
372
373   xtag_skip_whitespace (parser);
374
375   s = parser->start;
376
377   if (xtag_cin (s[0], X_CLOSETAG)) {
378     parser->current_tag = tag;
379
380     xtag_assert_and_pass (parser, X_CLOSETAG);
381
382     while ((inner = xtag_parse_tag (parser)) != NULL) {
383       tag->children = xlist_append (tag->children, inner);
384     }
385
386     xtag_skip_whitespace (parser);
387
388     xtag_assert_and_pass (parser, X_OPENTAG);
389     xtag_assert_and_pass (parser, X_SLASH);
390     name = xtag_slurp_to (parser, X_WHITESPACE | X_CLOSETAG, X_NONE);
391     if (name) {
392       if (name && tag->name && strcmp (name, tag->name)) {
393 #ifdef XTAG_DEBUG
394         printf ("got %s expected %s\n", name, tag->name);
395 #endif
396         parser->valid = false;
397       }
398       free (name);
399     }
400
401     xtag_skip_whitespace (parser);
402     xtag_assert_and_pass (parser, X_CLOSETAG);
403
404   } else {
405     xtag_assert_and_pass (parser, X_SLASH);
406     xtag_assert_and_pass (parser, X_CLOSETAG);
407   }
408
409
410   return tag;
411 }
412
413 void xtag_free (XTag * xtag)
414 {
415   XList * l;
416   XAttribute * attr;
417   XTag * child;
418
419   if( !xtag )
420     return;
421
422   free( xtag->name );
423   free( xtag->pcdata );
424
425   for( l = xtag->attributes; l; l = l->next) {
426     if((attr = (XAttribute *)l->data) != NULL) {
427       free( attr->name );
428       free( attr->value );
429       free( attr );
430     }
431   }
432   xlist_free (xtag->attributes);
433
434   for (l = xtag->children; l; l = l->next) {
435     child = (XTag *)l->data;
436     xtag_free( child );
437   }
438   xlist_free (xtag->children);
439
440   free( xtag );
441 }
442
443 XTag *
444 xtag_new_parse (const char * s, int n)
445 {
446   XTagParser parser;
447   XTag * tag, * ttag, * wrapper;
448
449   parser.valid = true;
450   parser.current_tag = NULL;
451   parser.start = (char *)s;
452
453   if (n == -1)
454     parser.end = NULL;
455   else if (n == 0)
456     return NULL;
457   else
458     parser.end = (char *)&s[n];
459
460   tag = xtag_parse_tag (&parser);
461
462   if (!parser.valid) {
463     xtag_free (tag);
464     return NULL;
465   }
466
467   if ((ttag = xtag_parse_tag (&parser)) != NULL) {
468
469     if (!parser.valid) {
470       xtag_free (ttag);
471       return tag;
472     }
473
474     wrapper = malloc (sizeof (XTag));
475     wrapper->name = NULL;
476     wrapper->pcdata = NULL;
477     wrapper->parent = NULL;
478     wrapper->attributes = NULL;
479     wrapper->children = NULL;
480     wrapper->current_child = NULL;
481
482     wrapper->children = xlist_append (wrapper->children, tag);
483     wrapper->children = xlist_append (wrapper->children, ttag);
484
485     while ((ttag = xtag_parse_tag (&parser)) != NULL) {
486
487       if (!parser.valid) {
488         xtag_free (ttag);
489         return wrapper;
490       }
491
492       wrapper->children = xlist_append (wrapper->children, ttag);
493     }
494     return wrapper;
495   }
496
497   return tag;
498 }
499
500 char *
501 xtag_get_name (XTag * xtag)
502 {
503   return xtag ? xtag->name : NULL;
504 }
505
506 char *
507 xtag_get_pcdata (XTag * xtag)
508 {
509   XList * l;
510   XTag * child;
511
512   if (xtag == NULL) return NULL;
513
514   for (l = xtag->children; l; l = l->next) {
515     child = (XTag *)l->data;
516     if (child->pcdata != NULL) {
517       return child->pcdata;
518     }
519   }
520
521   return NULL;
522 }
523
524 char* xtag_get_attribute (XTag * xtag, const char * attribute)
525 {
526     XList * l;
527     XAttribute * attr;
528
529     if( !xtag )
530         return NULL;
531
532     for( l = xtag->attributes; l; l = l->next )
533     {
534         if( ( attr = (XAttribute *)l->data ) != NULL )
535         {
536             if( attr->name && attribute && !strcmp( attr->name, attribute ) )
537                 return attr->value;
538         }
539     }
540     return NULL;
541 }
542
543 XTag* xtag_first_child (XTag * xtag, const char * name)
544 {
545     XList * l;
546     XTag * child;
547
548     if( !xtag )
549         return NULL;
550
551     if( ( l = xtag->children ) == NULL )
552         return NULL;
553
554     if( !name )
555     {
556         xtag->current_child = l;
557         return (XTag *)l->data;
558     }
559
560     for( ; l; l = l->next )
561     {
562         child = (XTag *)l->data;
563
564         if( child->name && name && !strcmp( child->name, name ) )
565         {
566             xtag->current_child = l;
567             return child;
568         }
569     }
570
571     xtag->current_child = NULL;
572     return NULL;
573 }
574
575 XTag *
576 xtag_next_child (XTag * xtag, char * name)
577 {
578   XList * l;
579   XTag * child;
580
581   if (xtag == NULL) return NULL;
582
583   if ((l = xtag->current_child) == NULL)
584     return xtag_first_child (xtag, name);
585
586   if ((l = l->next) == NULL)
587     return NULL;
588
589   if (name == NULL) {
590     xtag->current_child = l;
591     return (XTag *)l->data;
592   }
593
594   for (; l; l = l->next) {
595     child = (XTag *)l->data;
596
597     if (child->name && name && !strcmp(child->name, name)) {
598       xtag->current_child = l;
599       return child;
600     }
601   }
602
603   xtag->current_child = NULL;
604
605   return NULL;
606 }
607
608 /*
609  * This snprints function takes a variable list of char *, the last of
610  * which must be NULL, and prints each in turn to buf.
611  * Returns C99-style total length that would have been written, even if
612  * this is larger than n.
613  */
614 static int
615 xtag_snprints (char * buf, int n, ...)
616 {
617   va_list ap;
618   char * s;
619   int len, to_copy, total = 0;
620
621   va_start (ap, n);
622  
623   for (s = va_arg (ap, char *); s; s = va_arg (ap, char *)) {
624     len = strlen (s);
625
626     if ((to_copy = MIN (n, len)) > 0) {
627       memcpy (buf, s, to_copy);
628       buf += to_copy;
629       n -= to_copy;
630     }
631
632     total += len;
633   }
634
635   va_end (ap);
636
637   return total;
638 }
639
640 int
641 xtag_snprint (char * buf, int n, XTag * xtag)
642 {
643   int nn, written = 0;
644   XList * l;
645   XAttribute * attr;
646   XTag * child;
647
648 #define FORWARD(N) \
649   buf += MIN (n, N); \
650   n = MAX (n-N, 0);  \
651   written += N;
652
653   if (xtag == NULL) {
654     if (n > 0) buf[0] = '\0';
655     return 0;
656   }
657
658   if (xtag->pcdata) {
659     nn = xtag_snprints (buf, n, xtag->pcdata, NULL);
660     FORWARD(nn);
661
662     return written;
663   }
664
665   if (xtag->name) {
666     nn = xtag_snprints (buf, n, "<", xtag->name, NULL);
667     FORWARD(nn);
668
669     for (l = xtag->attributes; l; l = l->next) {
670       attr = (XAttribute *)l->data;
671  
672       nn = xtag_snprints (buf, n, " ", attr->name, "=\"", attr->value, "\"",
673                           NULL);
674       FORWARD(nn);
675     }
676  
677     if (xtag->children == NULL) {
678       nn = xtag_snprints (buf, n, "/>", NULL);
679       FORWARD(nn);
680
681       return written;
682     }
683  
684     nn = xtag_snprints (buf, n, ">", NULL);
685     FORWARD(nn);
686   }
687
688   for (l = xtag->children; l; l = l->next) {
689     child = (XTag *)l->data;
690
691     nn = xtag_snprint (buf, n, child);
692     FORWARD(nn);
693   }
694
695   if (xtag->name) {
696     nn = xtag_snprints (buf, n, "</", xtag->name, ">", NULL);
697     FORWARD(nn);
698   }
699
700   return written;
701 }
702