| OLD | NEW |
|---|
| (Empty) |
| 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 | |
| 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 #define bottom_legacy | |
| 1341 #include "elfgcchack.h" | |
| 1342 #endif /* LIBXML_LEGACY_ENABLED */ | |
| 1343 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2804483002:
Check in the libxml roll script. (Closed)
