lib/xml.c

   1 /* xml.c
   2    Lightweight and fast xml parser.
   3
   4    Part of the swftools package.
   5
   6    Copyright (c) 2010 Matthias Kramm <kramm@quiss.org>
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <memory.h>
  25 #include <assert.h>
  26 #include "xml.h"
  27
  28 /*
  29 group: 0=data 1=whitespace 2='"' 3='<' 4='>' 5='&' 6=';' 7='?' 8='/' 9='=' 10='!' 11=EOF
  30 */
  31
  32 static int group[256] =
  33 {
  34 // 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f
  35 //                            \t \n       \r
  36    13, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0,
  37 // 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f
  38 //
  39    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  40 // 20 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f
  41 //    !  "  #  $  %  &  '  (  )  *  +  ,  -  .  /
  42    1,10, 2, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 8,
  43 // 30 31 32 33 34 35 36 37 38 39 3a 3b 3c 3d 3e 3f
  44 // 0  1  2  3  4  5  6  7  8  9  :  ;  <  =  >  ?
  45    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 3, 9, 4, 7,
  46 // 40 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f
  47 // @  A  B  C  D  E  F  G  H  I  J  K  L  M  N  O
  48    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  49 // 50 51 52 53 54 55 56 57 58 59 5a 5b 5c 5d 5e 5f
  50 // P  Q  R  S  T  U  V  W  X  Y  Z  [  \  ]  ^  _
  51    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,11, 0,12, 0, 0,
  52 // 60 61 62 63 64 65 66 67 68 69 6a 6b 6c 6d 6e 6f
  53 // `  a  b  c  d  e  f  g  h  i  j  k  l  m  n  o
  54    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  55 // 70 71 72 73 74 75 76 77 78 79 7a 7b 7c 7d 7e 7f
  56 // p  q  r  s  t  u  v  w  x  y  z  {  |  }  ~
  57    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  58 // 80 81 82 83 84 85 86 87 88 89 8a 8b 8c 8d 8e 8f
  59 //
  60    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  61 // 90 91 92 93 94 95 96 97 98 99 9a 9b 9c 9d 9e 9f
  62 //
  63    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  64 // a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 aa ab ac ad ae af
  65 //
  66    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  67 // b0 b1 b2 b3 b4 b5 b6 b7 b8 b9 ba bb bc bd be bf
  68 //
  69    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  70 // c0 c1 c2 c3 c4 c5 c6 c7 c8 c9 ca cb cc cd ce cf
  71 //
  72    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  73 // d0 d1 d2 d3 d4 d5 d6 d7 d8 d9 da db dc dd de df
  74 //
  75    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  76 // e0 e1 e2 e3 e4 e5 e6 e7 e8 e9 ea eb ec ed ee ef
  77 //
  78    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  79 // f0 f1 f2 f3 f4 f5 f6 f7 f8 f9 fa fb fc fd fe ff
  80 //
  81    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  82 };
  83
  84 static const char*errors[]=
  85 {
  86   0,
  87 #define E1 -0x41
  88  /*E1*/"xml file must start with <?",
  89 #define E2 -0x42
  90  /*E2*/"<,; or & not allowed inside tags",
  91 #define E3 -0x43
  92  /*E3*/"syntax error",
  93 #define E4 -0x44
  94  /*E4*/"internal error",
  95 #define E5 -0x45
  96  /*E5*/"attribute definition without =\"",
  97 };
  98
  99 static int new_state[][16]=
 100 {        /*  dt ws  "  <  >  &  ;  ?  /  =  !  [  ]   - EOB*/
 101  /*  0 */{   E1, 0,E1, 1,E1,E1,E1,E1,E1,E1,E3,E1,E1,-63}, // .<
 102  /*  1 */{   E1,E1,E1,E1,E1,E1,E1, 9,E1,E1,E3,E1,E1,-63}, // <.?
 103  /*  2 */{   -3, 2,E3,E2,E2,E2,E2,E2,12,E2,16,E2,E2,-63}, // <.
 104  /*  3 */{   E3,E3,E3,E3,-1,E3,E3,E3,E3,E1,E3,E3,E3,-63}, // < /.>
 105  /*  4 */{   E3,E3,E3,E3,-2,E3,E3,E3,E3,E1,E1,E3,E3,-63}, // < .>
 106  /*  5 */{    5, 5, 5,-4, 5, 5, 5, 5, 5, 5, 5,E3,E3,-63}, // da.ta
 107  /*  6 */{    6,-7,E3,E2,-6,E2,E2,E3,-9,E3,E3,E3,E3,-63}, // <na.me
 108  /*  7 */{   -8, 7,E3,E2,-2,E2,E2, 7, 3,E3,E3,E3,E3,-63}, // <name .
 109  /*  8 */{    8,-12,E3,E2,E3,E2,E2,E3,E3,-10,E3,E3,E3,-63}, // att.r
 110  /*  9 */{    9, 7,E3,E3,E3,E3,E3,E3,E3,E3,E3,E3,E3,-63}, // <?x.ml
 111  /* 10 */{   E5,10,-11,E5,E5,E5,E5,E5,E5,E5,E3,E3,E3,-63},// attr=."
 112  /* 11 */{   11,11,-5 ,11,11,11,11,11,11,11,E3,E3,E3,-63},// attr="va.l
 113  /* 12 */{  -13,12,E3,E3,E3,E3,E3,E3,E3,E3,E3,E3,E3,-63}, // </ . >
 114  /* 13 */{  13,-14,E3,E3,-16,E3,E3,E3,E3,E3,E3,E3,E3,-63},// </ na.me>
 115  /* 14 */{   E3,14,E3,E3,-15,E3,E3,E3,E3,E3,E3,E3,E3,-63},// </ name. >
 116  /* 15 */{   E3,15,E3,E2,E3,E3,E3,E3,E3,10,E3,E3,E3,-63}, // attr .=
 117  /* 16 */{   E3,E3,E3,E2,E3,E3,E3,E3,E3,E3,E3,17,E3,-63}, // <!.[CDATA[ ]]>
 118  /* 17 */{   17,E3,E3,E3,E3,E3,E3,E3,E3,E3,E3,18,E3,-63}, // <![C.DATA[ ]]>
 119  /* 18 */{   18,18,18,18,18,18,18,18,18,18,18,18,19,-63}, // <![CDATA[ . ]]>
 120  /* 19 */{   18,18,18,18,-20,18,18,18,18,18,18,18,19,-63}, // <![CDATA[ ].]>
 121  /* 20 */{0,0,0,0,0,0,0,0,0,0,0,-63},
 122  /* 21 */{0,0,0,0,0,0,0,0,0,0,0,-63},
 123  /* 22 */{0,0,0,0,0,0,0,0,0,0,0,-63},
 124  /* 23 */{0,0,0,0,0,0,0,0,0,0,0,-63},
 125  /* 24 */{0,0,0,0,0,0,0,0,0,0,0,-63},
 126 };
 127
 128 typedef struct _tag_stack {
 129     const char*name;
 130     struct _tag_stack*prev;
 131 } tag_stack_t;
 132
 133 typedef struct _stringstate {
 134     char*current;
 135     int len;
 136     char*start;
 137     char*result;
 138 } stringstate_t;
 139
 140 static void stringstate_start(stringstate_t*s, char*buffer, int pos)
 141 {
 142     assert(!s->current);
 143     s->start = &buffer[pos];
 144     s->len = 0;
 145     s->result = 0;
 146 }
 147 static void stringstate_save(stringstate_t*s, char*buffer, int pos)
 148 {
 149     if(!s->start)
 150         return;
 151     int add = &buffer[pos] - s->start;
 152     if(!s->current) {
 153         assert(!s->len);
 154         s->current = malloc(add+1);
 155         memcpy(s->current, s->start, add);
 156     } else {
 157         s->current = realloc(s->current, s->len + add + 1);
 158         memcpy(s->current+s->len, s->start, add);
 159     }
 160     s->len += add;
 161     s->current[s->len] = 0;
 162     s->start = buffer;
 163 }
 164 static void stringstate_finish(stringstate_t*s, char*buffer, int pos)
 165 {
 166     stringstate_save(s, buffer, pos);
 167     s->result = s->current;
 168     s->current = 0;
 169     s->start = 0;
 170 }
 171 static void stringstate_clear(stringstate_t*s)
 172 {
 173     if(s->result) free(s->result);
 174     if(s->current) free(s->current);
 175     memset(s, 0, sizeof(stringstate_t));
 176 }
 177 static xmlattribute_t*attributes_reverse(xmlattribute_t*attr)
 178 {
 179     xmlattribute_t*prev = 0;
 180     while(attr) {
 181         xmlattribute_t*next = attr->next;
 182         attr->next = prev;
 183         prev = attr;
 184         attr = next;
 185     }
 186     return prev;
 187 }
 188
 189 static void attributes_free(xmlattribute_t*attributes)
 190 {
 191     while(attributes) {
 192         xmlattribute_t*next = attributes->next;
 193         free((void*)attributes->name);
 194         free((void*)attributes->value);
 195         free(attributes);
 196         attributes = next;
 197     }
 198 }
 199
 200 int xml_parse(reader_t*reader, xmlconsumer_t*out)
 201 {
 202     char buffer[4097];
 203     int old = 0, state = 0;
 204     char first=1;
 205     tag_stack_t*stack = 0;
 206
 207     stringstate_t tagname = {0,0,0,0};
 208     stringstate_t attr_name = {0,0,0,0};
 209     stringstate_t attr_value = {0,0,0,0};
 210     stringstate_t data = {0,0,0,0};
 211     xmlattribute_t*attributes = 0;
 212
 213     while(1) {
 214         int num = reader->read(reader, buffer, 4096);
 215         if(!num) break;
 216         buffer[num]=0;
 217         int pos = 0;
 218         while(pos<num) {
 219             /*printf("%c, state %d->%d\n",
 220                     buffer[pos], state, new_state[state][group[buffer[pos]]]);*/
 221
 222             /* inner loop */
 223             do {
 224                 state = new_state[old=state][group[(unsigned char)buffer[pos++]]];
 225             } while(state>=0);
 226
 227             switch(state) {
 228                 tag_stack_t*st;
 229                 xmlattribute_t*a;
 230                 case -63: // end of buffer
 231                     if(pos!=num+1) {
 232                         // we could backtrace, but the spec says this is indeed illegal
 233                         fprintf(stderr, "error: xml contains \\0 chars\n");
 234                         return 0;
 235                     }
 236                     // undo
 237                     pos = num;
 238                     state = old;
 239                 break;
 240                 case -1: // self closing tag
 241                     attributes = attributes_reverse(attributes);
 242                     out->start_tag(out, tagname.result, attributes);
 243                     out->end_tag(out, tagname.result);
 244                     stringstate_clear(&tagname);
 245                     attributes_free(attributes);attributes = 0;
 246                     stringstate_start(&data, buffer, pos);
 247                     state = 5;
 248                 break;
 249                 case -6: // after <tagname, at >
 250                     stringstate_finish(&tagname, buffer, pos-1);
 251                 // fallthrough
 252                 case -2: // <tag >.
 253                     st = malloc(sizeof(tag_stack_t));
 254                     st->name = tagname.result;
 255                     st->prev = stack;
 256                     stack = st;
 257                     attributes = attributes_reverse(attributes);
 258                     if(!first) out->start_tag(out, tagname.result, attributes);
 259                     attributes_free(attributes);attributes = 0;
 260                     stringstate_start(&data, buffer, pos);
 261                     state = 5;
 262                 break;
 263                 case -3: case -13: // after <, start of tag name
 264                     first=0;
 265                     stringstate_start(&tagname, buffer, pos-1);
 266                     state = state==-3?6:13;
 267                 break;
 268                 case -14: // after </, end of tag name, begin of white space
 269                     stringstate_finish(&tagname, buffer, pos-1);
 270                     state = 14;
 271                     break;
 272                 case -16: // after </, at >, end of tag name
 273                     stringstate_finish(&tagname, buffer, pos-1);
 274                 // fallthrough
 275                 case -15: // after </, at >
 276                     out->end_tag(out, tagname.result);
 277                     stringstate_clear(&tagname);
 278                     stringstate_start(&data, buffer, pos);
 279                     state = 5;
 280                 break;
 281                 case -4: // end of data
 282                     stringstate_finish(&data, buffer, pos-1);
 283                     if(!first) out->data(out, data.result, data.len);
 284                     stringstate_clear(&data);
 285                     state = 2;
 286                 break;
 287                 case -7: // after <, at whitespace, end of tag name
 288                     stringstate_finish(&tagname, buffer, pos-1);
 289                     state = 7;
 290                 break;
 291                 case -8: // inside tag, start of attribute name
 292                     stringstate_start(&attr_name, buffer, pos-1);
 293                     state = 8;
 294                 break;
 295                 case -9:
 296                     stringstate_finish(&tagname, buffer, pos-1);
 297                     state = 3;
 298                 break;
 299                 case -12: // end of attribute name, at ws
 300                     stringstate_finish(&attr_name, buffer, pos-1);
 301                     state = 15;
 302                 break;
 303                 case -10: // end of attribute name, at =
 304                     stringstate_finish(&attr_name, buffer, pos-1);
 305                     state = 10;
 306                 break;
 307                 case -11: // start of attribute value
 308                     stringstate_start(&attr_value, buffer, pos);
 309                     state = 11;
 310                 break;
 311                 case -5: // end of attribute value
 312                     stringstate_finish(&attr_value, buffer, pos-1);
 313                     a = malloc(sizeof(xmlattribute_t));
 314                     a->name = attr_name.result;attr_name.result=0;
 315                     a->value = attr_value.result;attr_value.result=0;
 316                     a->next = attributes;
 317                     attributes = a;
 318                     state = 7;
 319                 break;
 320                 case -20:
 321                     state = 5;
 322                 break;
 323                 default:
 324                     if(-state&0x40) {
 325                         fprintf(stderr, "%s (state %d, char '%c')\n", errors[(-state)&0x3f], old, buffer[pos-1]);
 326                         return 0;
 327                     } else {
 328                         fprintf(stderr, "internal error: no action %d\n", state);
 329                     }
 330                     return 0;
 331                 break;
 332             }
 333         }
 334         stringstate_save(&tagname, buffer, pos);
 335         stringstate_save(&attr_name, buffer, pos);
 336         stringstate_save(&attr_value, buffer, pos);
 337         stringstate_save(&data, buffer, pos);
 338     }
 339
 340     /* note: any of these except data *has* to be empty for a well formed xml */
 341     stringstate_clear(&tagname);
 342     stringstate_clear(&attr_name);
 343     stringstate_clear(&attr_value);
 344     stringstate_clear(&data);
 345
 346     while(stack) {
 347         tag_stack_t*next = stack->prev;
 348         free((void*)stack->name);
 349         free(stack);
 350         stack = next;
 351     }
 352     return 1;
 353 }
 354
 355 #ifdef MAIN
 356 void my_start_tag(xmlconsumer_t*c, char*name, xmlattribute_t*attr)
 357 {
 358     printf("<%s", name);
 359     for(;attr;attr=attr->next) {
 360         printf(" %s=\"%s\"", attr->name, attr->value);
 361     }
 362     printf(">");
 363 }
 364 void my_data(xmlconsumer_t*c, char*data, int len)
 365 {
 366     printf("%s", data);
 367 }
 368 void my_end_tag(xmlconsumer_t*c, char*name)
 369 {
 370     printf("</%s>", name);
 371 }
 372 int main()
 373 {
 374     xmlconsumer_t c = {my_start_tag, my_data, my_end_tag, 0};
 375
 376     reader_t r;
 377     reader_init_filereader2(&r, "test.xml");
 378     xml_parse(&r, &c);
 379     r.dealloc(&r);
 380     printf("\n");
 381 }
 382 #endif