Deleted Added
sdiff udiff text old ( 104349 ) new ( 178848 )
full compact
xmlwf.c (104349) xmlwf.c (178848)
1/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
2 See the file COPYING for copying permission.
3*/
4
5#include <stdio.h>
6#include <stdlib.h>
7#include <stddef.h>
8#include <string.h>
9
10#include "expat.h"
11#include "codepage.h"
12#include "xmlfile.h"
13#include "xmltchar.h"
14
15#ifdef _MSC_VER
16#include <crtdbg.h>
17#endif
18
1/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
2 See the file COPYING for copying permission.
3*/
4
5#include <stdio.h>
6#include <stdlib.h>
7#include <stddef.h>
8#include <string.h>
9
10#include "expat.h"
11#include "codepage.h"
12#include "xmlfile.h"
13#include "xmltchar.h"
14
15#ifdef _MSC_VER
16#include <crtdbg.h>
17#endif
18
19#if defined(__amigaos__) && defined(__USE_INLINE__)
20#include <proto/expat.h>
21#endif
22
19/* This ensures proper sorting. */
20
21#define NSSEP T('\001')
22
23/* This ensures proper sorting. */
24
25#define NSSEP T('\001')
26
23static void
27static void XMLCALL
24characterData(void *userData, const XML_Char *s, int len)
25{
28characterData(void *userData, const XML_Char *s, int len)
29{
26 FILE *fp = userData;
30 FILE *fp = (FILE *)userData;
27 for (; len > 0; --len, ++s) {
28 switch (*s) {
29 case T('&'):
30 fputts(T("&amp;"), fp);
31 break;
32 case T('<'):
33 fputts(T("&lt;"), fp);
34 break;

--- 73 unchanged lines hidden (view full) ---

108is equivalent to lexicographically comparing based on the character number. */
109
110static int
111attcmp(const void *att1, const void *att2)
112{
113 return tcscmp(*(const XML_Char **)att1, *(const XML_Char **)att2);
114}
115
31 for (; len > 0; --len, ++s) {
32 switch (*s) {
33 case T('&'):
34 fputts(T("&amp;"), fp);
35 break;
36 case T('<'):
37 fputts(T("&lt;"), fp);
38 break;

--- 73 unchanged lines hidden (view full) ---

112is equivalent to lexicographically comparing based on the character number. */
113
114static int
115attcmp(const void *att1, const void *att2)
116{
117 return tcscmp(*(const XML_Char **)att1, *(const XML_Char **)att2);
118}
119
116static void
120static void XMLCALL
117startElement(void *userData, const XML_Char *name, const XML_Char **atts)
118{
119 int nAtts;
120 const XML_Char **p;
121startElement(void *userData, const XML_Char *name, const XML_Char **atts)
122{
123 int nAtts;
124 const XML_Char **p;
121 FILE *fp = userData;
125 FILE *fp = (FILE *)userData;
122 puttc(T('<'), fp);
123 fputts(name, fp);
124
125 p = atts;
126 while (*p)
127 ++p;
126 puttc(T('<'), fp);
127 fputts(name, fp);
128
129 p = atts;
130 while (*p)
131 ++p;
128 nAtts = (p - atts) >> 1;
132 nAtts = (int)((p - atts) >> 1);
129 if (nAtts > 1)
130 qsort((void *)atts, nAtts, sizeof(XML_Char *) * 2, attcmp);
131 while (*atts) {
132 puttc(T(' '), fp);
133 fputts(*atts++, fp);
134 attributeValue(fp, *atts);
135 atts++;
136 }
137 puttc(T('>'), fp);
138}
139
133 if (nAtts > 1)
134 qsort((void *)atts, nAtts, sizeof(XML_Char *) * 2, attcmp);
135 while (*atts) {
136 puttc(T(' '), fp);
137 fputts(*atts++, fp);
138 attributeValue(fp, *atts);
139 atts++;
140 }
141 puttc(T('>'), fp);
142}
143
140static void
144static void XMLCALL
141endElement(void *userData, const XML_Char *name)
142{
145endElement(void *userData, const XML_Char *name)
146{
143 FILE *fp = userData;
147 FILE *fp = (FILE *)userData;
144 puttc(T('<'), fp);
145 puttc(T('/'), fp);
146 fputts(name, fp);
147 puttc(T('>'), fp);
148}
149
150static int
151nsattcmp(const void *p1, const void *p2)
152{
153 const XML_Char *att1 = *(const XML_Char **)p1;
154 const XML_Char *att2 = *(const XML_Char **)p2;
155 int sep1 = (tcsrchr(att1, NSSEP) != 0);
156 int sep2 = (tcsrchr(att1, NSSEP) != 0);
157 if (sep1 != sep2)
158 return sep1 - sep2;
159 return tcscmp(att1, att2);
160}
161
148 puttc(T('<'), fp);
149 puttc(T('/'), fp);
150 fputts(name, fp);
151 puttc(T('>'), fp);
152}
153
154static int
155nsattcmp(const void *p1, const void *p2)
156{
157 const XML_Char *att1 = *(const XML_Char **)p1;
158 const XML_Char *att2 = *(const XML_Char **)p2;
159 int sep1 = (tcsrchr(att1, NSSEP) != 0);
160 int sep2 = (tcsrchr(att1, NSSEP) != 0);
161 if (sep1 != sep2)
162 return sep1 - sep2;
163 return tcscmp(att1, att2);
164}
165
162static void
166static void XMLCALL
163startElementNS(void *userData, const XML_Char *name, const XML_Char **atts)
164{
165 int nAtts;
166 int nsi;
167 const XML_Char **p;
167startElementNS(void *userData, const XML_Char *name, const XML_Char **atts)
168{
169 int nAtts;
170 int nsi;
171 const XML_Char **p;
168 FILE *fp = userData;
172 FILE *fp = (FILE *)userData;
169 const XML_Char *sep;
170 puttc(T('<'), fp);
171
172 sep = tcsrchr(name, NSSEP);
173 if (sep) {
174 fputts(T("n1:"), fp);
175 fputts(sep + 1, fp);
176 fputts(T(" xmlns:n1"), fp);
177 attributeValue(fp, name);
178 nsi = 2;
179 }
180 else {
181 fputts(name, fp);
182 nsi = 1;
183 }
184
185 p = atts;
186 while (*p)
187 ++p;
173 const XML_Char *sep;
174 puttc(T('<'), fp);
175
176 sep = tcsrchr(name, NSSEP);
177 if (sep) {
178 fputts(T("n1:"), fp);
179 fputts(sep + 1, fp);
180 fputts(T(" xmlns:n1"), fp);
181 attributeValue(fp, name);
182 nsi = 2;
183 }
184 else {
185 fputts(name, fp);
186 nsi = 1;
187 }
188
189 p = atts;
190 while (*p)
191 ++p;
188 nAtts = (p - atts) >> 1;
192 nAtts = (int)((p - atts) >> 1);
189 if (nAtts > 1)
190 qsort((void *)atts, nAtts, sizeof(XML_Char *) * 2, nsattcmp);
191 while (*atts) {
192 name = *atts++;
193 sep = tcsrchr(name, NSSEP);
194 puttc(T(' '), fp);
195 if (sep) {
196 ftprintf(fp, T("n%d:"), nsi);

--- 6 unchanged lines hidden (view full) ---

203 ftprintf(fp, T(" xmlns:n%d"), nsi++);
204 attributeValue(fp, name);
205 }
206 atts++;
207 }
208 puttc(T('>'), fp);
209}
210
193 if (nAtts > 1)
194 qsort((void *)atts, nAtts, sizeof(XML_Char *) * 2, nsattcmp);
195 while (*atts) {
196 name = *atts++;
197 sep = tcsrchr(name, NSSEP);
198 puttc(T(' '), fp);
199 if (sep) {
200 ftprintf(fp, T("n%d:"), nsi);

--- 6 unchanged lines hidden (view full) ---

207 ftprintf(fp, T(" xmlns:n%d"), nsi++);
208 attributeValue(fp, name);
209 }
210 atts++;
211 }
212 puttc(T('>'), fp);
213}
214
211static void
215static void XMLCALL
212endElementNS(void *userData, const XML_Char *name)
213{
216endElementNS(void *userData, const XML_Char *name)
217{
214 FILE *fp = userData;
218 FILE *fp = (FILE *)userData;
215 const XML_Char *sep;
216 puttc(T('<'), fp);
217 puttc(T('/'), fp);
218 sep = tcsrchr(name, NSSEP);
219 if (sep) {
220 fputts(T("n1:"), fp);
221 fputts(sep + 1, fp);
222 }
223 else
224 fputts(name, fp);
225 puttc(T('>'), fp);
226}
227
228#ifndef W3C14N
229
219 const XML_Char *sep;
220 puttc(T('<'), fp);
221 puttc(T('/'), fp);
222 sep = tcsrchr(name, NSSEP);
223 if (sep) {
224 fputts(T("n1:"), fp);
225 fputts(sep + 1, fp);
226 }
227 else
228 fputts(name, fp);
229 puttc(T('>'), fp);
230}
231
232#ifndef W3C14N
233
230static void
234static void XMLCALL
231processingInstruction(void *userData, const XML_Char *target,
232 const XML_Char *data)
233{
235processingInstruction(void *userData, const XML_Char *target,
236 const XML_Char *data)
237{
234 FILE *fp = userData;
238 FILE *fp = (FILE *)userData;
235 puttc(T('<'), fp);
236 puttc(T('?'), fp);
237 fputts(target, fp);
238 puttc(T(' '), fp);
239 fputts(data, fp);
240 puttc(T('?'), fp);
241 puttc(T('>'), fp);
242}
243
244#endif /* not W3C14N */
245
239 puttc(T('<'), fp);
240 puttc(T('?'), fp);
241 fputts(target, fp);
242 puttc(T(' '), fp);
243 fputts(data, fp);
244 puttc(T('?'), fp);
245 puttc(T('>'), fp);
246}
247
248#endif /* not W3C14N */
249
246static void
250static void XMLCALL
247defaultCharacterData(void *userData, const XML_Char *s, int len)
248{
249 XML_DefaultCurrent((XML_Parser) userData);
250}
251
251defaultCharacterData(void *userData, const XML_Char *s, int len)
252{
253 XML_DefaultCurrent((XML_Parser) userData);
254}
255
252static void
256static void XMLCALL
253defaultStartElement(void *userData, const XML_Char *name,
254 const XML_Char **atts)
255{
256 XML_DefaultCurrent((XML_Parser) userData);
257}
258
257defaultStartElement(void *userData, const XML_Char *name,
258 const XML_Char **atts)
259{
260 XML_DefaultCurrent((XML_Parser) userData);
261}
262
259static void
263static void XMLCALL
260defaultEndElement(void *userData, const XML_Char *name)
261{
262 XML_DefaultCurrent((XML_Parser) userData);
263}
264
264defaultEndElement(void *userData, const XML_Char *name)
265{
266 XML_DefaultCurrent((XML_Parser) userData);
267}
268
265static void
269static void XMLCALL
266defaultProcessingInstruction(void *userData, const XML_Char *target,
267 const XML_Char *data)
268{
269 XML_DefaultCurrent((XML_Parser) userData);
270}
271
270defaultProcessingInstruction(void *userData, const XML_Char *target,
271 const XML_Char *data)
272{
273 XML_DefaultCurrent((XML_Parser) userData);
274}
275
272static void
276static void XMLCALL
273nopCharacterData(void *userData, const XML_Char *s, int len)
274{
275}
276
277nopCharacterData(void *userData, const XML_Char *s, int len)
278{
279}
280
277static void
281static void XMLCALL
278nopStartElement(void *userData, const XML_Char *name, const XML_Char **atts)
279{
280}
281
282nopStartElement(void *userData, const XML_Char *name, const XML_Char **atts)
283{
284}
285
282static void
286static void XMLCALL
283nopEndElement(void *userData, const XML_Char *name)
284{
285}
286
287nopEndElement(void *userData, const XML_Char *name)
288{
289}
290
287static void
291static void XMLCALL
288nopProcessingInstruction(void *userData, const XML_Char *target,
289 const XML_Char *data)
290{
291}
292
292nopProcessingInstruction(void *userData, const XML_Char *target,
293 const XML_Char *data)
294{
295}
296
293static void
297static void XMLCALL
294markup(void *userData, const XML_Char *s, int len)
295{
298markup(void *userData, const XML_Char *s, int len)
299{
296 FILE *fp = XML_GetUserData((XML_Parser) userData);
300 FILE *fp = (FILE *)XML_GetUserData((XML_Parser) userData);
297 for (; len > 0; --len, ++s)
298 puttc(*s, fp);
299}
300
301static void
302metaLocation(XML_Parser parser)
303{
304 const XML_Char *uri = XML_GetBase(parser);
305 if (uri)
301 for (; len > 0; --len, ++s)
302 puttc(*s, fp);
303}
304
305static void
306metaLocation(XML_Parser parser)
307{
308 const XML_Char *uri = XML_GetBase(parser);
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 XML_GetCurrentByteIndex(parser),
310 XML_GetCurrentByteCount(parser),
311 XML_GetCurrentLineNumber(parser),
312 XML_GetCurrentColumnNumber(parser));
313}
314
315static void
316metaStartDocument(void *userData)
317{
314 XML_GetCurrentByteIndex(parser),
315 XML_GetCurrentByteCount(parser),
316 XML_GetCurrentLineNumber(parser),
317 XML_GetCurrentColumnNumber(parser));
318}
319
320static void
321metaStartDocument(void *userData)
322{
318 fputts(T("\n"), XML_GetUserData((XML_Parser) userData));
323 fputts(T("<document>\n"), (FILE *)XML_GetUserData((XML_Parser) userData));
319}
320
321static void
322metaEndDocument(void *userData)
323{
324}
325
326static void
327metaEndDocument(void *userData)
328{
324 fputts(T("\n"), XML_GetUserData((XML_Parser) userData));
329 fputts(T("</document>\n"), (FILE *)XML_GetUserData((XML_Parser) userData));
325}
326
330}
331
327static void
332static void XMLCALL
328metaStartElement(void *userData, const XML_Char *name,
329 const XML_Char **atts)
330{
331 XML_Parser parser = (XML_Parser) userData;
333metaStartElement(void *userData, const XML_Char *name,
334 const XML_Char **atts)
335{
336 XML_Parser parser = (XML_Parser) userData;
332 FILE *fp = XML_GetUserData(parser);
337 FILE *fp = (FILE *)XML_GetUserData(parser);
333 const XML_Char **specifiedAttsEnd
334 = atts + XML_GetSpecifiedAttributeCount(parser);
335 const XML_Char **idAttPtr;
336 int idAttIndex = XML_GetIdAttributeIndex(parser);
337 if (idAttIndex < 0)
338 idAttPtr = 0;
339 else
340 idAttPtr = atts + idAttIndex;
341
342 ftprintf(fp, T("<starttag name=\"%s\""), name);
343 metaLocation(parser);
344 if (*atts) {
345 fputts(T(">\n"), fp);
346 do {
347 ftprintf(fp, T("<attribute name=\"%s\" value=\""), atts[0]);
338 const XML_Char **specifiedAttsEnd
339 = atts + XML_GetSpecifiedAttributeCount(parser);
340 const XML_Char **idAttPtr;
341 int idAttIndex = XML_GetIdAttributeIndex(parser);
342 if (idAttIndex < 0)
343 idAttPtr = 0;
344 else
345 idAttPtr = atts + idAttIndex;
346
347 ftprintf(fp, T("<starttag name=\"%s\""), name);
348 metaLocation(parser);
349 if (*atts) {
350 fputts(T(">\n"), fp);
351 do {
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 if (atts >= specifiedAttsEnd)
350 fputts(T("\" defaulted=\"yes\"/>\n"), fp);
351 else if (atts == idAttPtr)
352 fputts(T("\" id=\"yes\"/>\n"), fp);
353 else
354 fputts(T("\"/>\n"), fp);
355 } while (*(atts += 2));
356 fputts(T("</starttag>\n"), fp);
357 }
358 else
359 fputts(T("/>\n"), fp);
360}
361
354 if (atts >= specifiedAttsEnd)
355 fputts(T("\" defaulted=\"yes\"/>\n"), fp);
356 else if (atts == idAttPtr)
357 fputts(T("\" id=\"yes\"/>\n"), fp);
358 else
359 fputts(T("\"/>\n"), fp);
360 } while (*(atts += 2));
361 fputts(T("</starttag>\n"), fp);
362 }
363 else
364 fputts(T("/>\n"), fp);
365}
366
362static void
367static void XMLCALL
363metaEndElement(void *userData, const XML_Char *name)
364{
365 XML_Parser parser = (XML_Parser) userData;
368metaEndElement(void *userData, const XML_Char *name)
369{
370 XML_Parser parser = (XML_Parser) userData;
366 FILE *fp = XML_GetUserData(parser);
371 FILE *fp = (FILE *)XML_GetUserData(parser);
367 ftprintf(fp, T("<endtag name=\"%s\""), name);
368 metaLocation(parser);
369 fputts(T("/>\n"), fp);
370}
371
372 ftprintf(fp, T("<endtag name=\"%s\""), name);
373 metaLocation(parser);
374 fputts(T("/>\n"), fp);
375}
376
372static void
377static void XMLCALL
373metaProcessingInstruction(void *userData, const XML_Char *target,
374 const XML_Char *data)
375{
376 XML_Parser parser = (XML_Parser) userData;
378metaProcessingInstruction(void *userData, const XML_Char *target,
379 const XML_Char *data)
380{
381 XML_Parser parser = (XML_Parser) userData;
377 FILE *fp = XML_GetUserData(parser);
382 FILE *fp = (FILE *)XML_GetUserData(parser);
378 ftprintf(fp, T("<pi target=\"%s\" data=\""), target);
383 ftprintf(fp, T("<pi target=\"%s\" data=\""), target);
379 characterData(fp, data, tcslen(data));
384 characterData(fp, data, (int)tcslen(data));
380 puttc(T('"'), fp);
381 metaLocation(parser);
382 fputts(T("/>\n"), fp);
383}
384
385 puttc(T('"'), fp);
386 metaLocation(parser);
387 fputts(T("/>\n"), fp);
388}
389
385static void
390static void XMLCALL
386metaComment(void *userData, const XML_Char *data)
387{
388 XML_Parser parser = (XML_Parser) userData;
391metaComment(void *userData, const XML_Char *data)
392{
393 XML_Parser parser = (XML_Parser) userData;
389 FILE *fp = XML_GetUserData(parser);
394 FILE *fp = (FILE *)XML_GetUserData(parser);
390 fputts(T("<comment data=\""), fp);
395 fputts(T("<comment data=\""), fp);
391 characterData(fp, data, tcslen(data));
396 characterData(fp, data, (int)tcslen(data));
392 puttc(T('"'), fp);
393 metaLocation(parser);
394 fputts(T("/>\n"), fp);
395}
396
397 puttc(T('"'), fp);
398 metaLocation(parser);
399 fputts(T("/>\n"), fp);
400}
401
397static void
402static void XMLCALL
398metaStartCdataSection(void *userData)
399{
400 XML_Parser parser = (XML_Parser) userData;
403metaStartCdataSection(void *userData)
404{
405 XML_Parser parser = (XML_Parser) userData;
401 FILE *fp = XML_GetUserData(parser);
406 FILE *fp = (FILE *)XML_GetUserData(parser);
402 fputts(T("<startcdata"), fp);
403 metaLocation(parser);
404 fputts(T("/>\n"), fp);
405}
406
407 fputts(T("<startcdata"), fp);
408 metaLocation(parser);
409 fputts(T("/>\n"), fp);
410}
411
407static void
412static void XMLCALL
408metaEndCdataSection(void *userData)
409{
410 XML_Parser parser = (XML_Parser) userData;
413metaEndCdataSection(void *userData)
414{
415 XML_Parser parser = (XML_Parser) userData;
411 FILE *fp = XML_GetUserData(parser);
416 FILE *fp = (FILE *)XML_GetUserData(parser);
412 fputts(T("<endcdata"), fp);
413 metaLocation(parser);
414 fputts(T("/>\n"), fp);
415}
416
417 fputts(T("<endcdata"), fp);
418 metaLocation(parser);
419 fputts(T("/>\n"), fp);
420}
421
417static void
422static void XMLCALL
418metaCharacterData(void *userData, const XML_Char *s, int len)
419{
420 XML_Parser parser = (XML_Parser) userData;
423metaCharacterData(void *userData, const XML_Char *s, int len)
424{
425 XML_Parser parser = (XML_Parser) userData;
421 FILE *fp = XML_GetUserData(parser);
426 FILE *fp = (FILE *)XML_GetUserData(parser);
422 fputts(T("<chars str=\""), fp);
423 characterData(fp, s, len);
424 puttc(T('"'), fp);
425 metaLocation(parser);
426 fputts(T("/>\n"), fp);
427}
428
427 fputts(T("<chars str=\""), fp);
428 characterData(fp, s, len);
429 puttc(T('"'), fp);
430 metaLocation(parser);
431 fputts(T("/>\n"), fp);
432}
433
429static void
434static void XMLCALL
430metaStartDoctypeDecl(void *userData,
431 const XML_Char *doctypeName,
432 const XML_Char *sysid,
433 const XML_Char *pubid,
434 int has_internal_subset)
435{
436 XML_Parser parser = (XML_Parser) userData;
435metaStartDoctypeDecl(void *userData,
436 const XML_Char *doctypeName,
437 const XML_Char *sysid,
438 const XML_Char *pubid,
439 int has_internal_subset)
440{
441 XML_Parser parser = (XML_Parser) userData;
437 FILE *fp = XML_GetUserData(parser);
442 FILE *fp = (FILE *)XML_GetUserData(parser);
438 ftprintf(fp, T("<startdoctype name=\"%s\""), doctypeName);
439 metaLocation(parser);
440 fputts(T("/>\n"), fp);
441}
442
443 ftprintf(fp, T("<startdoctype name=\"%s\""), doctypeName);
444 metaLocation(parser);
445 fputts(T("/>\n"), fp);
446}
447
443static void
448static void XMLCALL
444metaEndDoctypeDecl(void *userData)
445{
446 XML_Parser parser = (XML_Parser) userData;
449metaEndDoctypeDecl(void *userData)
450{
451 XML_Parser parser = (XML_Parser) userData;
447 FILE *fp = XML_GetUserData(parser);
452 FILE *fp = (FILE *)XML_GetUserData(parser);
448 fputts(T("<enddoctype"), fp);
449 metaLocation(parser);
450 fputts(T("/>\n"), fp);
451}
452
453 fputts(T("<enddoctype"), fp);
454 metaLocation(parser);
455 fputts(T("/>\n"), fp);
456}
457
453static void
458static void XMLCALL
454metaNotationDecl(void *userData,
455 const XML_Char *notationName,
456 const XML_Char *base,
457 const XML_Char *systemId,
458 const XML_Char *publicId)
459{
460 XML_Parser parser = (XML_Parser) userData;
459metaNotationDecl(void *userData,
460 const XML_Char *notationName,
461 const XML_Char *base,
462 const XML_Char *systemId,
463 const XML_Char *publicId)
464{
465 XML_Parser parser = (XML_Parser) userData;
461 FILE *fp = XML_GetUserData(parser);
466 FILE *fp = (FILE *)XML_GetUserData(parser);
462 ftprintf(fp, T("<notation name=\"%s\""), notationName);
463 if (publicId)
464 ftprintf(fp, T(" public=\"%s\""), publicId);
465 if (systemId) {
466 fputts(T(" system=\""), fp);
467 ftprintf(fp, T("<notation name=\"%s\""), notationName);
468 if (publicId)
469 ftprintf(fp, T(" public=\"%s\""), publicId);
470 if (systemId) {
471 fputts(T(" system=\""), fp);
467 characterData(fp, systemId, tcslen(systemId));
472 characterData(fp, systemId, (int)tcslen(systemId));
468 puttc(T('"'), fp);
469 }
470 metaLocation(parser);
471 fputts(T("/>\n"), fp);
472}
473
474
473 puttc(T('"'), fp);
474 }
475 metaLocation(parser);
476 fputts(T("/>\n"), fp);
477}
478
479
475static void
480static void XMLCALL
476metaEntityDecl(void *userData,
477 const XML_Char *entityName,
478 int is_param,
479 const XML_Char *value,
480 int value_length,
481 const XML_Char *base,
482 const XML_Char *systemId,
483 const XML_Char *publicId,
484 const XML_Char *notationName)
485{
486 XML_Parser parser = (XML_Parser) userData;
481metaEntityDecl(void *userData,
482 const XML_Char *entityName,
483 int is_param,
484 const XML_Char *value,
485 int value_length,
486 const XML_Char *base,
487 const XML_Char *systemId,
488 const XML_Char *publicId,
489 const XML_Char *notationName)
490{
491 XML_Parser parser = (XML_Parser) userData;
487 FILE *fp = XML_GetUserData(parser);
492 FILE *fp = (FILE *)XML_GetUserData(parser);
488
489 if (value) {
490 ftprintf(fp, T("<entity name=\"%s\""), entityName);
491 metaLocation(parser);
492 puttc(T('>'), fp);
493 characterData(fp, value, value_length);
494 fputts(T("</entity/>\n"), fp);
495 }
496 else if (notationName) {
497 ftprintf(fp, T("<entity name=\"%s\""), entityName);
498 if (publicId)
499 ftprintf(fp, T(" public=\"%s\""), publicId);
500 fputts(T(" system=\""), fp);
493
494 if (value) {
495 ftprintf(fp, T("<entity name=\"%s\""), entityName);
496 metaLocation(parser);
497 puttc(T('>'), fp);
498 characterData(fp, value, value_length);
499 fputts(T("</entity/>\n"), fp);
500 }
501 else if (notationName) {
502 ftprintf(fp, T("<entity name=\"%s\""), entityName);
503 if (publicId)
504 ftprintf(fp, T(" public=\"%s\""), publicId);
505 fputts(T(" system=\""), fp);
501 characterData(fp, systemId, tcslen(systemId));
506 characterData(fp, systemId, (int)tcslen(systemId));
502 puttc(T('"'), fp);
503 ftprintf(fp, T(" notation=\"%s\""), notationName);
504 metaLocation(parser);
505 fputts(T("/>\n"), fp);
506 }
507 else {
508 ftprintf(fp, T("<entity name=\"%s\""), entityName);
509 if (publicId)
510 ftprintf(fp, T(" public=\"%s\""), publicId);
511 fputts(T(" system=\""), fp);
507 puttc(T('"'), fp);
508 ftprintf(fp, T(" notation=\"%s\""), notationName);
509 metaLocation(parser);
510 fputts(T("/>\n"), fp);
511 }
512 else {
513 ftprintf(fp, T("<entity name=\"%s\""), entityName);
514 if (publicId)
515 ftprintf(fp, T(" public=\"%s\""), publicId);
516 fputts(T(" system=\""), fp);
512 characterData(fp, systemId, tcslen(systemId));
517 characterData(fp, systemId, (int)tcslen(systemId));
513 puttc(T('"'), fp);
514 metaLocation(parser);
515 fputts(T("/>\n"), fp);
516 }
517}
518
518 puttc(T('"'), fp);
519 metaLocation(parser);
520 fputts(T("/>\n"), fp);
521 }
522}
523
519static void
524static void XMLCALL
520metaStartNamespaceDecl(void *userData,
521 const XML_Char *prefix,
522 const XML_Char *uri)
523{
524 XML_Parser parser = (XML_Parser) userData;
525metaStartNamespaceDecl(void *userData,
526 const XML_Char *prefix,
527 const XML_Char *uri)
528{
529 XML_Parser parser = (XML_Parser) userData;
525 FILE *fp = XML_GetUserData(parser);
530 FILE *fp = (FILE *)XML_GetUserData(parser);
526 fputts(T("<startns"), fp);
527 if (prefix)
528 ftprintf(fp, T(" prefix=\"%s\""), prefix);
529 if (uri) {
530 fputts(T(" ns=\""), fp);
531 fputts(T("<startns"), fp);
532 if (prefix)
533 ftprintf(fp, T(" prefix=\"%s\""), prefix);
534 if (uri) {
535 fputts(T(" ns=\""), fp);
531 characterData(fp, uri, tcslen(uri));
536 characterData(fp, uri, (int)tcslen(uri));
532 fputts(T("\"/>\n"), fp);
533 }
534 else
535 fputts(T("/>\n"), fp);
536}
537
537 fputts(T("\"/>\n"), fp);
538 }
539 else
540 fputts(T("/>\n"), fp);
541}
542
538static void
543static void XMLCALL
539metaEndNamespaceDecl(void *userData, const XML_Char *prefix)
540{
541 XML_Parser parser = (XML_Parser) userData;
544metaEndNamespaceDecl(void *userData, const XML_Char *prefix)
545{
546 XML_Parser parser = (XML_Parser) userData;
542 FILE *fp = XML_GetUserData(parser);
547 FILE *fp = (FILE *)XML_GetUserData(parser);
543 if (!prefix)
544 fputts(T("<endns/>\n"), fp);
545 else
546 ftprintf(fp, T("<endns prefix=\"%s\"/>\n"), prefix);
547}
548
548 if (!prefix)
549 fputts(T("<endns/>\n"), fp);
550 else
551 ftprintf(fp, T("<endns prefix=\"%s\"/>\n"), prefix);
552}
553
549static int
554static int XMLCALL
550unknownEncodingConvert(void *data, const char *p)
551{
552 return codepageConvert(*(int *)data, p);
553}
554
555unknownEncodingConvert(void *data, const char *p)
556{
557 return codepageConvert(*(int *)data, p);
558}
559
555static int
560static int XMLCALL
556unknownEncoding(void *userData, const XML_Char *name, XML_Encoding *info)
557{
558 int cp;
559 static const XML_Char prefixL[] = T("windows-");
560 static const XML_Char prefixU[] = T("WINDOWS-");
561 int i;
562
563 for (i = 0; prefixU[i]; i++)
564 if (name[i] != prefixU[i] && name[i] != prefixL[i])
565 return 0;
566
567 cp = 0;
568 for (; name[i]; i++) {
569 static const XML_Char digits[] = T("0123456789");
570 const XML_Char *s = tcschr(digits, name[i]);
571 if (!s)
572 return 0;
573 cp *= 10;
561unknownEncoding(void *userData, const XML_Char *name, XML_Encoding *info)
562{
563 int cp;
564 static const XML_Char prefixL[] = T("windows-");
565 static const XML_Char prefixU[] = T("WINDOWS-");
566 int i;
567
568 for (i = 0; prefixU[i]; i++)
569 if (name[i] != prefixU[i] && name[i] != prefixL[i])
570 return 0;
571
572 cp = 0;
573 for (; name[i]; i++) {
574 static const XML_Char digits[] = T("0123456789");
575 const XML_Char *s = tcschr(digits, name[i]);
576 if (!s)
577 return 0;
578 cp *= 10;
574 cp += s - digits;
579 cp += (int)(s - digits);
575 if (cp >= 0x10000)
576 return 0;
577 }
578 if (!codepageMap(cp, info->map))
579 return 0;
580 info->convert = unknownEncodingConvert;
581 /* We could just cast the code page integer to a void *,
582 and avoid the use of release. */
583 info->release = free;
584 info->data = malloc(sizeof(int));
585 if (!info->data)
586 return 0;
587 *(int *)info->data = cp;
588 return 1;
589}
590
580 if (cp >= 0x10000)
581 return 0;
582 }
583 if (!codepageMap(cp, info->map))
584 return 0;
585 info->convert = unknownEncodingConvert;
586 /* We could just cast the code page integer to a void *,
587 and avoid the use of release. */
588 info->release = free;
589 info->data = malloc(sizeof(int));
590 if (!info->data)
591 return 0;
592 *(int *)info->data = cp;
593 return 1;
594}
595
591static int
596static int XMLCALL
592notStandalone(void *userData)
593{
594 return 0;
595}
596
597static void
598showVersion(XML_Char *prog)
599{
600 XML_Char *s = prog;
601 XML_Char ch;
602 const XML_Feature *features = XML_GetFeatureList();
603 while ((ch = *s) != 0) {
604 if (ch == '/'
597notStandalone(void *userData)
598{
599 return 0;
600}
601
602static void
603showVersion(XML_Char *prog)
604{
605 XML_Char *s = prog;
606 XML_Char ch;
607 const XML_Feature *features = XML_GetFeatureList();
608 while ((ch = *s) != 0) {
609 if (ch == '/'
605#ifdef WIN32
610#if (defined(WIN32) || defined(__WATCOMC__))
606 || ch == '\\'
607#endif
608 )
609 prog = s + 1;
610 ++s;
611 }
612 ftprintf(stdout, T("%s using %s\n"), prog, XML_ExpatVersion());
613 if (features != NULL && features[0].feature != XML_FEATURE_END) {

--- 26 unchanged lines hidden (view full) ---

640 int i, j;
641 const XML_Char *outputDir = NULL;
642 const XML_Char *encoding = NULL;
643 unsigned processFlags = XML_MAP_FILE;
644 int windowsCodePages = 0;
645 int outputType = 0;
646 int useNamespaces = 0;
647 int requireStandalone = 0;
611 || ch == '\\'
612#endif
613 )
614 prog = s + 1;
615 ++s;
616 }
617 ftprintf(stdout, T("%s using %s\n"), prog, XML_ExpatVersion());
618 if (features != NULL && features[0].feature != XML_FEATURE_END) {

--- 26 unchanged lines hidden (view full) ---

645 int i, j;
646 const XML_Char *outputDir = NULL;
647 const XML_Char *encoding = NULL;
648 unsigned processFlags = XML_MAP_FILE;
649 int windowsCodePages = 0;
650 int outputType = 0;
651 int useNamespaces = 0;
652 int requireStandalone = 0;
648 int paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;
653 enum XML_ParamEntityParsing paramEntityParsing =
654 XML_PARAM_ENTITY_PARSING_NEVER;
649 int useStdin = 0;
650
651#ifdef _MSC_VER
652 _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF|_CRTDBG_LEAK_CHECK_DF);
653#endif
654
655 i = 1;
656 j = 0;

--- 104 unchanged lines hidden (view full) ---

761 /* This is for doing timings; this gives a more realistic estimate of
762 the parsing time. */
763 outputDir = 0;
764 XML_SetElementHandler(parser, nopStartElement, nopEndElement);
765 XML_SetCharacterDataHandler(parser, nopCharacterData);
766 XML_SetProcessingInstructionHandler(parser, nopProcessingInstruction);
767 }
768 else if (outputDir) {
655 int useStdin = 0;
656
657#ifdef _MSC_VER
658 _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF|_CRTDBG_LEAK_CHECK_DF);
659#endif
660
661 i = 1;
662 j = 0;

--- 104 unchanged lines hidden (view full) ---

767 /* This is for doing timings; this gives a more realistic estimate of
768 the parsing time. */
769 outputDir = 0;
770 XML_SetElementHandler(parser, nopStartElement, nopEndElement);
771 XML_SetCharacterDataHandler(parser, nopCharacterData);
772 XML_SetProcessingInstructionHandler(parser, nopProcessingInstruction);
773 }
774 else if (outputDir) {
775 const XML_Char * delim = T("/");
769 const XML_Char *file = useStdin ? T("STDIN") : argv[i];
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#endif
791#endif
776 outName = malloc((tcslen(outputDir) + tcslen(file) + 2)
792 }
793 outName = (XML_Char *)malloc((tcslen(outputDir) + tcslen(file) + 2)
777 * sizeof(XML_Char));
778 tcscpy(outName, outputDir);
794 * sizeof(XML_Char));
795 tcscpy(outName, outputDir);
779 tcscat(outName, T("/"));
796 tcscat(outName, delim);
780 tcscat(outName, file);
781 fp = tfopen(outName, T("wb"));
782 if (!fp) {
783 tperror(outName);
784 exit(1);
785 }
786 setvbuf(fp, NULL, _IOFBF, 16384);
787#ifdef XML_UNICODE

--- 55 unchanged lines hidden --- 		797 tcscat(outName, file);
798 fp = tfopen(outName, T("wb"));
799 if (!fp) {
800 tperror(outName);
801 exit(1);
802 }
803 setvbuf(fp, NULL, _IOFBF, 16384);
804#ifdef XML_UNICODE

--- 55 unchanged lines hidden ---