← Back to branch summary

~ubuntu-branches/ubuntu/saucy/totem-pl-parser/saucy-proposed

« back to all changes in this revision

Viewing changes to debian/patches/01_make-reentrant.patch

  • Committer: Bazaar Package Importer
  • Author(s): Sebastian Dröge
  • Date: 2009-12-11 14:36:54 UTC
  • mfrom: (1.5.3 squeeze)
  • Revision ID: james.westby@ubuntu.com-20091211143654-qw2v124b01bo8pid
Tags: 2.28.2-1
http://bugs.debian.org/558644
* New upstream bugfix release:
  + debian/patches/01_make-reentrant.patch:
    - Dropped, merged upstream.
  + Include gio/gio.h instead of relying on GTK+ to include
    it, which it doesn't in older versions (Closes: #558644).
  + debian/rules:
    - Update shlibs version for new API.

Show diffs side-by-side

added added

removed removed

Lines of Context:
debian/patches/01_make-reentrant.patch
1
 
only in patch2:
2
 
unchanged:
3
 
--- totem-pl-parser-2.28.1.orig/plparse/xmllexer.h
4
 
+++ totem-pl-parser-2.28.1/plparse/xmllexer.h
5
 
@@ -51,9 +51,26 @@
6
 
 #define T_CDATA_STOP    19   /* ]]> */
7
 
 
8
 
 
9
 
+/* public structures */
10
 
+struct lexer
11
 
+{
12
 
+  const char * lexbuf;
13
 
+  int lexbuf_size;
14
 
+  int lexbuf_pos;
15
 
+  int in_comment;
16
 
+  char * lex_malloc;
17
 
+  enum {
18
 
+    NORMAL,
19
 
+    DATA,
20
 
+    CDATA,
21
 
+  } lex_mode;
22
 
+};
23
 
+
24
 
+
25
 
 /* public functions */
26
 
-void lexer_init(const char * buf, int size) XINE_PROTECTED;
27
 
-int lexer_get_token(char * tok, int tok_size) XINE_PROTECTED;
28
 
+struct lexer *lexer_init(const char * buf, int size) XINE_PROTECTED;
29
 
+void lexer_finalize(struct lexer * lexer) XINE_PROTECTED;
30
 
+int lexer_get_token(struct lexer * lexer, char * tok, int tok_size) XINE_PROTECTED;
31
 
 char *lexer_decode_entities (const char *tok) XINE_PROTECTED;
32
 
 
33
 
 #endif
34
 
only in patch2:
35
 
unchanged:
36
 
--- totem-pl-parser-2.28.1.orig/plparse/xmlparser.c
37
 
+++ totem-pl-parser-2.28.1/plparse/xmlparser.c
38
 
@@ -51,9 +51,6 @@
39
 
 #define DATA_SIZE   64 * 1024
40
 
 #define MAX_RECURSION 23
41
 
 
42
 
-/* private global variables */
43
 
-static int xml_parser_mode;
44
 
-
45
 
 /* private functions */
46
 
 
47
 
 static char * strtoupper(char * str) {
48
 
@@ -103,10 +100,17 @@
49
 
   free(property);
50
 
 }
51
 
 
52
 
