← Back to branch summary

~ubuntu-branches/ubuntu/precise/expat/precise-security

« back to all changes in this revision

Viewing changes to xmlwf/xmlwf.c

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Leidert (dale)
  • Date: 2008-06-09 20:48:30 UTC
  • mfrom: (4.1.4 hardy)
  • Revision ID: james.westby@ubuntu.com-20080609204830-25qbpwdhrov7tuyc
Tags: 2.0.1-4
http://bugs.debian.org/485460
debian/libexpat1-dev.install: Install the libtool .la files again and drop
them after Lenny (closes: #485460).

Show diffs side-by-side

added added

removed removed

Lines of Context:
xmlwf/xmlwf.c
16
16
#include <crtdbg.h>
17
17
#endif
18
18
 
 
19
#if defined(__amigaos__) && defined(__USE_INLINE__)
 
20
#include <proto/expat.h>
 
21
#endif
 
22
 
19
23
/* This ensures proper sorting. */
20
24
 
21
25
#define NSSEP T('\001')
23
27
static void XMLCALL
24
28
characterData(void *userData, const XML_Char *s, int len)
25
29
{
26
 
  FILE *fp = userData;
 
30
  FILE *fp = (FILE *)userData;
27
31
  for (; len > 0; --len, ++s) {
28
32
    switch (*s) {
29
33
    case T('&'):
118
122
{
119
123
  int nAtts;
120
124
  const XML_Char **p;
121
 
  FILE *fp = userData;
 
125
  FILE *fp = (FILE *)userData;
122
126
  puttc(T('<'), fp);
123
127
  fputts(name, fp);
124
128
 
125
129
  p = atts;
126
130
  while (*p)
127
131
    ++p;
128
 
  nAtts = (p - atts) >> 1;
 
132
  nAtts = (int)((p - atts) >> 1);
129
133
  if (nAtts > 1)
130
134
    qsort((void *)atts, nAtts, sizeof(XML_Char *) * 2, attcmp);
131
135
  while (*atts) {
140
144
static void XMLCALL
141
145
endElement(void *userData, const XML_Char *name)
142
146
{
143
 
  FILE *fp = userData;
 
147
  FILE *fp = (FILE *)userData;
144
148
  puttc(T('<'), fp);
145
149
  puttc(T('/'), fp);
146
150
  fputts(name, fp);
165
169
  int nAtts;
166
170
  int nsi;
167
171
  const XML_Char **p;
168
 
  FILE *fp = userData;
 
172
  FILE *fp = (FILE *)userData;
169
173
  const XML_Char *sep;
170
174
  puttc(T('<'), fp);
171
175
 
185
189
  p = atts;
186
190
  while (*p)
187
191
    ++p;
188
 
  nAtts = (p - atts) >> 1;
 
192
  nAtts = (int)((p - atts) >> 1);
189
193
  if (nAtts > 1)
190
194
    qsort((void *)atts, nAtts, sizeof(XML_Char *) * 2, nsattcmp);
191
195
  while (*atts) {
211
215
static void XMLCALL
212
216
endElementNS(void *userData, const XML_Char *name)
213
217
{
214
 
  FILE *fp = userData;
 
218
  FILE *fp = (FILE *)userData;
215
219
  const XML_Char *sep;
216
220
  puttc(T('<'), fp);
217
221
  puttc(T('/'), fp);
231
235
processingInstruction(void *userData, const XML_Char *target,
232
236
                      const XML_Char *data)
233
237
{
234
 
  FILE *fp = userData;
 
238
  FILE *fp = (FILE *)userData;
235
239
  puttc(T('<'), fp);
236
240
  puttc(T('?'), fp);
237
241
  fputts(target, fp);
293
297
static void XMLCALL
294
298
markup(void *userData, const XML_Char *s, int len)
295
299
{
296
 
  FILE *fp = XML_GetUserData((XML_Parser) userData);
 
300
  FILE *fp = (FILE *)XML_GetUserData((XML_Parser) userData);
297
301
  for (; len > 0; --len, ++s)
298
302
    puttc(*s, fp);
299
303
}
303
307
{
304
308
  const XML_Char *uri = XML_GetBase(parser);
305
309
  if (uri)
306
 
    ftprintf(XML_GetUserData(parser), T(" uri=\"%s\""), uri);
307
 
  ftprintf(XML_GetUserData(parser),
308
 
           T(" byte=\"%ld\" nbytes=\"%d\" line=\"%d\" col=\"%d\""),
 
310
    ftprintf((FILE *)XML_GetUserData(parser), T(" uri=\"%s\""), uri);
 
311
  ftprintf((FILE *)XML_GetUserData(parser),
 
312
           T(" byte=\"%" XML_FMT_INT_MOD "d\" nbytes=\"%d\" \
 
313
                         line=\"%" XML_FMT_INT_MOD "u\" col=\"%" XML_FMT_INT_MOD "u\""),
309
314
           XML_GetCurrentByteIndex(parser),
310
315
           XML_GetCurrentByteCount(parser),
311
316
           XML_GetCurrentLineNumber(parser),
315
320
static void
316
321
metaStartDocument(void *userData)
317
322
{
318
 
  fputts(T("<document>\n"), XML_GetUserData((XML_Parser) userData));
 
323
  fputts(T("<document>\n"), (FILE *)XML_GetUserData((XML_Parser) userData));
319
324
}
320
325
 
321
326
static void
322
327
metaEndDocument(void *userData)
323
328
{
324
 
  fputts(T("</document>\n"), XML_GetUserData((XML_Parser) userData));
 
329
  fputts(T("</document>\n"), (FILE *)XML_GetUserData((XML_Parser) userData));
325
330
}
326
331
 
327
332
static void XMLCALL
329
334
                 const XML_Char **atts)
330
335
{
331
336
  XML_Parser parser = (XML_Parser) userData;
332
 
  FILE *fp = XML_GetUserData(parser);
 
337
  FILE *fp = (FILE *)XML_GetUserData(parser);
333
338
  const XML_Char **specifiedAttsEnd
334
339
    = atts + XML_GetSpecifiedAttributeCount(parser);
335
340
  const XML_Char **idAttPtr;
345
350
    fputts(T(">\n"), fp);
346
351
    do {
347
352
      ftprintf(fp, T("<attribute name=\"%s\" value=\""), atts[0]);
348
 
      characterData(fp, atts[1], tcslen(atts[1]));
 
353
      characterData(fp, atts[1], (int)tcslen(atts[1]));
349
354
      if (atts >= specifiedAttsEnd)
350
355
        fputts(T("\" defaulted=\"yes\"/>\n"), fp);
351
356
      else if (atts == idAttPtr)
363
368
metaEndElement(void *userData, const XML_Char *name)
364
369
{
365
370
  XML_Parser parser = (XML_Parser) userData;
366
 
  FILE *fp = XML_GetUserData(parser);
 
371
  FILE *fp = (FILE *)XML_GetUserData(parser);
367
372
  ftprintf(fp, T("<endtag name=\"%s\""), name);
368
373
  metaLocation(parser);
369
374
  fputts(T("/>\n"), fp);
374
379
                          const XML_Char *data)
375
380
{
376
381
  XML_Parser parser = (XML_Parser) userData;
377
 
  FILE *fp = XML_GetUserData(parser);
 
382
  FILE *fp = (FILE *)XML_GetUserData(parser);
378
383
  ftprintf(fp, T("<pi target=\"%s\" data=\""), target);
379
 
  characterData(fp, data, tcslen(data));
 
384
  characterData(fp, data, (int)tcslen(data));
380
385
  puttc(T('"'), fp);
381
386
  metaLocation(parser);
382
387
  fputts(T("/>\n"), fp);
386
391
metaComment(void *userData, const XML_Char *data)
387
392
{
388
393
  XML_Parser parser = (XML_Parser) userData;
389
 
  FILE *fp = XML_GetUserData(parser);
 
394
  FILE *fp = (FILE *)XML_GetUserData(parser);
390
395
  fputts(T("<comment data=\""), fp);
391
 
  characterData(fp, data, tcslen(data));
 
396
  characterData(fp, data, (int)tcslen(data));
392
397
  puttc(T('"'), fp);
393
398
  metaLocation(parser);
394
399
  fputts(T("/>\n"), fp);
398
403
metaStartCdataSection(void *userData)
399
404
{
400
405
  XML_Parser parser = (XML_Parser) userData;
401
 
  FILE *fp = XML_GetUserData(parser);
 
406
  FILE *fp = (FILE *)XML_GetUserData(parser);
402
407
  fputts(T("<startcdata"), fp);
403
408
  metaLocation(parser);
404
409
  fputts(T("/>\n"), fp);
408
413
metaEndCdataSection(void *userData)
409
414
{
410
415
  XML_Parser parser = (XML_Parser) userData;
411
 
  FILE *fp = XML_GetUserData(parser);
 
416
  FILE *fp = (FILE *)XML_GetUserData(parser);
412
417
  fputts(T("<endcdata"), fp);
413
418
  metaLocation(parser);
414
419
  fputts(T("/>\n"), fp);
418
423
metaCharacterData(void *userData, const XML_Char *s, int len)
419
424
{
420
425
  XML_Parser parser = (XML_Parser) userData;
421
 
  FILE *fp = XML_GetUserData(parser);
 
426
  FILE *fp = (FILE *)XML_GetUserData(parser);
422
427
  fputts(T("<chars str=\""), fp);
423
428
  characterData(fp, s, len);
424
429
  puttc(T('"'), fp);
434
439
                     int has_internal_subset)
435
440
{
436
441
  XML_Parser parser = (XML_Parser) userData;
437
 
  FILE *fp = XML_GetUserData(parser);
 
442
  FILE *fp = (FILE *)XML_GetUserData(parser);
438
443
  ftprintf(fp, T("<startdoctype name=\"%s\""), doctypeName);
439
444
  metaLocation(parser);
440
445
  fputts(T("/>\n"), fp);
444
449
metaEndDoctypeDecl(void *userData)
445
450
{
446
451
  XML_Parser parser = (XML_Parser) userData;
447
 
  FILE *fp = XML_GetUserData(parser);
 
452
  FILE *fp = (FILE *)XML_GetUserData(parser);
448
453
  fputts(T("<enddoctype"), fp);
449
454
  metaLocation(parser);
450
455
  fputts(T("/>\n"), fp);
458
463
                 const XML_Char *publicId)
459
464
{
460
465
  XML_Parser parser = (XML_Parser) userData;
461
 
  FILE *fp = XML_GetUserData(parser);
 
466
  FILE *fp = (FILE *)XML_GetUserData(parser);
462
467
  ftprintf(fp, T("<notation name=\"%s\""), notationName);
463
468
  if (publicId)
464
469
    ftprintf(fp, T(" public=\"%s\""), publicId);
465
470
  if (systemId) {
466
471
    fputts(T(" system=\""), fp);
467
 
    characterData(fp, systemId, tcslen(systemId));
 
472
    characterData(fp, systemId, (int)tcslen(systemId));
468
473
    puttc(T('"'), fp);
469
474
  }
470
475
  metaLocation(parser);
484
489
               const XML_Char *notationName)
485
490
{
486
491
  XML_Parser parser = (XML_Parser) userData;
487
 
  FILE *fp = XML_GetUserData(parser);
 
492
  FILE *fp = (FILE *)XML_GetUserData(parser);
488
493
 
489
494
  if (value) {
490
495
    ftprintf(fp, T("<entity name=\"%s\""), entityName);
498
503
    if (publicId)
499
504
      ftprintf(fp, T(" public=\"%s\""), publicId);
500
505
    fputts(T(" system=\""), fp);
501
 
    characterData(fp, systemId, tcslen(systemId));
 
506
    characterData(fp, systemId, (int)tcslen(systemId));
502
507
    puttc(T('"'), fp);
503
508
    ftprintf(fp, T(" notation=\"%s\""), notationName);
504
509
    metaLocation(parser);
509
514
    if (publicId)
510
515
      ftprintf(fp, T(" public=\"%s\""), publicId);
511
516
    fputts(T(" system=\""), fp);
512
 
    characterData(fp, systemId, tcslen(systemId));
 
517
    characterData(fp, systemId, (int)tcslen(systemId));
513
518
    puttc(T('"'), fp);
514
519
    metaLocation(parser);
515
520
    fputts(T("/>\n"), fp);
522
527
                       const XML_Char *uri)
523
528
{
524
529
  XML_Parser parser = (XML_Parser) userData;
525
 
  FILE *fp = XML_GetUserData(parser);
 
530
  FILE *fp = (FILE *)XML_GetUserData(parser);
526
531
  fputts(T("<startns"), fp);
527
532
  if (prefix)
528
533
    ftprintf(fp, T(" prefix=\"%s\""), prefix);
529
534
  if (uri) {
530
535
    fputts(T(" ns=\""), fp);
531
 
    characterData(fp, uri, tcslen(uri));
 
536
    characterData(fp, uri, (int)tcslen(uri));
532
537
    fputts(T("\"/>\n"), fp);
533
538
  }
534
539
  else
539
544
metaEndNamespaceDecl(void *userData, const XML_Char *prefix)
540
545
{
541
546
  XML_Parser parser = (XML_Parser) userData;
542
 
  FILE *fp = XML_GetUserData(parser);
 
547
  FILE *fp = (FILE *)XML_GetUserData(parser);
543
548
  if (!prefix)
544
549
    fputts(T("<endns/>\n"), fp);
545
550
  else
571
576
    if (!s)
572
577
      return 0;
573
578
    cp *= 10;
574
 
    cp += s - digits;
 
579
    cp += (int)(s - digits);
575
580
    if (cp >= 0x10000)
576
581
      return 0;
577
582
  }
602
607
  const XML_Feature *features = XML_GetFeatureList();
603
608
  while ((ch = *s) != 0) {
604
609
    if (ch == '/'
605
 
#ifdef WIN32
 
610
#if (defined(WIN32) || defined(__WATCOMC__))
606
611
        || ch == '\\'
607
612
#endif
608
613
        )
645
650
  int outputType = 0;
646
651
  int useNamespaces = 0;
647
652
  int requireStandalone = 0;
648
 
  int paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;
 
653
  enum XML_ParamEntityParsing paramEntityParsing = 
 
654
    XML_PARAM_ENTITY_PARSING_NEVER;
649
655
  int useStdin = 0;
650
656
 
651
657
#ifdef _MSC_VER
766
772
      XML_SetProcessingInstructionHandler(parser, nopProcessingInstruction);
767
773
    }
768
774
    else if (outputDir) {
 
775
      const XML_Char * delim = T("/");
769
776
      const XML_Char *file = useStdin ? T("STDIN") : argv[i];
770
 
      if (tcsrchr(file, T('/')))
771
 
        file = tcsrchr(file, T('/')) + 1;
772
 
#ifdef WIN32
773
 
      if (tcsrchr(file, T('\\')))
774
 
        file = tcsrchr(file, T('\\')) + 1;
 
777
      if (!useStdin) {
 
778
        /* Jump after last (back)slash */
 
779
        const XML_Char * lastDelim = tcsrchr(file, delim[0]);
 
780
        if (lastDelim)
 
781
          file = lastDelim + 1;
 
782
#if (defined(WIN32) || defined(__WATCOMC__))
 
783
        else {
 
784
          const XML_Char * winDelim = T("\\");
 
785
          lastDelim = tcsrchr(file, winDelim[0]);
 
786
          if (lastDelim) {
 
787
            file = lastDelim + 1;
 
788
            delim = winDelim;
 
789
          }
 
790
        }
775
791
#endif
776
 
      outName = malloc((tcslen(outputDir) + tcslen(file) + 2)
 
792
      }
 
793
      outName = (XML_Char *)malloc((tcslen(outputDir) + tcslen(file) + 2)
777
794
                       * sizeof(XML_Char));
778
795
      tcscpy(outName, outputDir);
779
 
      tcscat(outName, T("/"));
 
796
      tcscat(outName, delim);
780
797
      tcscat(outName, file);
781
798
      fp = tfopen(outName, T("wb"));
782
799
      if (!fp) {
832
849
      if (outputType == 'm')
833
850
        metaEndDocument(parser);
834
851
      fclose(fp);
835
 
      if (!result) {
836
 
        tremove(outName);
837
 
        exit(2);
838
 
      }
 
852
      if (!result)
 
853
        tremove(outName);
839
854
      free(outName);
840
855
    }
841
856
    XML_ParserFree(parser);