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* const 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
396 *
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
459 * @prefix: a xmlChar **
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
606 *
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
618 * of the following entities: amp, lt, gt, apos, quot.
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
627 * the handling is done accordingly to
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
696 *
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.
722 *
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 * *
743 * Old set of SAXv1 functions *
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)
964 * @name: the entity name
965 * @type: the entity type
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
986 * @fullname: the attribute name
987 * @type: the attribute type
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)
1008 * @name: the element name
1009 * @type: the element type
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 *
1162 * called when an entity reference is detected.
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
1341 /*
1342 * nanoftp.h
1343 */
1344
1345 #ifndef LIBXML_FTP_ENABLED
1346
1347 #include <libxml/nanoftp.h>
1348
1349 /** DOC_DISABLE */
1350
1351 #ifdef _WIN32
1352 #include <winsock2.h>
1353 #else
1354 #define SOCKET int
1355 #endif
1356
1357 typedef void
1358 (*ftpListCallback)(void *userData, const char *filename, const char *attrib,
1359 const char *owner, const char *group, unsigned long size,
1360 int links, int year, const char *month, int day, int hour,
1361 int minute);
1362
1363 typedef void
1364 (*ftpDataCallback) (void *userData, const char *data, int len);
1365
1366 XMLPUBFUN void
1367 xmlNanoFTPInit(void);
1368
1369 void
1370 xmlNanoFTPInit(void) {
1371 }
1372
1373 XMLPUBFUN void
1374 xmlNanoFTPCleanup(void);
1375
1376 void
1377 xmlNanoFTPCleanup(void) {
1378 }
1379
1380 XMLPUBFUN void
1381 xmlNanoFTPProxy(const char *host, int port, const char *user,
1382 const char *passwd, int type);
1383
1384 void
1385 xmlNanoFTPProxy(const char *host ATTRIBUTE_UNUSED, int port ATTRIBUTE_UNUSED,
1386 const char *user ATTRIBUTE_UNUSED,
1387 const char *passwd ATTRIBUTE_UNUSED, int type ATTRIBUTE_UNUSED) {
1388 }
1389
1390 XMLPUBFUN int
1391 xmlNanoFTPUpdateURL(void *ctx, const char *URL);
1392
1393 int
1394 xmlNanoFTPUpdateURL(void *ctx ATTRIBUTE_UNUSED,
1395 const char *URL ATTRIBUTE_UNUSED) {
1396 return(-1);
1397 }
1398
1399 XMLPUBFUN void
1400 xmlNanoFTPScanProxy(const char *URL);
1401
1402 void
1403 xmlNanoFTPScanProxy(const char *URL ATTRIBUTE_UNUSED) {
1404 }
1405
1406 XMLPUBFUN void *
1407 xmlNanoFTPNewCtxt(const char *URL);
1408
1409 void*
1410 xmlNanoFTPNewCtxt(const char *URL ATTRIBUTE_UNUSED) {
1411 return(NULL);
1412 }
1413
1414 XMLPUBFUN void
1415 xmlNanoFTPFreeCtxt(void *ctx);
1416
1417 void
1418 xmlNanoFTPFreeCtxt(void * ctx ATTRIBUTE_UNUSED) {
1419 }
1420
1421 XMLPUBFUN int
1422 xmlNanoFTPGetResponse(void *ctx);
1423
1424 int
1425 xmlNanoFTPGetResponse(void *ctx ATTRIBUTE_UNUSED) {
1426 return(-1);
1427 }
1428
1429 XMLPUBFUN int
1430 xmlNanoFTPCheckResponse(void *ctx);
1431
1432 int
1433 xmlNanoFTPCheckResponse(void *ctx ATTRIBUTE_UNUSED) {
1434 return(-1);
1435 }
1436
1437 XMLPUBFUN int
1438 xmlNanoFTPQuit(void *ctx);
1439
1440 int
1441 xmlNanoFTPQuit(void *ctx ATTRIBUTE_UNUSED) {
1442 return(-1);
1443 }
1444
1445 XMLPUBFUN int
1446 xmlNanoFTPConnect(void *ctx);
1447
1448 int
1449 xmlNanoFTPConnect(void *ctx ATTRIBUTE_UNUSED) {
1450 return(-1);
1451 }
1452
1453 XMLPUBFUN void *
1454 xmlNanoFTPConnectTo(const char *server, int port);
1455
1456 void*
1457 xmlNanoFTPConnectTo(const char *server ATTRIBUTE_UNUSED,
1458 int port ATTRIBUTE_UNUSED) {
1459 return(NULL);
1460 }
1461
1462 XMLPUBFUN int
1463 xmlNanoFTPCwd(void *ctx, const char *directory);
1464
1465 int
1466 xmlNanoFTPCwd(void *ctx ATTRIBUTE_UNUSED,
1467 const char *directory ATTRIBUTE_UNUSED) {
1468 return(-1);
1469 }
1470
1471 XMLPUBFUN int
1472 xmlNanoFTPDele(void *ctx, const char *file);
1473
1474 int
1475 xmlNanoFTPDele(void *ctx ATTRIBUTE_UNUSED, const char *file ATTRIBUTE_UNUSED) {
1476 return(-1);
1477 }
1478
1479 XMLPUBFUN SOCKET
1480 xmlNanoFTPGetConnection(void *ctx);
1481
1482 SOCKET
1483 xmlNanoFTPGetConnection(void *ctx ATTRIBUTE_UNUSED) {
1484 return(-1);
1485 }
1486
1487 XMLPUBFUN int
1488 xmlNanoFTPCloseConnection(void *ctx);
1489
1490 int
1491 xmlNanoFTPCloseConnection(void *ctx ATTRIBUTE_UNUSED) {
1492 return(-1);
1493 }
1494
1495 XMLPUBFUN int
1496 xmlNanoFTPList(void *ctx, ftpListCallback callback, void *userData,
1497 const char *filename);
1498
1499 int
1500 xmlNanoFTPList(void *ctx ATTRIBUTE_UNUSED,
1501 ftpListCallback callback ATTRIBUTE_UNUSED,
1502 void *userData ATTRIBUTE_UNUSED,
1503 const char *filename ATTRIBUTE_UNUSED) {
1504 return(-1);
1505 }
1506
1507 XMLPUBFUN SOCKET
1508 xmlNanoFTPGetSocket(void *ctx, const char *filename);
1509
1510 SOCKET
1511 xmlNanoFTPGetSocket(void *ctx ATTRIBUTE_UNUSED,
1512 const char *filename ATTRIBUTE_UNUSED) {
1513 return(-1);
1514 }
1515
1516 XMLPUBFUN int
1517 xmlNanoFTPGet(void *ctx, ftpDataCallback callback, void *userData,
1518 const char *filename);
1519
1520 int
1521 xmlNanoFTPGet(void *ctx ATTRIBUTE_UNUSED,
1522 ftpDataCallback callback ATTRIBUTE_UNUSED,
1523 void *userData ATTRIBUTE_UNUSED,
1524 const char *filename ATTRIBUTE_UNUSED) {
1525 return(-1);
1526 }
1527
1528 XMLPUBFUN int
1529 xmlNanoFTPRead(void *ctx, void *dest, int len);
1530
1531 int
1532 xmlNanoFTPRead(void *ctx ATTRIBUTE_UNUSED, void *dest ATTRIBUTE_UNUSED,
1533 int len ATTRIBUTE_UNUSED) {
1534 return(-1);
1535 }
1536
1537 XMLPUBFUN void *
1538 xmlNanoFTPOpen(const char *URL);
1539
1540 void*
1541 xmlNanoFTPOpen(const char *URL ATTRIBUTE_UNUSED) {
1542 return(NULL);
1543 }
1544
1545 XMLPUBFUN int
1546 xmlNanoFTPClose(void *ctx);
1547
1548 int
1549 xmlNanoFTPClose(void *ctx ATTRIBUTE_UNUSED) {
1550 return(-1);
1551 }
1552
1553 XMLPUBFUN int
1554 xmlIOFTPMatch(const char *filename);
1555
1556 int
1557 xmlIOFTPMatch(const char *filename ATTRIBUTE_UNUSED) {
1558 return(0);
1559 }
1560
1561 XMLPUBFUN void *
1562 xmlIOFTPOpen(const char *filename);
1563
1564 void *
1565 xmlIOFTPOpen(const char *filename ATTRIBUTE_UNUSED) {
1566 return(NULL);
1567 }
1568
1569 XMLPUBFUN int
1570 xmlIOFTPRead(void *context, char *buffer, int len);
1571
1572 int
1573 xmlIOFTPRead(void *context ATTRIBUTE_UNUSED, char *buffer ATTRIBUTE_UNUSED,
1574 int len ATTRIBUTE_UNUSED) {
1575 return(-1);
1576 }
1577
1578 XMLPUBFUN int
1579 xmlIOFTPClose(void *context);
1580
1581 int
1582 xmlIOFTPClose(void *context ATTRIBUTE_UNUSED) {
1583 return(-1);
1584 }
1585
1586 /** DOC_ENABLE */
1587
1588 #endif /* #ifndef LIBXML_FTP_ENABLED */
1589
1590 /*
1591 * xpointer.h
1592 */
1593
1594 #ifndef LIBXML_XPTR_LOCS_ENABLED
1595
1596 #include <libxml/xpath.h>
1597 #include <libxml/xpathInternals.h>
1598 #include <libxml/xpointer.h>
1599
1600 /** DOC_DISABLE */
1601
1602 typedef struct _xmlLocationSet *xmlLocationSetPtr;
1603
1604 XMLPUBFUN xmlXPathObjectPtr
1605 xmlXPtrNewRange(xmlNodePtr start, int startindex,
1606 xmlNodePtr end, int endindex);
1607
1608 xmlXPathObjectPtr
1609 xmlXPtrNewRange(xmlNodePtr start ATTRIBUTE_UNUSED,
1610 int startindex ATTRIBUTE_UNUSED,
1611 xmlNodePtr end ATTRIBUTE_UNUSED,
1612 int endindex ATTRIBUTE_UNUSED) {
1613 return(NULL);
1614 }
1615
1616 XMLPUBFUN xmlXPathObjectPtr
1617 xmlXPtrNewRangePoints(xmlXPathObjectPtr start, xmlXPathObjectPtr end);
1618
1619 xmlXPathObjectPtr
1620 xmlXPtrNewRangePoints(xmlXPathObjectPtr start ATTRIBUTE_UNUSED,
1621 xmlXPathObjectPtr end ATTRIBUTE_UNUSED) {
1622 return(NULL);
1623 }
1624
1625 XMLPUBFUN xmlXPathObjectPtr
1626 xmlXPtrNewRangePointNode(xmlXPathObjectPtr start, xmlNodePtr end);
1627
1628 xmlXPathObjectPtr
1629 xmlXPtrNewRangePointNode(xmlXPathObjectPtr start ATTRIBUTE_UNUSED,
1630 xmlNodePtr end ATTRIBUTE_UNUSED) {
1631 return(NULL);
1632 }
1633
1634 XMLPUBFUN xmlXPathObjectPtr
1635 xmlXPtrNewRangeNodePoint(xmlNodePtr start, xmlXPathObjectPtr end);
1636
1637 xmlXPathObjectPtr
1638 xmlXPtrNewRangeNodePoint(xmlNodePtr start ATTRIBUTE_UNUSED,
1639 xmlXPathObjectPtr end ATTRIBUTE_UNUSED) {
1640 return(NULL);
1641 }
1642
1643 XMLPUBFUN xmlXPathObjectPtr
1644 xmlXPtrNewRangeNodes(xmlNodePtr start, xmlNodePtr end);
1645
1646 xmlXPathObjectPtr
1647 xmlXPtrNewRangeNodes(xmlNodePtr start ATTRIBUTE_UNUSED,
1648 xmlNodePtr end ATTRIBUTE_UNUSED) {
1649 return(NULL);
1650 }
1651
1652 XMLPUBFUN xmlXPathObjectPtr
1653 xmlXPtrNewCollapsedRange(xmlNodePtr start);
1654
1655 xmlXPathObjectPtr
1656 xmlXPtrNewCollapsedRange(xmlNodePtr start ATTRIBUTE_UNUSED) {
1657 return(NULL);
1658 }
1659
1660 XMLPUBFUN xmlXPathObjectPtr
1661 xmlXPtrNewRangeNodeObject(xmlNodePtr start, xmlXPathObjectPtr end);
1662
1663 xmlXPathObjectPtr
1664 xmlXPtrNewRangeNodeObject(xmlNodePtr start ATTRIBUTE_UNUSED,
1665 xmlXPathObjectPtr end ATTRIBUTE_UNUSED) {
1666 return(NULL);
1667 }
1668
1669 XMLPUBFUN xmlLocationSetPtr
1670 xmlXPtrLocationSetCreate(xmlXPathObjectPtr val);
1671
1672 xmlLocationSetPtr
1673 xmlXPtrLocationSetCreate(xmlXPathObjectPtr val ATTRIBUTE_UNUSED) {
1674 return(NULL);
1675 }
1676
1677 XMLPUBFUN void
1678 xmlXPtrLocationSetAdd(xmlLocationSetPtr cur, xmlXPathObjectPtr val);
1679
1680 void
1681 xmlXPtrLocationSetAdd(xmlLocationSetPtr cur ATTRIBUTE_UNUSED,
1682 xmlXPathObjectPtr val ATTRIBUTE_UNUSED) {
1683 }
1684
1685 XMLPUBFUN xmlLocationSetPtr
1686 xmlXPtrLocationSetMerge(xmlLocationSetPtr val1, xmlLocationSetPtr val2);
1687
1688 xmlLocationSetPtr
1689 xmlXPtrLocationSetMerge(xmlLocationSetPtr val1 ATTRIBUTE_UNUSED,
1690 xmlLocationSetPtr val2 ATTRIBUTE_UNUSED) {
1691 return(NULL);
1692 }
1693
1694 XMLPUBFUN void
1695 xmlXPtrLocationSetDel(xmlLocationSetPtr cur, xmlXPathObjectPtr val);
1696
1697 void
1698 xmlXPtrLocationSetDel(xmlLocationSetPtr cur ATTRIBUTE_UNUSED,
1699 xmlXPathObjectPtr val ATTRIBUTE_UNUSED) {
1700 }
1701
1702 XMLPUBFUN void
1703 xmlXPtrLocationSetRemove(xmlLocationSetPtr cur, int val);
1704
1705 void
1706 xmlXPtrLocationSetRemove(xmlLocationSetPtr cur ATTRIBUTE_UNUSED,
1707 int val ATTRIBUTE_UNUSED) {
1708 }
1709
1710 XMLPUBFUN void
1711 xmlXPtrFreeLocationSet(xmlLocationSetPtr obj);
1712
1713 void
1714 xmlXPtrFreeLocationSet(xmlLocationSetPtr obj ATTRIBUTE_UNUSED) {
1715 }
1716
1717 XMLPUBFUN xmlXPathObjectPtr
1718 xmlXPtrNewLocationSetNodes(xmlNodePtr start, xmlNodePtr end);
1719
1720 xmlXPathObjectPtr
1721 xmlXPtrNewLocationSetNodes(xmlNodePtr start ATTRIBUTE_UNUSED,
1722 xmlNodePtr end ATTRIBUTE_UNUSED) {
1723 return(NULL);
1724 }
1725
1726 XMLPUBFUN xmlXPathObjectPtr
1727 xmlXPtrNewLocationSetNodeSet(xmlNodeSetPtr set);
1728
1729 xmlXPathObjectPtr
1730 xmlXPtrNewLocationSetNodeSet(xmlNodeSetPtr set ATTRIBUTE_UNUSED) {
1731 return(NULL);
1732 }
1733
1734 XMLPUBFUN xmlXPathObjectPtr
1735 xmlXPtrWrapLocationSet(xmlLocationSetPtr val);
1736
1737 xmlXPathObjectPtr
1738 xmlXPtrWrapLocationSet(xmlLocationSetPtr val ATTRIBUTE_UNUSED) {
1739 return(NULL);
1740 }
1741
1742 XMLPUBFUN xmlNodePtr
1743 xmlXPtrBuildNodeList(xmlXPathObjectPtr obj);
1744
1745 xmlNodePtr
1746 xmlXPtrBuildNodeList(xmlXPathObjectPtr obj ATTRIBUTE_UNUSED) {
1747 return(NULL);
1748 }
1749
1750 XMLPUBFUN void
1751 xmlXPtrRangeToFunction(xmlXPathParserContextPtr ctxt, int nargs);
1752
1753 void
1754 xmlXPtrRangeToFunction(xmlXPathParserContextPtr ctxt,
1755 int nargs ATTRIBUTE_UNUSED) {
1756 XP_ERROR(XPATH_EXPR_ERROR);
1757 }
1758
1759 /** DOC_ENABLE */
1760
1761 #endif /* #ifndef LIBXML_XPTR_LOCS_ENABLED */
1762
1763 #endif /* LIBXML_LEGACY_ENABLED */
1764