-void xml_parser_init(const char * buf, int size, int mode) {
53
 
+xml_parser_t *xml_parser_init(const char * buf, int size, int mode) {
54
 
+  xml_parser_t *xml_parser = malloc(sizeof(xml_parser_t));
55
 
+  xml_parser->lexer = lexer_init(buf, size);
56
 
+  xml_parser->mode = mode;
57
 
+  return xml_parser;
58
 
+}
59
 
 
60
 
-  lexer_init(buf, size);
61
 
-  xml_parser_mode = mode;
62
 
+void xml_parser_finalize(xml_parser_t *xml_parser)
63
 
+{
64
 
+  lexer_finalize(xml_parser->lexer);
65
 
+  free(xml_parser);
66
 
 }
67
 
 
68
 
 static void xml_parser_free_props(xml_property_t *current_property) {
69
 
@@ -220,7 +224,7 @@
70
 
 
71
 
 #define Q_STATE(CURRENT,NEW) (STATE_##NEW + state - STATE_##CURRENT)
72
 
 
73
 
-static int xml_parser_get_node_internal (xml_node_t *current_node, char *root_names[], int rec, int flags)
74
 
+static int xml_parser_get_node_internal (xml_parser_t *xml_parser, xml_node_t *current_node, char *root_names[], int rec, int flags)
75
 
 {
76
 
   char tok[TOKEN_SIZE];
77
 
   char property_name[TOKEN_SIZE];
78
 
@@ -239,7 +243,7 @@
79
 
 
80
 
     memset (tok, 0, TOKEN_SIZE);
81
 
 
82
 
-    while ((bypass_get_token) || (res = lexer_get_token(tok, TOKEN_SIZE)) != T_ERROR) {
83
 
+    while ((bypass_get_token) || (res = lexer_get_token(xml_parser->lexer, tok, TOKEN_SIZE)) != T_ERROR) {
84
 
       bypass_get_token = 0;
85
 
       lprintf("info: %d - %d : '%s'\n", state, res, tok);
86
 
 
87
 
@@ -295,7 +299,7 @@
88
 
          current_property = NULL;
89
 
 
90
 
          /* save node name */
91
 
-         if (xml_parser_mode == XML_PARSER_CASE_INSENSITIVE) {
92
 
+         if (xml_parser->mode == XML_PARSER_CASE_INSENSITIVE) {
93
 
            strtoupper(tok);
94
 
          }
95
 
          if (state == STATE_Q_NODE) {
96
 
@@ -331,7 +335,7 @@
97
 
          subtree->props = properties;
98
 
          lprintf("info: rec %d new subtree %s\n", rec, node_name);
99
 
          root_names[rec + 1] = node_name;
100
 
-         parse_res = xml_parser_get_node_internal(subtree, root_names, rec + 1, flags);
101
 
+         parse_res = xml_parser_get_node_internal(xml_parser, subtree, root_names, rec + 1, flags);
102
 
          if (parse_res == -1 || parse_res > 0) {
103
 
            return parse_res;
104
 
          }
105
 
@@ -374,7 +378,7 @@
106
 
        case (T_IDENT):
107
 
          /* save property name */
108
 
          new_prop:
109
 
-         if (xml_parser_mode == XML_PARSER_CASE_INSENSITIVE) {
110
 
+         if (xml_parser->mode == XML_PARSER_CASE_INSENSITIVE) {
111
 
            strtoupper(tok);
112
 
          }
113
 
          strcpy(property_name, tok);
114
 
@@ -409,7 +413,7 @@
115
 
        switch (res) {
116
 
        case (T_IDENT):
117
 
          /* must be equal to root_name */
118
 
-         if (xml_parser_mode == XML_PARSER_CASE_INSENSITIVE) {
119
 
+         if (xml_parser->mode == XML_PARSER_CASE_INSENSITIVE) {
120
 
            strtoupper(tok);
121
 
          }
122
 
          if (strcmp(tok, root_names[rec]) == 0) {
123
 
@@ -621,19 +625,19 @@
124
 
   }
125
 
 }
126
 
 
127
 
-static int xml_parser_get_node (xml_node_t *current_node, int flags)
128
 
+static int xml_parser_get_node (xml_parser_t *xml_parser, xml_node_t *current_node, int flags)
129
 
 {
130
 
   char *root_names[MAX_RECURSION + 1];
131
 
   root_names[0] = "";
132
 
-  return xml_parser_get_node_internal (current_node, root_names, 0, flags);
133
 
+  return xml_parser_get_node_internal (xml_parser, current_node, root_names, 0, flags);
134
 
 }
135
 
 
136
 
-int xml_parser_build_tree_with_options(xml_node_t **root_node, int flags) {
137
 
+int xml_parser_build_tree_with_options(xml_parser_t *xml_parser, xml_node_t **root_node, int flags) {
138
 
   xml_node_t *tmp_node, *pri_node, *q_node;
139
 
   int res;
140
 
 
141
 
   tmp_node = new_xml_node();
142
 
-  res = xml_parser_get_node(tmp_node, flags);
143
 
+  res = xml_parser_get_node(xml_parser, tmp_node, flags);
144
 
 
145
 
   /* delete any top-level [CDATA] nodes */;
146
 
   pri_node = tmp_node->child;
147
 
@@ -676,8 +680,8 @@
148
 
   return res;
149
 
 }
150
 
 
151
 
-int xml_parser_build_tree(xml_node_t **root_node) {
152
 
-  return xml_parser_build_tree_with_options (root_node, 0);
153
 
+int xml_parser_build_tree(xml_parser_t *xml_parser, xml_node_t **root_node) {
154
 
+  return xml_parser_build_tree_with_options (xml_parser, root_node, 0);
155
 
 }
156
 
 
157
 
 const char *xml_parser_get_property (const xml_node_t *node, const char *name) {
158
 
only in patch2:
159
 
unchanged:
160
 
--- totem-pl-parser-2.28.1.orig/plparse/totem-pl-parser.c
161
 
+++ totem-pl-parser-2.28.1/plparse/totem-pl-parser.c
162
 
@@ -1676,11 +1676,16 @@
163
 
        xml_node_t* doc, *node;
164
 
        char *encoding, *new_contents;
165
 
        gsize new_size;
166
 
+       xml_parser_t *xml_parser;
167
 
 
168
 
        totem_pl_parser_cleanup_xml (contents);
169
 
-       xml_parser_init (contents, size, XML_PARSER_CASE_INSENSITIVE);
170
 
-       if (xml_parser_build_tree_with_options (&doc, XML_PARSER_RELAXED | XML_PARSER_MULTI_TEXT) < 0)
171
 
+       xml_parser = xml_parser_init (contents, size, XML_PARSER_CASE_INSENSITIVE);
172
 
+       if (xml_parser_build_tree_with_options (xml_parser, &doc, XML_PARSER_RELAXED | XML_PARSER_MULTI_TEXT) < 0) {
173
 
+               xml_parser_finalize (xml_parser);
174
 
                return NULL;
175
 
+       }
176
 
+
177
 
+       xml_parser_finalize (xml_parser);
178
 
 
179
 
        encoding = NULL;
180
 
        for (node = doc; node != NULL; node = node->next) {
181
 
@@ -1705,12 +1710,14 @@
182
 
        }
183
 
        g_free (encoding);
184
 
 
185
 
-       xml_parser_init (new_contents, new_size, XML_PARSER_CASE_INSENSITIVE);
186
 
-       if (xml_parser_build_tree_with_options (&doc, XML_PARSER_RELAXED | XML_PARSER_MULTI_TEXT) < 0) {
187
 
+       xml_parser = xml_parser_init (new_contents, new_size, XML_PARSER_CASE_INSENSITIVE);
188
 
+       if (xml_parser_build_tree_with_options (xml_parser, &doc, XML_PARSER_RELAXED | XML_PARSER_MULTI_TEXT) < 0) {
189
 
+               xml_parser_finalize (xml_parser);
190
 
                g_free (new_contents);
191
 
                return NULL;
192
 
        }
193
 
 
194
 
+       xml_parser_finalize (xml_parser);
195
 
        g_free (new_contents);
196
 
 
197
 
        return doc;
198
 
only in patch2:
199
 
unchanged:
200
 
--- totem-pl-parser-2.28.1.orig/plparse/xmlparser.h
201
 
+++ totem-pl-parser-2.28.1/plparse/xmlparser.h
202
 
@@ -65,10 +65,16 @@
203
 
        struct xml_node_s *next;
204
 
 } xml_node_t;
205
 
 
206
 
-void xml_parser_init(const char * buf, int size, int mode) XINE_PROTECTED;
207
 
+typedef struct xml_parser_s {
208
 
+       struct lexer *lexer;
209
 
+       int mode;
210
 
+} xml_parser_t;
211
 
 
212
 
-int xml_parser_build_tree(xml_node_t **root_node) XINE_PROTECTED;
213
 
-int xml_parser_build_tree_with_options(xml_node_t **root_node, int flags) XINE_PROTECTED;
214
 
+xml_parser_t *xml_parser_init(const char * buf, int size, int mode) XINE_PROTECTED;
215
 
+void xml_parser_finalize(xml_parser_t *xml_parser) XINE_PROTECTED;
216
 
+
217
 
+int xml_parser_build_tree(xml_parser_t *xml_parser, xml_node_t **root_node) XINE_PROTECTED;
218
 
+int xml_parser_build_tree_with_options(xml_parser_t *xml_parser, xml_node_t **root_node, int flags) XINE_PROTECTED;
219
 
 
220
 
 void xml_parser_free_tree(xml_node_t *root_node) XINE_PROTECTED;
221
 
 
222
 
only in patch2:
223
 
unchanged:
224
 
--- totem-pl-parser-2.28.1.orig/plparse/xmllexer.c
225
 
+++ totem-pl-parser-2.28.1/plparse/xmllexer.c
226
 
@@ -44,16 +44,9 @@
227
 
 
228
 
 /* private constants*/
229
 
 
230
 
-/* private global variables */
231
 
-static const char * lexbuf;
232
 
-static int lexbuf_size = 0;
233
 
-static int lexbuf_pos  = 0;
234
 
-static int in_comment  = 0;
235
 
-static char *lex_malloc = NULL;
236
 
-
237
 
 enum utf { UTF32BE, UTF32LE, UTF16BE, UTF16LE };
238
 
 
239
 
-static void lex_convert (const char * buf, int size, enum utf utf)
240
 
+static void lex_convert (struct lexer * lexer, const char * buf, int size, enum utf utf)
241
 
 {
242
 
   char *utf8 = malloc (size * (utf >= UTF16BE ? 3 : 6) + 1);
243
 
   char *bp = utf8;
244
 
@@ -85,45 +78,44 @@
245
 
     }
246
 
   }
247
 
   *bp = 0;
248
 
-  lexbuf_size = bp - utf8;
249
 
-  lexbuf = lex_malloc = realloc (utf8, lexbuf_size + 1);
250
 
+  lexer->lexbuf_size = bp - utf8;
251
 
+  lexer->lexbuf = lexer->lex_malloc = realloc (utf8, lexer->lexbuf_size + 1);
252
 
 }
253
 
 
254
 
-static enum {
255
 
-  NORMAL,
256
 
-  DATA,
257
 
-  CDATA,
258
 
-} lex_mode = NORMAL;
259
 
-
260
 
-void lexer_init(const char * buf, int size) {
261
 
+struct lexer *lexer_init(const char * buf, int size) {
262
 
   static const char boms[] = { 0xFF, 0xFE, 0, 0, 0xFE, 0xFF },
263
 
                    bom_utf8[] = { 0xEF, 0xBB, 0xBF };
264
 
+  struct lexer * lexer = calloc (1, sizeof (*lexer));
265
 
 
266
 
-  free (lex_malloc);
267
 
-  lex_malloc = NULL;
268
 
-
269
 
-  lexbuf      = buf;
270
 
-  lexbuf_size = size;
271
 
+  lexer->lexbuf      = buf;
272
 
+  lexer->lexbuf_size = size;
273
 
 
274
 
   if (size >= 4 && !memcmp (buf, boms + 2, 4))
275
 
-    lex_convert (buf + 4, size - 4, UTF32BE);
276
 
+    lex_convert (lexer, buf + 4, size - 4, UTF32BE);
277
 
   else if (size >= 4 && !memcmp (buf, boms, 4))
278
 
-    lex_convert (buf + 4, size - 4, UTF32LE);
279
 
+    lex_convert (lexer, buf + 4, size - 4, UTF32LE);
280
 
   else if (size >= 3 && !memcmp (buf, bom_utf8, 3))
281
 
   {
282
 
-    lexbuf += 3;
283
 
-    lexbuf_size -= 3;
284
 
+    lexer->lexbuf += 3;
285
 
+    lexer->lexbuf_size -= 3;
286
 
   }
287
 
   else if (size >= 2 && !memcmp (buf, boms + 4, 2))
288
 
-    lex_convert (buf + 2, size - 2, UTF16BE);
289
 
+    lex_convert (lexer, buf + 2, size - 2, UTF16BE);
290
 
   else if (size >= 2 && !memcmp (buf, boms, 2))
291
 
-    lex_convert (buf + 2, size - 2, UTF16LE);
292
 
+    lex_convert (lexer, buf + 2, size - 2, UTF16LE);
293
 
 
294
 
-  lexbuf_pos  = 0;
295
 
-  lex_mode    = NORMAL;
296
 
-  in_comment  = 0;
297
 
+  lexer->lexbuf_pos  = 0;
298
 
+  lexer->lex_mode    = NORMAL;
299
 
+  lexer->in_comment  = 0;
300
 
 
301
 
   lprintf("buffer length %d\n", size);
302
 
+  return lexer;
303
 
+}
304
 
+
305
 
+void lexer_finalize(struct lexer * lexer)
306
 
+{
307
 
+  free (lexer->lex_malloc);
308
 
+  free (lexer);
309
 
 }
310
 
 
311
 
 typedef enum {
312
 
@@ -144,17 +136,17 @@
313
 
   STATE_IDENT /* must be last */
314
 
 } lexer_state_t;
315
 
 
316
 
-int lexer_get_token(char * tok, int tok_size) {
317
 
+int lexer_get_token(struct lexer * lexer, char * tok, int tok_size) {
318
 
   int tok_pos = 0;
319
 
   lexer_state_t state = STATE_IDLE;
320
 
   char c;
321
 
 
322
 
   if (tok) {
323
 
-    while ((tok_pos < tok_size) && (lexbuf_pos < lexbuf_size)) {
324
 
-      c = lexbuf[lexbuf_pos];
325
 
-      lprintf("c=%c, state=%d, lex_mode=%d, in_comment=%d\n", c, state, lex_mode, in_comment);
326
 
+    while ((tok_pos < tok_size) && (lexer->lexbuf_pos < lexer->lexbuf_size)) {
327
 
+      c = lexer->lexbuf[lexer->lexbuf_pos];
328
 
+      lprintf("c=%c, state=%d, lex_mode=%d, lexer->in_comment=%d\n", c, state, lexer->lex_mode, lexer->in_comment);
329
 
 
330
 
-      switch (lex_mode) {
331
 
+      switch (lexer->lex_mode) {
332
 
       case NORMAL:
333
 
        switch (state) {
334
 
          /* init state */
335
 
@@ -187,7 +179,7 @@
336
 
            break;
337
 
 
338
 
          case '/':
339
 
-           if (!in_comment) 
340
 
+           if (!lexer->in_comment) 
341
 
              state = STATE_T_M_STOP_2;
342
 
            tok[tok_pos] = c;
343
 
            tok_pos++;
344
 
@@ -214,7 +206,7 @@
345
 
            break;
346
 
 
347
 
          case '?':
348
 
-           if (!in_comment)
349
 
+           if (!lexer->in_comment)
350
 
              state = STATE_T_TI_STOP;
351
 
            tok[tok_pos] = c;
352
 
            tok_pos++;
353
 
@@ -226,14 +218,14 @@
354
 
            tok_pos++;
355
 
            break;
356
 
          }
357
 
-         lexbuf_pos++;
358
 
+         lexer->lexbuf_pos++;
359
 
          break;
360
 
 
361
 
          /* end of line */
362
 
        case STATE_EOL:
363
 
          if (c == '\n' || (c == '\r')) {
364
 
            tok[tok_pos] = c;
365
 
-           lexbuf_pos++;
366
 
+           lexer->lexbuf_pos++;
367
 
            tok_pos++;
368
 
          } else {
369
 
            tok[tok_pos] = '\0';
370
 
@@ -245,7 +237,7 @@
371
 
        case STATE_SEPAR:
372
 
          if (c == ' ' || (c == '\t')) {
373
 
            tok[tok_pos] = c;
374
 
-           lexbuf_pos++;
375
 
+           lexer->lexbuf_pos++;
376
 
            tok_pos++;
377
 
          } else {
378
 
            tok[tok_pos] = '\0';
379
 
@@ -258,20 +250,20 @@
380
 
          switch (c) {
381
 
          case '/':
382
 
            tok[tok_pos] = c;
383
 
-           lexbuf_pos++;
384
 
+           lexer->lexbuf_pos++;
385
 
            tok_pos++; /* FIXME */
386
 
            tok[tok_pos] = '\0';
387
 
            return T_M_START_2;
388
 
            break;
389
 
          case '!':
390
 
            tok[tok_pos] = c;
391
 
-           lexbuf_pos++;
392
 
+           lexer->lexbuf_pos++;
393
 
            tok_pos++;
394
 
            state = STATE_T_COMMENT;
395
 
            break;
396
 
          case '?':
397
 
            tok[tok_pos] = c;
398
 
-           lexbuf_pos++;
399
 
+           lexer->lexbuf_pos++;
400
 
            tok_pos++; /* FIXME */
401
 
            tok[tok_pos] = '\0';
402
 
            return T_TI_START;
403
 
@@ -285,8 +277,8 @@
404
 
          /* T_M_STOP_1 */
405
 
        case STATE_T_M_STOP_1:
406
 
          tok[tok_pos] = '\0';
407
 
-         if (!in_comment)
408
 
-           lex_mode = DATA;
409
 
+         if (!lexer->in_comment)
410
 
+           lexer->lex_mode = DATA;
411
 
          return T_M_STOP_1;
412
 
          break;
413
 
 
414
 
@@ -294,11 +286,11 @@
415
 
        case STATE_T_M_STOP_2:
416
 
          if (c == '>') {
417
 
            tok[tok_pos] = c;
418
 
-           lexbuf_pos++;
419
 
+           lexer->lexbuf_pos++;
420
 
            tok_pos++; /* FIXME */
421
 
            tok[tok_pos] = '\0';
422
 
-           if (!in_comment)
423
 
-             lex_mode = DATA;
424
 
+           if (!lexer->in_comment)
425
 
+             lexer->lex_mode = DATA;
426
 
            return T_M_STOP_2;
427
 
          } else {
428
 
            tok[tok_pos] = '\0';
429
 
@@ -315,7 +307,7 @@
430
 
          /* T_STRING */
431
 
        case STATE_T_STRING_DOUBLE:
432
 
          tok[tok_pos] = c;
433
 
-         lexbuf_pos++;
434
 
+         lexer->lexbuf_pos++;
435
 
          if (c == '\"') { /* " */
436
 
            tok[tok_pos] = '\0'; /* FIXME */
437
 
            return T_STRING;
438
 
@@ -327,33 +319,33 @@
439
 
        case STATE_T_COMMENT:
440
 
          switch (c) {
441
 
          case '-':
442
 
-           lexbuf_pos++;
443
 
-           if (lexbuf[lexbuf_pos] == '-')
444
 
+           lexer->lexbuf_pos++;
445
 
+           if (lexer->lexbuf[lexer->lexbuf_pos] == '-')
446
 
              {
447
 
-               lexbuf_pos++;
448
 
+               lexer->lexbuf_pos++;
449
 
                tok[tok_pos++] = '-'; /* FIXME */
450
 
                tok[tok_pos++] = '-';
451
 
                tok[tok_pos] = '\0';
452
 
-               in_comment = 1;
453
 
+               lexer->in_comment = 1;
454
 
                return T_C_START;
455
 
              }
456
 
            break;
457
 
          case 'D':
458
 
-           lexbuf_pos++;
459
 
-           if (strncmp(lexbuf + lexbuf_pos, "OCTYPE", 6) == 0) {
460
 
+           lexer->lexbuf_pos++;
461
 
+           if (strncmp(lexer->lexbuf + lexer->lexbuf_pos, "OCTYPE", 6) == 0) {
462
 
              strncpy(tok + tok_pos, "DOCTYPE", 7); /* FIXME */
463
 
-             lexbuf_pos += 6;
464
 
+             lexer->lexbuf_pos += 6;
465
 
              return T_DOCTYPE_START;
466
 
            } else {
467
 
              return T_ERROR;
468
 
            }
469
 
            break;
470
 
          case '[':
471
 
-           lexbuf_pos++;
472
 
-           if (strncmp(lexbuf + lexbuf_pos, "CDATA[", 6) == 0) {
473
 
+           lexer->lexbuf_pos++;
474
 
+           if (strncmp(lexer->lexbuf + lexer->lexbuf_pos, "CDATA[", 6) == 0) {
475
 
              strncpy (tok + tok_pos, "[CDATA[", 7); /* FIXME */
476
 
-             lexbuf_pos += 6;
477
 
-             lex_mode = CDATA;
478
 
+             lexer->lexbuf_pos += 6;
479
 
+             lexer->lex_mode = CDATA;
480
 
              return T_CDATA_START;
481
 
            } else{
482
 
              return T_ERROR;
483
 
@@ -369,11 +361,11 @@
484
 
        case STATE_T_TI_STOP:
485
 
          if (c == '>') {
486
 
            tok[tok_pos] = c;
487
 
-           lexbuf_pos++;
488
 
+           lexer->lexbuf_pos++;
489
 
            tok_pos++; /* FIXME */
490
 
            tok[tok_pos] = '\0';
491
 
-           if (!in_comment)
492
 
-             lex_mode = DATA;
493
 
+           if (!lexer->in_comment)
494
 
+             lexer->lex_mode = DATA;
495
 
            return T_TI_STOP;
496
 
          } else {
497
 
            tok[tok_pos] = '\0';
498
 
@@ -387,13 +379,13 @@
499
 
          case '-':
500
 
            tok[tok_pos] = c;
501
 
            tok_pos++;
502
 
-           lexbuf_pos++;
503
 
+           lexer->lexbuf_pos++;
504
 
            state = STATE_T_C_STOP;
505
 
            break;
506
 
          default:
507
 
            tok[tok_pos] = c;
508
 
            tok_pos++;
509
 
-           lexbuf_pos++;
510
 
+           lexer->lexbuf_pos++;
511
 
            state = STATE_IDENT;
512
 
          }
513
 
          break;
514
 
@@ -404,21 +396,21 @@
515
 
          case '>':
516
 
            tok[tok_pos] = c;
517
 
            tok_pos++;
518
 
-           lexbuf_pos++;
519
 
+           lexer->lexbuf_pos++;
520
 
            tok[tok_pos] = '\0'; /* FIX ME */
521
 
            if (strlen(tok) != 3) {
522
 
              tok[tok_pos - 3] = '\0';
523
 
-             lexbuf_pos -= 3;
524
 
+             lexer->lexbuf_pos -= 3;
525
 
              return T_IDENT;
526
 
            } else {
527
 
-             in_comment = 0;
528
 
+             lexer->in_comment = 0;
529
 
              return T_C_STOP;
530
 
            }
531
 
            break;
532
 
          default:
533
 
            tok[tok_pos] = c;
534
 
            tok_pos++;
535
 
-           lexbuf_pos++;
536
 
+           lexer->lexbuf_pos++;
537
 
            state = STATE_IDENT;
538
 
          }
539
 
          break;
540
 
@@ -426,7 +418,7 @@
541
 
          /* T_STRING (single quotes) */
542
 
        case STATE_T_STRING_SINGLE:
543
 
          tok[tok_pos] = c;
544
 
-         lexbuf_pos++;
545
 
+         lexer->lexbuf_pos++;
546
 
          if (c == '\'') { /* " */
547
 
            tok[tok_pos] = '\0'; /* FIXME */
548
 
            return T_STRING;
549
 
@@ -453,19 +445,19 @@
550
 
          case '?':
551
 
            tok[tok_pos] = c;
552
 
            tok_pos++;
553
 
-           lexbuf_pos++;
554
 
+           lexer->lexbuf_pos++;
555
 
            state = STATE_T_TI_STOP;
556
 
            break;
557
 
          case '-':
558
 
            tok[tok_pos] = c;
559
 
            tok_pos++;
560
 
-           lexbuf_pos++;
561
 
+           lexer->lexbuf_pos++;
562
 
            state = STATE_T_DASHDASH;
563
 
            break;
564
 
          default:
565
 
            tok[tok_pos] = c;
566
 
            tok_pos++;
567
 
-           lexbuf_pos++;
568
 
+           lexer->lexbuf_pos++;
569
 
          }
570
 
          break;
571
 
        default:
572
 
@@ -479,12 +471,12 @@
573
 
         {
574
 
         case '<':
575
 
          tok[tok_pos] = '\0';
576
 
-         lex_mode = NORMAL;
577
 
+         lexer->lex_mode = NORMAL;
578
 
          return T_DATA;
579
 
        default:
580
 
          tok[tok_pos] = c;
581
 
          tok_pos++;
582
 
-         lexbuf_pos++;
583
 
+         lexer->lexbuf_pos++;
584
 
        }
585
 
        break;
586
 
 
587
 
@@ -492,32 +484,32 @@
588
 
         switch (c)
589
 
         {
590
 
        case ']':
591
 
-         if (strncmp(lexbuf + lexbuf_pos, "]]>", 3) == 0) {
592
 
-           lexbuf_pos += 3;
593
 
-           lex_mode = DATA;
594
 
+         if (strncmp(lexer->lexbuf + lexer->lexbuf_pos, "]]>", 3) == 0) {
595
 
+           lexer->lexbuf_pos += 3;
596
 
+           lexer->lex_mode = DATA;
597
 
            return T_CDATA_STOP;
598
 
          } else {
599
 
            tok[tok_pos] = c;
600
 
            tok_pos++;
601
 
-           lexbuf_pos++;
602
 
+           lexer->lexbuf_pos++;
603
 
          }
604
 
          break;
605
 
        default:
606
 
          tok[tok_pos] = c;
607
 
          tok_pos++;
608
 
-         lexbuf_pos++;
609
 
+         lexer->lexbuf_pos++;
610
 
        }
611
 
        break;
612
 
       }
613
 
     }
614
 
     lprintf ("loop done tok_pos = %d, tok_size=%d, lexbuf_pos=%d, lexbuf_size=%d\n", 
615
 
-            tok_pos, tok_size, lexbuf_pos, lexbuf_size);
616
 
+            tok_pos, tok_size, lexer->lexbuf_pos, lexer->lexbuf_size);
617
 
 
618
 
     /* pb */
619
 
     if (tok_pos >= tok_size) {
620
 
       lprintf("token buffer is too little\n");
621
 
     } else {
622
 
-      if (lexbuf_pos >= lexbuf_size) {
623
 
+      if (lexer->lexbuf_pos >= lexer->lexbuf_size) {
624
 
                                /* Terminate the current token */
625
 
        tok[tok_pos] = '\0';
626
 
        switch (state) {