Annotation of embedaddon/libxml2/legacy.c, revision 1.1.1.2
1.1 misho 1: /*
2: * legacy.c: set of deprecated routines, not to be used anymore but
3: * kept purely for ABI compatibility
4: *
5: * See Copyright for the status of this software.
6: *
7: * daniel@veillard.com
8: */
9:
10: #define IN_LIBXML
11: #include "libxml.h"
12:
13: #ifdef LIBXML_LEGACY_ENABLED
14: #include <string.h>
15:
16: #include <libxml/tree.h>
17: #include <libxml/entities.h>
18: #include <libxml/SAX.h>
19: #include <libxml/parserInternals.h>
20: #include <libxml/HTMLparser.h>
21:
22: void xmlUpgradeOldNs(xmlDocPtr doc);
23:
24: /************************************************************************
25: * *
26: * Deprecated functions kept for compatibility *
27: * *
28: ************************************************************************/
29:
30: #ifdef LIBXML_HTML_ENABLED
31: xmlChar *htmlDecodeEntities(htmlParserCtxtPtr ctxt, int len, xmlChar end,
32: xmlChar end2, xmlChar end3);
33:
34: /**
35: * htmlDecodeEntities:
36: * @ctxt: the parser context
37: * @len: the len to decode (in bytes !), -1 for no size limit
38: * @end: an end marker xmlChar, 0 if none
39: * @end2: an end marker xmlChar, 0 if none
40: * @end3: an end marker xmlChar, 0 if none
41: *
42: * Substitute the HTML entities by their value
43: *
44: * DEPRECATED !!!!
45: *
46: * Returns A newly allocated string with the substitution done. The caller
47: * must deallocate it !
48: */
49: xmlChar *
50: htmlDecodeEntities(htmlParserCtxtPtr ctxt ATTRIBUTE_UNUSED,
51: int len ATTRIBUTE_UNUSED, xmlChar end ATTRIBUTE_UNUSED,
52: xmlChar end2 ATTRIBUTE_UNUSED,
53: xmlChar end3 ATTRIBUTE_UNUSED)
54: {
55: static int deprecated = 0;
56:
57: if (!deprecated) {
58: xmlGenericError(xmlGenericErrorContext,
59: "htmlDecodeEntities() deprecated function reached\n");
60: deprecated = 1;
61: }
62: return (NULL);
63: }
64: #endif
65:
66: /**
67: * xmlInitializePredefinedEntities:
68: *
69: * Set up the predefined entities.
70: * Deprecated call
71: */
72: void
73: xmlInitializePredefinedEntities(void)
74: {
75: }
76:
77: /**
78: * xmlCleanupPredefinedEntities:
79: *
80: * Cleanup up the predefined entities table.
81: * Deprecated call
82: */
83: void
84: xmlCleanupPredefinedEntities(void)
85: {
86: }
87:
88: static const char *xmlFeaturesList[] = {
89: "validate",
90: "load subset",
91: "keep blanks",
92: "disable SAX",
93: "fetch external entities",
94: "substitute entities",
95: "gather line info",
96: "user data",
97: "is html",
98: "is standalone",
99: "stop parser",
100: "document",
101: "is well formed",
102: "is valid",
103: "SAX block",
104: "SAX function internalSubset",
105: "SAX function isStandalone",
106: "SAX function hasInternalSubset",
107: "SAX function hasExternalSubset",
108: "SAX function resolveEntity",
109: "SAX function getEntity",
110: "SAX function entityDecl",
111: "SAX function notationDecl",
112: "SAX function attributeDecl",
113: "SAX function elementDecl",
114: "SAX function unparsedEntityDecl",
115: "SAX function setDocumentLocator",
116: "SAX function startDocument",
117: "SAX function endDocument",
118: "SAX function startElement",
119: "SAX function endElement",
120: "SAX function reference",
121: "SAX function characters",
122: "SAX function ignorableWhitespace",
123: "SAX function processingInstruction",
124: "SAX function comment",
125: "SAX function warning",
126: "SAX function error",
127: "SAX function fatalError",
128: "SAX function getParameterEntity",
129: "SAX function cdataBlock",
130: "SAX function externalSubset",
131: };
132:
133: /**
134: * xmlGetFeaturesList:
135: * @len: the length of the features name array (input/output)
136: * @result: an array of string to be filled with the features name.
137: *
138: * Copy at most *@len feature names into the @result array
139: *
140: * Returns -1 in case or error, or the total number of features,
141: * len is updated with the number of strings copied,
142: * strings must not be deallocated
143: */
144: int
145: xmlGetFeaturesList(int *len, const char **result)
146: {
147: int ret, i;
148:
149: ret = sizeof(xmlFeaturesList) / sizeof(xmlFeaturesList[0]);
150: if ((len == NULL) || (result == NULL))
151: return (ret);
152: if ((*len < 0) || (*len >= 1000))
153: return (-1);
154: if (*len > ret)
155: *len = ret;
156: for (i = 0; i < *len; i++)
157: result[i] = xmlFeaturesList[i];
158: return (ret);
159: }
160:
161: /**
162: * xmlGetFeature:
163: * @ctxt: an XML/HTML parser context
164: * @name: the feature name
165: * @result: location to store the result
166: *
167: * Read the current value of one feature of this parser instance
168: *
169: * Returns -1 in case or error, 0 otherwise
170: */
171: int
172: xmlGetFeature(xmlParserCtxtPtr ctxt, const char *name, void *result)
173: {
174: if ((ctxt == NULL) || (name == NULL) || (result == NULL))
175: return (-1);
176:
177: if (!strcmp(name, "validate")) {
178: *((int *) result) = ctxt->validate;
179: } else if (!strcmp(name, "keep blanks")) {
180: *((int *) result) = ctxt->keepBlanks;
181: } else if (!strcmp(name, "disable SAX")) {
182: *((int *) result) = ctxt->disableSAX;
183: } else if (!strcmp(name, "fetch external entities")) {
184: *((int *) result) = ctxt->loadsubset;
185: } else if (!strcmp(name, "substitute entities")) {
186: *((int *) result) = ctxt->replaceEntities;
187: } else if (!strcmp(name, "gather line info")) {
188: *((int *) result) = ctxt->record_info;
189: } else if (!strcmp(name, "user data")) {
190: *((void **) result) = ctxt->userData;
191: } else if (!strcmp(name, "is html")) {
192: *((int *) result) = ctxt->html;
193: } else if (!strcmp(name, "is standalone")) {
194: *((int *) result) = ctxt->standalone;
195: } else if (!strcmp(name, "document")) {
196: *((xmlDocPtr *) result) = ctxt->myDoc;
197: } else if (!strcmp(name, "is well formed")) {
198: *((int *) result) = ctxt->wellFormed;
199: } else if (!strcmp(name, "is valid")) {
200: *((int *) result) = ctxt->valid;
201: } else if (!strcmp(name, "SAX block")) {
202: *((xmlSAXHandlerPtr *) result) = ctxt->sax;
203: } else if (!strcmp(name, "SAX function internalSubset")) {
204: *((internalSubsetSAXFunc *) result) = ctxt->sax->internalSubset;
205: } else if (!strcmp(name, "SAX function isStandalone")) {
206: *((isStandaloneSAXFunc *) result) = ctxt->sax->isStandalone;
207: } else if (!strcmp(name, "SAX function hasInternalSubset")) {
208: *((hasInternalSubsetSAXFunc *) result) =
209: ctxt->sax->hasInternalSubset;
210: } else if (!strcmp(name, "SAX function hasExternalSubset")) {
211: *((hasExternalSubsetSAXFunc *) result) =
212: ctxt->sax->hasExternalSubset;
213: } else if (!strcmp(name, "SAX function resolveEntity")) {
214: *((resolveEntitySAXFunc *) result) = ctxt->sax->resolveEntity;
215: } else if (!strcmp(name, "SAX function getEntity")) {
216: *((getEntitySAXFunc *) result) = ctxt->sax->getEntity;
217: } else if (!strcmp(name, "SAX function entityDecl")) {
218: *((entityDeclSAXFunc *) result) = ctxt->sax->entityDecl;
219: } else if (!strcmp(name, "SAX function notationDecl")) {
220: *((notationDeclSAXFunc *) result) = ctxt->sax->notationDecl;
221: } else if (!strcmp(name, "SAX function attributeDecl")) {
222: *((attributeDeclSAXFunc *) result) = ctxt->sax->attributeDecl;
223: } else if (!strcmp(name, "SAX function elementDecl")) {
224: *((elementDeclSAXFunc *) result) = ctxt->sax->elementDecl;
225: } else if (!strcmp(name, "SAX function unparsedEntityDecl")) {
226: *((unparsedEntityDeclSAXFunc *) result) =
227: ctxt->sax->unparsedEntityDecl;
228: } else if (!strcmp(name, "SAX function setDocumentLocator")) {
229: *((setDocumentLocatorSAXFunc *) result) =
230: ctxt->sax->setDocumentLocator;
231: } else if (!strcmp(name, "SAX function startDocument")) {
232: *((startDocumentSAXFunc *) result) = ctxt->sax->startDocument;
233: } else if (!strcmp(name, "SAX function endDocument")) {
234: *((endDocumentSAXFunc *) result) = ctxt->sax->endDocument;
235: } else if (!strcmp(name, "SAX function startElement")) {
236: *((startElementSAXFunc *) result) = ctxt->sax->startElement;
237: } else if (!strcmp(name, "SAX function endElement")) {
238: *((endElementSAXFunc *) result) = ctxt->sax->endElement;
239: } else if (!strcmp(name, "SAX function reference")) {
240: *((referenceSAXFunc *) result) = ctxt->sax->reference;
241: } else if (!strcmp(name, "SAX function characters")) {
242: *((charactersSAXFunc *) result) = ctxt->sax->characters;
243: } else if (!strcmp(name, "SAX function ignorableWhitespace")) {
244: *((ignorableWhitespaceSAXFunc *) result) =
245: ctxt->sax->ignorableWhitespace;
246: } else if (!strcmp(name, "SAX function processingInstruction")) {
247: *((processingInstructionSAXFunc *) result) =
248: ctxt->sax->processingInstruction;
249: } else if (!strcmp(name, "SAX function comment")) {
250: *((commentSAXFunc *) result) = ctxt->sax->comment;
251: } else if (!strcmp(name, "SAX function warning")) {
252: *((warningSAXFunc *) result) = ctxt->sax->warning;
253: } else if (!strcmp(name, "SAX function error")) {
254: *((errorSAXFunc *) result) = ctxt->sax->error;
255: } else if (!strcmp(name, "SAX function fatalError")) {
256: *((fatalErrorSAXFunc *) result) = ctxt->sax->fatalError;
257: } else if (!strcmp(name, "SAX function getParameterEntity")) {
258: *((getParameterEntitySAXFunc *) result) =
259: ctxt->sax->getParameterEntity;
260: } else if (!strcmp(name, "SAX function cdataBlock")) {
261: *((cdataBlockSAXFunc *) result) = ctxt->sax->cdataBlock;
262: } else if (!strcmp(name, "SAX function externalSubset")) {
263: *((externalSubsetSAXFunc *) result) = ctxt->sax->externalSubset;
264: } else {
265: return (-1);
266: }
267: return (0);
268: }
269:
270: /**
271: * xmlSetFeature:
272: * @ctxt: an XML/HTML parser context
273: * @name: the feature name
274: * @value: pointer to the location of the new value
275: *
276: * Change the current value of one feature of this parser instance
277: *
278: * Returns -1 in case or error, 0 otherwise
279: */
280: int
281: xmlSetFeature(xmlParserCtxtPtr ctxt, const char *name, void *value)
282: {
283: if ((ctxt == NULL) || (name == NULL) || (value == NULL))
284: return (-1);
285:
286: if (!strcmp(name, "validate")) {
287: int newvalidate = *((int *) value);
288:
289: if ((!ctxt->validate) && (newvalidate != 0)) {
290: if (ctxt->vctxt.warning == NULL)
291: ctxt->vctxt.warning = xmlParserValidityWarning;
292: if (ctxt->vctxt.error == NULL)
293: ctxt->vctxt.error = xmlParserValidityError;
294: ctxt->vctxt.nodeMax = 0;
295: }
296: ctxt->validate = newvalidate;
297: } else if (!strcmp(name, "keep blanks")) {
298: ctxt->keepBlanks = *((int *) value);
299: } else if (!strcmp(name, "disable SAX")) {
300: ctxt->disableSAX = *((int *) value);
301: } else if (!strcmp(name, "fetch external entities")) {
302: ctxt->loadsubset = *((int *) value);
303: } else if (!strcmp(name, "substitute entities")) {
304: ctxt->replaceEntities = *((int *) value);
305: } else if (!strcmp(name, "gather line info")) {
306: ctxt->record_info = *((int *) value);
307: } else if (!strcmp(name, "user data")) {
308: ctxt->userData = *((void **) value);
309: } else if (!strcmp(name, "is html")) {
310: ctxt->html = *((int *) value);
311: } else if (!strcmp(name, "is standalone")) {
312: ctxt->standalone = *((int *) value);
313: } else if (!strcmp(name, "document")) {
314: ctxt->myDoc = *((xmlDocPtr *) value);
315: } else if (!strcmp(name, "is well formed")) {
316: ctxt->wellFormed = *((int *) value);
317: } else if (!strcmp(name, "is valid")) {
318: ctxt->valid = *((int *) value);
319: } else if (!strcmp(name, "SAX block")) {
320: ctxt->sax = *((xmlSAXHandlerPtr *) value);
321: } else if (!strcmp(name, "SAX function internalSubset")) {
322: ctxt->sax->internalSubset = *((internalSubsetSAXFunc *) value);
323: } else if (!strcmp(name, "SAX function isStandalone")) {
324: ctxt->sax->isStandalone = *((isStandaloneSAXFunc *) value);
325: } else if (!strcmp(name, "SAX function hasInternalSubset")) {
326: ctxt->sax->hasInternalSubset =
327: *((hasInternalSubsetSAXFunc *) value);
328: } else if (!strcmp(name, "SAX function hasExternalSubset")) {
329: ctxt->sax->hasExternalSubset =
330: *((hasExternalSubsetSAXFunc *) value);
331: } else if (!strcmp(name, "SAX function resolveEntity")) {
332: ctxt->sax->resolveEntity = *((resolveEntitySAXFunc *) value);
333: } else if (!strcmp(name, "SAX function getEntity")) {
334: ctxt->sax->getEntity = *((getEntitySAXFunc *) value);
335: } else if (!strcmp(name, "SAX function entityDecl")) {
336: ctxt->sax->entityDecl = *((entityDeclSAXFunc *) value);
337: } else if (!strcmp(name, "SAX function notationDecl")) {
338: ctxt->sax->notationDecl = *((notationDeclSAXFunc *) value);
339: } else if (!strcmp(name, "SAX function attributeDecl")) {
340: ctxt->sax->attributeDecl = *((attributeDeclSAXFunc *) value);
341: } else if (!strcmp(name, "SAX function elementDecl")) {
342: ctxt->sax->elementDecl = *((elementDeclSAXFunc *) value);
343: } else if (!strcmp(name, "SAX function unparsedEntityDecl")) {
344: ctxt->sax->unparsedEntityDecl =
345: *((unparsedEntityDeclSAXFunc *) value);
346: } else if (!strcmp(name, "SAX function setDocumentLocator")) {
347: ctxt->sax->setDocumentLocator =
348: *((setDocumentLocatorSAXFunc *) value);
349: } else if (!strcmp(name, "SAX function startDocument")) {
350: ctxt->sax->startDocument = *((startDocumentSAXFunc *) value);
351: } else if (!strcmp(name, "SAX function endDocument")) {
352: ctxt->sax->endDocument = *((endDocumentSAXFunc *) value);
353: } else if (!strcmp(name, "SAX function startElement")) {
354: ctxt->sax->startElement = *((startElementSAXFunc *) value);
355: } else if (!strcmp(name, "SAX function endElement")) {
356: ctxt->sax->endElement = *((endElementSAXFunc *) value);
357: } else if (!strcmp(name, "SAX function reference")) {
358: ctxt->sax->reference = *((referenceSAXFunc *) value);
359: } else if (!strcmp(name, "SAX function characters")) {
360: ctxt->sax->characters = *((charactersSAXFunc *) value);
361: } else if (!strcmp(name, "SAX function ignorableWhitespace")) {
362: ctxt->sax->ignorableWhitespace =
363: *((ignorableWhitespaceSAXFunc *) value);
364: } else if (!strcmp(name, "SAX function processingInstruction")) {
365: ctxt->sax->processingInstruction =
366: *((processingInstructionSAXFunc *) value);
367: } else if (!strcmp(name, "SAX function comment")) {
368: ctxt->sax->comment = *((commentSAXFunc *) value);
369: } else if (!strcmp(name, "SAX function warning")) {
370: ctxt->sax->warning = *((warningSAXFunc *) value);
371: } else if (!strcmp(name, "SAX function error")) {
372: ctxt->sax->error = *((errorSAXFunc *) value);
373: } else if (!strcmp(name, "SAX function fatalError")) {
374: ctxt->sax->fatalError = *((fatalErrorSAXFunc *) value);
375: } else if (!strcmp(name, "SAX function getParameterEntity")) {
376: ctxt->sax->getParameterEntity =
377: *((getParameterEntitySAXFunc *) value);
378: } else if (!strcmp(name, "SAX function cdataBlock")) {
379: ctxt->sax->cdataBlock = *((cdataBlockSAXFunc *) value);
380: } else if (!strcmp(name, "SAX function externalSubset")) {
381: ctxt->sax->externalSubset = *((externalSubsetSAXFunc *) value);
382: } else {
383: return (-1);
384: }
385: return (0);
386: }
387:
388: /**
389: * xmlDecodeEntities:
390: * @ctxt: the parser context
391: * @len: the len to decode (in bytes !), -1 for no size limit
392: * @what: combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF
393: * @end: an end marker xmlChar, 0 if none
394: * @end2: an end marker xmlChar, 0 if none
395: * @end3: an end marker xmlChar, 0 if none
1.1.1.2 ! misho 396: *
1.1 misho 397: * This function is deprecated, we now always process entities content
398: * through xmlStringDecodeEntities
399: *
400: * TODO: remove it in next major release.
401: *
402: * [67] Reference ::= EntityRef | CharRef
403: *
404: * [69] PEReference ::= '%' Name ';'
405: *
406: * Returns A newly allocated string with the substitution done. The caller
407: * must deallocate it !
408: */
409: xmlChar *
410: xmlDecodeEntities(xmlParserCtxtPtr ctxt ATTRIBUTE_UNUSED,
411: int len ATTRIBUTE_UNUSED, int what ATTRIBUTE_UNUSED,
412: xmlChar end ATTRIBUTE_UNUSED,
413: xmlChar end2 ATTRIBUTE_UNUSED,
414: xmlChar end3 ATTRIBUTE_UNUSED)
415: {
416: static int deprecated = 0;
417:
418: if (!deprecated) {
419: xmlGenericError(xmlGenericErrorContext,
420: "xmlDecodeEntities() deprecated function reached\n");
421: deprecated = 1;
422: }
423: return (NULL);
424: }
425:
426: /**
427: * xmlNamespaceParseNCName:
428: * @ctxt: an XML parser context
429: *
430: * parse an XML namespace name.
431: *
432: * TODO: this seems not in use anymore, the namespace handling is done on
433: * top of the SAX interfaces, i.e. not on raw input.
434: *
435: * [NS 3] NCName ::= (Letter | '_') (NCNameChar)*
436: *
437: * [NS 4] NCNameChar ::= Letter | Digit | '.' | '-' | '_' |
438: * CombiningChar | Extender
439: *
440: * Returns the namespace name or NULL
441: */
442:
443: xmlChar *
444: xmlNamespaceParseNCName(xmlParserCtxtPtr ctxt ATTRIBUTE_UNUSED)
445: {
446: static int deprecated = 0;
447:
448: if (!deprecated) {
449: xmlGenericError(xmlGenericErrorContext,
450: "xmlNamespaceParseNCName() deprecated function reached\n");
451: deprecated = 1;
452: }
453: return (NULL);
454: }
455:
456: /**
457: * xmlNamespaceParseQName:
458: * @ctxt: an XML parser context
1.1.1.2 ! misho 459: * @prefix: a xmlChar **
1.1 misho 460: *
461: * TODO: this seems not in use anymore, the namespace handling is done on
462: * top of the SAX interfaces, i.e. not on raw input.
463: *
464: * parse an XML qualified name
465: *
466: * [NS 5] QName ::= (Prefix ':')? LocalPart
467: *
468: * [NS 6] Prefix ::= NCName
469: *
470: * [NS 7] LocalPart ::= NCName
471: *
472: * Returns the local part, and prefix is updated
473: * to get the Prefix if any.
474: */
475:
476: xmlChar *
477: xmlNamespaceParseQName(xmlParserCtxtPtr ctxt ATTRIBUTE_UNUSED,
478: xmlChar ** prefix ATTRIBUTE_UNUSED)
479: {
480:
481: static int deprecated = 0;
482:
483: if (!deprecated) {
484: xmlGenericError(xmlGenericErrorContext,
485: "xmlNamespaceParseQName() deprecated function reached\n");
486: deprecated = 1;
487: }
488: return (NULL);
489: }
490:
491: /**
492: * xmlNamespaceParseNSDef:
493: * @ctxt: an XML parser context
494: *
495: * parse a namespace prefix declaration
496: *
497: * TODO: this seems not in use anymore, the namespace handling is done on
498: * top of the SAX interfaces, i.e. not on raw input.
499: *
500: * [NS 1] NSDef ::= PrefixDef Eq SystemLiteral
501: *
502: * [NS 2] PrefixDef ::= 'xmlns' (':' NCName)?
503: *
504: * Returns the namespace name
505: */
506:
507: xmlChar *
508: xmlNamespaceParseNSDef(xmlParserCtxtPtr ctxt ATTRIBUTE_UNUSED)
509: {
510: static int deprecated = 0;
511:
512: if (!deprecated) {
513: xmlGenericError(xmlGenericErrorContext,
514: "xmlNamespaceParseNSDef() deprecated function reached\n");
515: deprecated = 1;
516: }
517: return (NULL);
518: }
519:
520: /**
521: * xmlParseQuotedString:
522: * @ctxt: an XML parser context
523: *
524: * Parse and return a string between quotes or doublequotes
525: *
526: * TODO: Deprecated, to be removed at next drop of binary compatibility
527: *
528: * Returns the string parser or NULL.
529: */
530: xmlChar *
531: xmlParseQuotedString(xmlParserCtxtPtr ctxt ATTRIBUTE_UNUSED)
532: {
533: static int deprecated = 0;
534:
535: if (!deprecated) {
536: xmlGenericError(xmlGenericErrorContext,
537: "xmlParseQuotedString() deprecated function reached\n");
538: deprecated = 1;
539: }
540: return (NULL);
541: }
542:
543: /**
544: * xmlParseNamespace:
545: * @ctxt: an XML parser context
546: *
547: * xmlParseNamespace: parse specific PI '<?namespace ...' constructs.
548: *
549: * This is what the older xml-name Working Draft specified, a bunch of
550: * other stuff may still rely on it, so support is still here as
551: * if it was declared on the root of the Tree:-(
552: *
553: * TODO: remove from library
554: *
555: * To be removed at next drop of binary compatibility
556: */
557:
558: void
559: xmlParseNamespace(xmlParserCtxtPtr ctxt ATTRIBUTE_UNUSED)
560: {
561: static int deprecated = 0;
562:
563: if (!deprecated) {
564: xmlGenericError(xmlGenericErrorContext,
565: "xmlParseNamespace() deprecated function reached\n");
566: deprecated = 1;
567: }
568: }
569:
570: /**
571: * xmlScanName:
572: * @ctxt: an XML parser context
573: *
574: * Trickery: parse an XML name but without consuming the input flow
575: * Needed for rollback cases. Used only when parsing entities references.
576: *
577: * TODO: seems deprecated now, only used in the default part of
578: * xmlParserHandleReference
579: *
580: * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
581: * CombiningChar | Extender
582: *
583: * [5] Name ::= (Letter | '_' | ':') (NameChar)*
584: *
585: * [6] Names ::= Name (S Name)*
586: *
587: * Returns the Name parsed or NULL
588: */
589:
590: xmlChar *
591: xmlScanName(xmlParserCtxtPtr ctxt ATTRIBUTE_UNUSED)
592: {
593: static int deprecated = 0;
594:
595: if (!deprecated) {
596: xmlGenericError(xmlGenericErrorContext,
597: "xmlScanName() deprecated function reached\n");
598: deprecated = 1;
599: }
600: return (NULL);
601: }
602:
603: /**
604: * xmlParserHandleReference:
605: * @ctxt: the parser context
1.1.1.2 ! misho 606: *
1.1 misho 607: * TODO: Remove, now deprecated ... the test is done directly in the
608: * content parsing
609: * routines.
610: *
611: * [67] Reference ::= EntityRef | CharRef
612: *
613: * [68] EntityRef ::= '&' Name ';'
614: *
615: * [ WFC: Entity Declared ]
616: * the Name given in the entity reference must match that in an entity
617: * declaration, except that well-formed documents need not declare any
1.1.1.2 ! misho 618: * of the following entities: amp, lt, gt, apos, quot.
1.1 misho 619: *
620: * [ WFC: Parsed Entity ]
621: * An entity reference must not contain the name of an unparsed entity
622: *
623: * [66] CharRef ::= '&#' [0-9]+ ';' |
624: * '&#x' [0-9a-fA-F]+ ';'
625: *
626: * A PEReference may have been detected in the current input stream
1.1.1.2 ! misho 627: * the handling is done accordingly to
1.1 misho 628: * http://www.w3.org/TR/REC-xml#entproc
629: */
630: void
631: xmlParserHandleReference(xmlParserCtxtPtr ctxt ATTRIBUTE_UNUSED)
632: {
633: static int deprecated = 0;
634:
635: if (!deprecated) {
636: xmlGenericError(xmlGenericErrorContext,
637: "xmlParserHandleReference() deprecated function reached\n");
638: deprecated = 1;
639: }
640:
641: return;
642: }
643:
644: /**
645: * xmlHandleEntity:
646: * @ctxt: an XML parser context
647: * @entity: an XML entity pointer.
648: *
649: * Default handling of defined entities, when should we define a new input
650: * stream ? When do we just handle that as a set of chars ?
651: *
652: * OBSOLETE: to be removed at some point.
653: */
654:
655: void
656: xmlHandleEntity(xmlParserCtxtPtr ctxt ATTRIBUTE_UNUSED,
657: xmlEntityPtr entity ATTRIBUTE_UNUSED)
658: {
659: static int deprecated = 0;
660:
661: if (!deprecated) {
662: xmlGenericError(xmlGenericErrorContext,
663: "xmlHandleEntity() deprecated function reached\n");
664: deprecated = 1;
665: }
666: }
667:
668: /**
669: * xmlNewGlobalNs:
670: * @doc: the document carrying the namespace
671: * @href: the URI associated
672: * @prefix: the prefix for the namespace
673: *
674: * Creation of a Namespace, the old way using PI and without scoping
675: * DEPRECATED !!!
676: * Returns NULL this functionality had been removed
677: */
678: xmlNsPtr
679: xmlNewGlobalNs(xmlDocPtr doc ATTRIBUTE_UNUSED,
680: const xmlChar * href ATTRIBUTE_UNUSED,
681: const xmlChar * prefix ATTRIBUTE_UNUSED)
682: {
683: static int deprecated = 0;
684:
685: if (!deprecated) {
686: xmlGenericError(xmlGenericErrorContext,
687: "xmlNewGlobalNs() deprecated function reached\n");
688: deprecated = 1;
689: }
690: return (NULL);
691: }
692:
693: /**
694: * xmlUpgradeOldNs:
695: * @doc: a document pointer
1.1.1.2 ! misho 696: *
1.1 misho 697: * Upgrade old style Namespaces (PI) and move them to the root of the document.
698: * DEPRECATED
699: */
700: void
701: xmlUpgradeOldNs(xmlDocPtr doc ATTRIBUTE_UNUSED)
702: {
703: static int deprecated = 0;
704:
705: if (!deprecated) {
706: xmlGenericError(xmlGenericErrorContext,
707: "xmlUpgradeOldNs() deprecated function reached\n");
708: deprecated = 1;
709: }
710: }
711:
712: /**
713: * xmlEncodeEntities:
714: * @doc: the document containing the string
715: * @input: A string to convert to XML.
716: *
717: * TODO: remove xmlEncodeEntities, once we are not afraid of breaking binary
718: * compatibility
719: *
720: * People must migrate their code to xmlEncodeEntitiesReentrant !
721: * This routine will issue a warning when encountered.
1.1.1.2 ! misho 722: *
1.1 misho 723: * Returns NULL
724: */
725: const xmlChar *
726: xmlEncodeEntities(xmlDocPtr doc ATTRIBUTE_UNUSED,
727: const xmlChar * input ATTRIBUTE_UNUSED)
728: {
729: static int warning = 1;
730:
731: if (warning) {
732: xmlGenericError(xmlGenericErrorContext,
733: "Deprecated API xmlEncodeEntities() used\n");
734: xmlGenericError(xmlGenericErrorContext,
735: " change code to use xmlEncodeEntitiesReentrant()\n");
736: warning = 0;
737: }
738: return (NULL);
739: }
740:
741: /************************************************************************
742: * *
1.1.1.2 ! misho 743: * Old set of SAXv1 functions *
1.1 misho 744: * *
745: ************************************************************************/
746: static int deprecated_v1_msg = 0;
747:
748: #define DEPRECATED(n) \
749: if (deprecated_v1_msg == 0) \
750: xmlGenericError(xmlGenericErrorContext, \
751: "Use of deprecated SAXv1 function %s\n", n); \
752: deprecated_v1_msg++;
753:
754: /**
755: * getPublicId:
756: * @ctx: the user data (XML parser context)
757: *
758: * Provides the public ID e.g. "-//SGMLSOURCE//DTD DEMO//EN"
759: * DEPRECATED: use xmlSAX2GetPublicId()
760: *
761: * Returns a xmlChar *
762: */
763: const xmlChar *
764: getPublicId(void *ctx)
765: {
766: DEPRECATED("getPublicId")
767: return (xmlSAX2GetPublicId(ctx));
768: }
769:
770: /**
771: * getSystemId:
772: * @ctx: the user data (XML parser context)
773: *
774: * Provides the system ID, basically URL or filename e.g.
775: * http://www.sgmlsource.com/dtds/memo.dtd
776: * DEPRECATED: use xmlSAX2GetSystemId()
777: *
778: * Returns a xmlChar *
779: */
780: const xmlChar *
781: getSystemId(void *ctx)
782: {
783: DEPRECATED("getSystemId")
784: return (xmlSAX2GetSystemId(ctx));
785: }
786:
787: /**
788: * getLineNumber:
789: * @ctx: the user data (XML parser context)
790: *
791: * Provide the line number of the current parsing point.
792: * DEPRECATED: use xmlSAX2GetLineNumber()
793: *
794: * Returns an int
795: */
796: int
797: getLineNumber(void *ctx)
798: {
799: DEPRECATED("getLineNumber")
800: return (xmlSAX2GetLineNumber(ctx));
801: }
802:
803: /**
804: * getColumnNumber:
805: * @ctx: the user data (XML parser context)
806: *
807: * Provide the column number of the current parsing point.
808: * DEPRECATED: use xmlSAX2GetColumnNumber()
809: *
810: * Returns an int
811: */
812: int
813: getColumnNumber(void *ctx)
814: {
815: DEPRECATED("getColumnNumber")
816: return (xmlSAX2GetColumnNumber(ctx));
817: }
818:
819: /**
820: * isStandalone:
821: * @ctx: the user data (XML parser context)
822: *
823: * Is this document tagged standalone ?
824: * DEPRECATED: use xmlSAX2IsStandalone()
825: *
826: * Returns 1 if true
827: */
828: int
829: isStandalone(void *ctx)
830: {
831: DEPRECATED("isStandalone")
832: return (xmlSAX2IsStandalone(ctx));
833: }
834:
835: /**
836: * hasInternalSubset:
837: * @ctx: the user data (XML parser context)
838: *
839: * Does this document has an internal subset
840: * DEPRECATED: use xmlSAX2HasInternalSubset()
841: *
842: * Returns 1 if true
843: */
844: int
845: hasInternalSubset(void *ctx)
846: {
847: DEPRECATED("hasInternalSubset")
848: return (xmlSAX2HasInternalSubset(ctx));
849: }
850:
851: /**
852: * hasExternalSubset:
853: * @ctx: the user data (XML parser context)
854: *
855: * Does this document has an external subset
856: * DEPRECATED: use xmlSAX2HasExternalSubset()
857: *
858: * Returns 1 if true
859: */
860: int
861: hasExternalSubset(void *ctx)
862: {
863: DEPRECATED("hasExternalSubset")
864: return (xmlSAX2HasExternalSubset(ctx));
865: }
866:
867: /**
868: * internalSubset:
869: * @ctx: the user data (XML parser context)
870: * @name: the root element name
871: * @ExternalID: the external ID
872: * @SystemID: the SYSTEM ID (e.g. filename or URL)
873: *
874: * Callback on internal subset declaration.
875: * DEPRECATED: use xmlSAX2InternalSubset()
876: */
877: void
878: internalSubset(void *ctx, const xmlChar * name,
879: const xmlChar * ExternalID, const xmlChar * SystemID)
880: {
881: DEPRECATED("internalSubset")
882: xmlSAX2InternalSubset(ctx, name, ExternalID, SystemID);
883: }
884:
885: /**
886: * externalSubset:
887: * @ctx: the user data (XML parser context)
888: * @name: the root element name
889: * @ExternalID: the external ID
890: * @SystemID: the SYSTEM ID (e.g. filename or URL)
891: *
892: * Callback on external subset declaration.
893: * DEPRECATED: use xmlSAX2ExternalSubset()
894: */
895: void
896: externalSubset(void *ctx, const xmlChar * name,
897: const xmlChar * ExternalID, const xmlChar * SystemID)
898: {
899: DEPRECATED("externalSubset")
900: xmlSAX2ExternalSubset(ctx, name, ExternalID, SystemID);
901: }
902:
903: /**
904: * resolveEntity:
905: * @ctx: the user data (XML parser context)
906: * @publicId: The public ID of the entity
907: * @systemId: The system ID of the entity
908: *
909: * The entity loader, to control the loading of external entities,
910: * the application can either:
911: * - override this resolveEntity() callback in the SAX block
912: * - or better use the xmlSetExternalEntityLoader() function to
913: * set up it's own entity resolution routine
914: * DEPRECATED: use xmlSAX2ResolveEntity()
915: *
916: * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour.
917: */
918: xmlParserInputPtr
919: resolveEntity(void *ctx, const xmlChar * publicId,
920: const xmlChar * systemId)
921: {
922: DEPRECATED("resolveEntity")
923: return (xmlSAX2ResolveEntity(ctx, publicId, systemId));
924: }
925:
926: /**
927: * getEntity:
928: * @ctx: the user data (XML parser context)
929: * @name: The entity name
930: *
931: * Get an entity by name
932: * DEPRECATED: use xmlSAX2GetEntity()
933: *
934: * Returns the xmlEntityPtr if found.
935: */
936: xmlEntityPtr
937: getEntity(void *ctx, const xmlChar * name)
938: {
939: DEPRECATED("getEntity")
940: return (xmlSAX2GetEntity(ctx, name));
941: }
942:
943: /**
944: * getParameterEntity:
945: * @ctx: the user data (XML parser context)
946: * @name: The entity name
947: *
948: * Get a parameter entity by name
949: * DEPRECATED: use xmlSAX2GetParameterEntity()
950: *
951: * Returns the xmlEntityPtr if found.
952: */
953: xmlEntityPtr
954: getParameterEntity(void *ctx, const xmlChar * name)
955: {
956: DEPRECATED("getParameterEntity")
957: return (xmlSAX2GetParameterEntity(ctx, name));
958: }
959:
960:
961: /**
962: * entityDecl:
963: * @ctx: the user data (XML parser context)
1.1.1.2 ! misho 964: * @name: the entity name
! 965: * @type: the entity type
1.1 misho 966: * @publicId: The public ID of the entity
967: * @systemId: The system ID of the entity
968: * @content: the entity value (without processing).
969: *
970: * An entity definition has been parsed
971: * DEPRECATED: use xmlSAX2EntityDecl()
972: */
973: void
974: entityDecl(void *ctx, const xmlChar * name, int type,
975: const xmlChar * publicId, const xmlChar * systemId,
976: xmlChar * content)
977: {
978: DEPRECATED("entityDecl")
979: xmlSAX2EntityDecl(ctx, name, type, publicId, systemId, content);
980: }
981:
982: /**
983: * attributeDecl:
984: * @ctx: the user data (XML parser context)
985: * @elem: the name of the element
1.1.1.2 ! misho 986: * @fullname: the attribute name
! 987: * @type: the attribute type
1.1 misho 988: * @def: the type of default value
989: * @defaultValue: the attribute default value
990: * @tree: the tree of enumerated value set
991: *
992: * An attribute definition has been parsed
993: * DEPRECATED: use xmlSAX2AttributeDecl()
994: */
995: void
996: attributeDecl(void *ctx, const xmlChar * elem, const xmlChar * fullname,
997: int type, int def, const xmlChar * defaultValue,
998: xmlEnumerationPtr tree)
999: {
1000: DEPRECATED("attributeDecl")
1001: xmlSAX2AttributeDecl(ctx, elem, fullname, type, def, defaultValue,
1002: tree);
1003: }
1004:
1005: /**
1006: * elementDecl:
1007: * @ctx: the user data (XML parser context)
1.1.1.2 ! misho 1008: * @name: the element name
! 1009: * @type: the element type
1.1 misho 1010: * @content: the element value tree
1011: *
1012: * An element definition has been parsed
1013: * DEPRECATED: use xmlSAX2ElementDecl()
1014: */
1015: void
1016: elementDecl(void *ctx, const xmlChar * name, int type,
1017: xmlElementContentPtr content)
1018: {
1019: DEPRECATED("elementDecl")
1020: xmlSAX2ElementDecl(ctx, name, type, content);
1021: }
1022:
1023: /**
1024: * notationDecl:
1025: * @ctx: the user data (XML parser context)
1026: * @name: The name of the notation
1027: * @publicId: The public ID of the entity
1028: * @systemId: The system ID of the entity
1029: *
1030: * What to do when a notation declaration has been parsed.
1031: * DEPRECATED: use xmlSAX2NotationDecl()
1032: */
1033: void
1034: notationDecl(void *ctx, const xmlChar * name,
1035: const xmlChar * publicId, const xmlChar * systemId)
1036: {
1037: DEPRECATED("notationDecl")
1038: xmlSAX2NotationDecl(ctx, name, publicId, systemId);
1039: }
1040:
1041: /**
1042: * unparsedEntityDecl:
1043: * @ctx: the user data (XML parser context)
1044: * @name: The name of the entity
1045: * @publicId: The public ID of the entity
1046: * @systemId: The system ID of the entity
1047: * @notationName: the name of the notation
1048: *
1049: * What to do when an unparsed entity declaration is parsed
1050: * DEPRECATED: use xmlSAX2UnparsedEntityDecl()
1051: */
1052: void
1053: unparsedEntityDecl(void *ctx, const xmlChar * name,
1054: const xmlChar * publicId, const xmlChar * systemId,
1055: const xmlChar * notationName)
1056: {
1057: DEPRECATED("unparsedEntityDecl")
1058: xmlSAX2UnparsedEntityDecl(ctx, name, publicId, systemId,
1059: notationName);
1060: }
1061:
1062: /**
1063: * setDocumentLocator:
1064: * @ctx: the user data (XML parser context)
1065: * @loc: A SAX Locator
1066: *
1067: * Receive the document locator at startup, actually xmlDefaultSAXLocator
1068: * Everything is available on the context, so this is useless in our case.
1069: * DEPRECATED
1070: */
1071: void
1072: setDocumentLocator(void *ctx ATTRIBUTE_UNUSED,
1073: xmlSAXLocatorPtr loc ATTRIBUTE_UNUSED)
1074: {
1075: DEPRECATED("setDocumentLocator")
1076: }
1077:
1078: /**
1079: * startDocument:
1080: * @ctx: the user data (XML parser context)
1081: *
1082: * called when the document start being processed.
1083: * DEPRECATED: use xmlSAX2StartDocument()
1084: */
1085: void
1086: startDocument(void *ctx)
1087: {
1088: /* don't be too painful for glade users */
1089: /* DEPRECATED("startDocument") */
1090: xmlSAX2StartDocument(ctx);
1091: }
1092:
1093: /**
1094: * endDocument:
1095: * @ctx: the user data (XML parser context)
1096: *
1097: * called when the document end has been detected.
1098: * DEPRECATED: use xmlSAX2EndDocument()
1099: */
1100: void
1101: endDocument(void *ctx)
1102: {
1103: DEPRECATED("endDocument")
1104: xmlSAX2EndDocument(ctx);
1105: }
1106:
1107: /**
1108: * attribute:
1109: * @ctx: the user data (XML parser context)
1110: * @fullname: The attribute name, including namespace prefix
1111: * @value: The attribute value
1112: *
1113: * Handle an attribute that has been read by the parser.
1114: * The default handling is to convert the attribute into an
1115: * DOM subtree and past it in a new xmlAttr element added to
1116: * the element.
1117: * DEPRECATED: use xmlSAX2Attribute()
1118: */
1119: void
1120: attribute(void *ctx ATTRIBUTE_UNUSED,
1121: const xmlChar * fullname ATTRIBUTE_UNUSED,
1122: const xmlChar * value ATTRIBUTE_UNUSED)
1123: {
1124: DEPRECATED("attribute")
1125: }
1126:
1127: /**
1128: * startElement:
1129: * @ctx: the user data (XML parser context)
1130: * @fullname: The element name, including namespace prefix
1131: * @atts: An array of name/value attributes pairs, NULL terminated
1132: *
1133: * called when an opening tag has been processed.
1134: * DEPRECATED: use xmlSAX2StartElement()
1135: */
1136: void
1137: startElement(void *ctx, const xmlChar * fullname, const xmlChar ** atts)
1138: {
1139: xmlSAX2StartElement(ctx, fullname, atts);
1140: }
1141:
1142: /**
1143: * endElement:
1144: * @ctx: the user data (XML parser context)
1145: * @name: The element name
1146: *
1147: * called when the end of an element has been detected.
1148: * DEPRECATED: use xmlSAX2EndElement()
1149: */
1150: void
1151: endElement(void *ctx, const xmlChar * name ATTRIBUTE_UNUSED)
1152: {
1153: DEPRECATED("endElement")
1154: xmlSAX2EndElement(ctx, name);
1155: }
1156:
1157: /**
1158: * reference:
1159: * @ctx: the user data (XML parser context)
1160: * @name: The entity name
1161: *
1.1.1.2 ! misho 1162: * called when an entity reference is detected.
1.1 misho 1163: * DEPRECATED: use xmlSAX2Reference()
1164: */
1165: void
1166: reference(void *ctx, const xmlChar * name)
1167: {
1168: DEPRECATED("reference")
1169: xmlSAX2Reference(ctx, name);
1170: }
1171:
1172: /**
1173: * characters:
1174: * @ctx: the user data (XML parser context)
1175: * @ch: a xmlChar string
1176: * @len: the number of xmlChar
1177: *
1178: * receiving some chars from the parser.
1179: * DEPRECATED: use xmlSAX2Characters()
1180: */
1181: void
1182: characters(void *ctx, const xmlChar * ch, int len)
1183: {
1184: DEPRECATED("characters")
1185: xmlSAX2Characters(ctx, ch, len);
1186: }
1187:
1188: /**
1189: * ignorableWhitespace:
1190: * @ctx: the user data (XML parser context)
1191: * @ch: a xmlChar string
1192: * @len: the number of xmlChar
1193: *
1194: * receiving some ignorable whitespaces from the parser.
1195: * UNUSED: by default the DOM building will use characters
1196: * DEPRECATED: use xmlSAX2IgnorableWhitespace()
1197: */
1198: void
1199: ignorableWhitespace(void *ctx ATTRIBUTE_UNUSED,
1200: const xmlChar * ch ATTRIBUTE_UNUSED,
1201: int len ATTRIBUTE_UNUSED)
1202: {
1203: DEPRECATED("ignorableWhitespace")
1204: }
1205:
1206: /**
1207: * processingInstruction:
1208: * @ctx: the user data (XML parser context)
1209: * @target: the target name
1210: * @data: the PI data's
1211: *
1212: * A processing instruction has been parsed.
1213: * DEPRECATED: use xmlSAX2ProcessingInstruction()
1214: */
1215: void
1216: processingInstruction(void *ctx, const xmlChar * target,
1217: const xmlChar * data)
1218: {
1219: DEPRECATED("processingInstruction")
1220: xmlSAX2ProcessingInstruction(ctx, target, data);
1221: }
1222:
1223: /**
1224: * globalNamespace:
1225: * @ctx: the user data (XML parser context)
1226: * @href: the namespace associated URN
1227: * @prefix: the namespace prefix
1228: *
1229: * An old global namespace has been parsed.
1230: * DEPRECATED
1231: */
1232: void
1233: globalNamespace(void *ctx ATTRIBUTE_UNUSED,
1234: const xmlChar * href ATTRIBUTE_UNUSED,
1235: const xmlChar * prefix ATTRIBUTE_UNUSED)
1236: {
1237: DEPRECATED("globalNamespace")
1238: }
1239:
1240: /**
1241: * setNamespace:
1242: * @ctx: the user data (XML parser context)
1243: * @name: the namespace prefix
1244: *
1245: * Set the current element namespace.
1246: * DEPRECATED
1247: */
1248:
1249: void
1250: setNamespace(void *ctx ATTRIBUTE_UNUSED,
1251: const xmlChar * name ATTRIBUTE_UNUSED)
1252: {
1253: DEPRECATED("setNamespace")
1254: }
1255:
1256: /**
1257: * getNamespace:
1258: * @ctx: the user data (XML parser context)
1259: *
1260: * Get the current element namespace.
1261: * DEPRECATED
1262: *
1263: * Returns the xmlNsPtr or NULL if none
1264: */
1265:
1266: xmlNsPtr
1267: getNamespace(void *ctx ATTRIBUTE_UNUSED)
1268: {
1269: DEPRECATED("getNamespace")
1270: return (NULL);
1271: }
1272:
1273: /**
1274: * checkNamespace:
1275: * @ctx: the user data (XML parser context)
1276: * @namespace: the namespace to check against
1277: *
1278: * Check that the current element namespace is the same as the
1279: * one read upon parsing.
1280: * DEPRECATED
1281: *
1282: * Returns 1 if true 0 otherwise
1283: */
1284:
1285: int
1286: checkNamespace(void *ctx ATTRIBUTE_UNUSED,
1287: xmlChar * namespace ATTRIBUTE_UNUSED)
1288: {
1289: DEPRECATED("checkNamespace")
1290: return (0);
1291: }
1292:
1293: /**
1294: * namespaceDecl:
1295: * @ctx: the user data (XML parser context)
1296: * @href: the namespace associated URN
1297: * @prefix: the namespace prefix
1298: *
1299: * A namespace has been parsed.
1300: * DEPRECATED
1301: */
1302: void
1303: namespaceDecl(void *ctx ATTRIBUTE_UNUSED,
1304: const xmlChar * href ATTRIBUTE_UNUSED,
1305: const xmlChar * prefix ATTRIBUTE_UNUSED)
1306: {
1307: DEPRECATED("namespaceDecl")
1308: }
1309:
1310: /**
1311: * comment:
1312: * @ctx: the user data (XML parser context)
1313: * @value: the comment content
1314: *
1315: * A comment has been parsed.
1316: * DEPRECATED: use xmlSAX2Comment()
1317: */
1318: void
1319: comment(void *ctx, const xmlChar * value)
1320: {
1321: DEPRECATED("comment")
1322: xmlSAX2Comment(ctx, value);
1323: }
1324:
1325: /**
1326: * cdataBlock:
1327: * @ctx: the user data (XML parser context)
1328: * @value: The pcdata content
1329: * @len: the block length
1330: *
1331: * called when a pcdata block has been parsed
1332: * DEPRECATED: use xmlSAX2CDataBlock()
1333: */
1334: void
1335: cdataBlock(void *ctx, const xmlChar * value, int len)
1336: {
1337: DEPRECATED("cdataBlock")
1338: xmlSAX2CDataBlock(ctx, value, len);
1339: }
1340: #define bottom_legacy
1341: #include "elfgcchack.h"
1342: #endif /* LIBXML_LEGACY_ENABLED */
1343:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to legacy.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2