ReactOS Development > Doxygen

00001 /*
00002  * legacy.c: set of deprecated routines, not to be used anymore but
00003  *           kept purely for ABI compatibility
00004  *
00005  * See Copyright for the status of this software.
00006  *
00007  * daniel@veillard.com
00008  */
00009 
00010 #define IN_LIBXML
00011 #include "libxml.h"
00012 
00013 #ifdef LIBXML_LEGACY_ENABLED
00014 #include <string.h>
00015 
00016 #include <libxml/tree.h>
00017 #include <libxml/entities.h>
00018 #include <libxml/SAX.h>
00019 #include <libxml/parserInternals.h>
00020 #include <libxml/HTMLparser.h>
00021 
00022 void xmlUpgradeOldNs(xmlDocPtr doc);
00023 
00024 /************************************************************************
00025  *                                  *
00026  *      Deprecated functions kept for compatibility     *
00027  *                                  *
00028  ************************************************************************/
00029 
00030 #ifdef LIBXML_HTML_ENABLED
00031 xmlChar *htmlDecodeEntities(htmlParserCtxtPtr ctxt, int len, xmlChar end,
00032                             xmlChar end2, xmlChar end3);
00033 
00049 xmlChar *
00050 htmlDecodeEntities(htmlParserCtxtPtr ctxt ATTRIBUTE_UNUSED,
00051                    int len ATTRIBUTE_UNUSED, xmlChar end ATTRIBUTE_UNUSED,
00052                    xmlChar end2 ATTRIBUTE_UNUSED,
00053                    xmlChar end3 ATTRIBUTE_UNUSED)
00054 {
00055     static int deprecated = 0;
00056 
00057     if (!deprecated) {
00058         xmlGenericError(xmlGenericErrorContext,
00059                         "htmlDecodeEntities() deprecated function reached\n");
00060         deprecated = 1;
00061     }
00062     return (NULL);
00063 }
00064 #endif
00065 
00072 void
00073 xmlInitializePredefinedEntities(void)
00074 {
00075 }
00076 
00083 void
00084 xmlCleanupPredefinedEntities(void)
00085 {
00086 }
00087 
00088 static const char *xmlFeaturesList[] = {
00089     "validate",
00090     "load subset",
00091     "keep blanks",
00092     "disable SAX",
00093     "fetch external entities",
00094     "substitute entities",
00095     "gather line info",
00096     "user data",
00097     "is html",
00098     "is standalone",
00099     "stop parser",
00100     "document",
00101     "is well formed",
00102     "is valid",
00103     "SAX block",
00104     "SAX function internalSubset",
00105     "SAX function isStandalone",
00106     "SAX function hasInternalSubset",
00107     "SAX function hasExternalSubset",
00108     "SAX function resolveEntity",
00109     "SAX function getEntity",
00110     "SAX function entityDecl",
00111     "SAX function notationDecl",
00112     "SAX function attributeDecl",
00113     "SAX function elementDecl",
00114     "SAX function unparsedEntityDecl",
00115     "SAX function setDocumentLocator",
00116     "SAX function startDocument",
00117     "SAX function endDocument",
00118     "SAX function startElement",
00119     "SAX function endElement",
00120     "SAX function reference",
00121     "SAX function characters",
00122     "SAX function ignorableWhitespace",
00123     "SAX function processingInstruction",
00124     "SAX function comment",
00125     "SAX function warning",
00126     "SAX function error",
00127     "SAX function fatalError",
00128     "SAX function getParameterEntity",
00129     "SAX function cdataBlock",
00130     "SAX function externalSubset",
00131 };
00132 
00144 int
00145 xmlGetFeaturesList(int *len, const char **result)
00146 {
00147     int ret, i;
00148 
00149     ret = sizeof(xmlFeaturesList) / sizeof(xmlFeaturesList[0]);
00150     if ((len == NULL) || (result == NULL))
00151         return (ret);
00152     if ((*len < 0) || (*len >= 1000))
00153         return (-1);
00154     if (*len > ret)
00155         *len = ret;
00156     for (i = 0; i < *len; i++)
00157         result[i] = xmlFeaturesList[i];
00158     return (ret);
00159 }
00160 
00171 int
00172 xmlGetFeature(xmlParserCtxtPtr ctxt, const char *name, void *result)
00173 {
00174     if ((ctxt == NULL) || (name == NULL) || (result == NULL))
00175         return (-1);
00176 
00177     if (!strcmp(name, "validate")) {
00178         *((int *) result) = ctxt->validate;
00179     } else if (!strcmp(name, "keep blanks")) {
00180         *((int *) result) = ctxt->keepBlanks;
00181     } else if (!strcmp(name, "disable SAX")) {
00182         *((int *) result) = ctxt->disableSAX;
00183     } else if (!strcmp(name, "fetch external entities")) {
00184         *((int *) result) = ctxt->loadsubset;
00185     } else if (!strcmp(name, "substitute entities")) {
00186         *((int *) result) = ctxt->replaceEntities;
00187     } else if (!strcmp(name, "gather line info")) {
00188         *((int *) result) = ctxt->record_info;
00189     } else if (!strcmp(name, "user data")) {
00190         *((void **) result) = ctxt->userData;
00191     } else if (!strcmp(name, "is html")) {
00192         *((int *) result) = ctxt->html;
00193     } else if (!strcmp(name, "is standalone")) {
00194         *((int *) result) = ctxt->standalone;
00195     } else if (!strcmp(name, "document")) {
00196         *((xmlDocPtr *) result) = ctxt->myDoc;
00197     } else if (!strcmp(name, "is well formed")) {
00198         *((int *) result) = ctxt->wellFormed;
00199     } else if (!strcmp(name, "is valid")) {
00200         *((int *) result) = ctxt->valid;
00201     } else if (!strcmp(name, "SAX block")) {
00202         *((xmlSAXHandlerPtr *) result) = ctxt->sax;
00203     } else if (!strcmp(name, "SAX function internalSubset")) {
00204         *((internalSubsetSAXFunc *) result) = ctxt->sax->internalSubset;
00205     } else if (!strcmp(name, "SAX function isStandalone")) {
00206         *((isStandaloneSAXFunc *) result) = ctxt->sax->isStandalone;
00207     } else if (!strcmp(name, "SAX function hasInternalSubset")) {
00208         *((hasInternalSubsetSAXFunc *) result) =
00209             ctxt->sax->hasInternalSubset;
00210     } else if (!strcmp(name, "SAX function hasExternalSubset")) {
00211         *((hasExternalSubsetSAXFunc *) result) =
00212             ctxt->sax->hasExternalSubset;
00213     } else if (!strcmp(name, "SAX function resolveEntity")) {
00214         *((resolveEntitySAXFunc *) result) = ctxt->sax->resolveEntity;
00215     } else if (!strcmp(name, "SAX function getEntity")) {
00216         *((getEntitySAXFunc *) result) = ctxt->sax->getEntity;
00217     } else if (!strcmp(name, "SAX function entityDecl")) {
00218         *((entityDeclSAXFunc *) result) = ctxt->sax->entityDecl;
00219     } else if (!strcmp(name, "SAX function notationDecl")) {
00220         *((notationDeclSAXFunc *) result) = ctxt->sax->notationDecl;
00221     } else if (!strcmp(name, "SAX function attributeDecl")) {
00222         *((attributeDeclSAXFunc *) result) = ctxt->sax->attributeDecl;
00223     } else if (!strcmp(name, "SAX function elementDecl")) {
00224         *((elementDeclSAXFunc *) result) = ctxt->sax->elementDecl;
00225     } else if (!strcmp(name, "SAX function unparsedEntityDecl")) {
00226         *((unparsedEntityDeclSAXFunc *) result) =
00227             ctxt->sax->unparsedEntityDecl;
00228     } else if (!strcmp(name, "SAX function setDocumentLocator")) {
00229         *((setDocumentLocatorSAXFunc *) result) =
00230             ctxt->sax->setDocumentLocator;
00231     } else if (!strcmp(name, "SAX function startDocument")) {
00232         *((startDocumentSAXFunc *) result) = ctxt->sax->startDocument;
00233     } else if (!strcmp(name, "SAX function endDocument")) {
00234         *((endDocumentSAXFunc *) result) = ctxt->sax->endDocument;
00235     } else if (!strcmp(name, "SAX function startElement")) {
00236         *((startElementSAXFunc *) result) = ctxt->sax->startElement;
00237     } else if (!strcmp(name, "SAX function endElement")) {
00238         *((endElementSAXFunc *) result) = ctxt->sax->endElement;
00239     } else if (!strcmp(name, "SAX function reference")) {
00240         *((referenceSAXFunc *) result) = ctxt->sax->reference;
00241     } else if (!strcmp(name, "SAX function characters")) {
00242         *((charactersSAXFunc *) result) = ctxt->sax->characters;
00243     } else if (!strcmp(name, "SAX function ignorableWhitespace")) {
00244         *((ignorableWhitespaceSAXFunc *) result) =
00245             ctxt->sax->ignorableWhitespace;
00246     } else if (!strcmp(name, "SAX function processingInstruction")) {
00247         *((processingInstructionSAXFunc *) result) =
00248             ctxt->sax->processingInstruction;
00249     } else if (!strcmp(name, "SAX function comment")) {
00250         *((commentSAXFunc *) result) = ctxt->sax->comment;
00251     } else if (!strcmp(name, "SAX function warning")) {
00252         *((warningSAXFunc *) result) = ctxt->sax->warning;
00253     } else if (!strcmp(name, "SAX function error")) {
00254         *((errorSAXFunc *) result) = ctxt->sax->error;
00255     } else if (!strcmp(name, "SAX function fatalError")) {
00256         *((fatalErrorSAXFunc *) result) = ctxt->sax->fatalError;
00257     } else if (!strcmp(name, "SAX function getParameterEntity")) {
00258         *((getParameterEntitySAXFunc *) result) =
00259             ctxt->sax->getParameterEntity;
00260     } else if (!strcmp(name, "SAX function cdataBlock")) {
00261         *((cdataBlockSAXFunc *) result) = ctxt->sax->cdataBlock;
00262     } else if (!strcmp(name, "SAX function externalSubset")) {
00263         *((externalSubsetSAXFunc *) result) = ctxt->sax->externalSubset;
00264     } else {
00265         return (-1);
00266     }
00267     return (0);
00268 }
00269 
00280 int
00281 xmlSetFeature(xmlParserCtxtPtr ctxt, const char *name, void *value)
00282 {
00283     if ((ctxt == NULL) || (name == NULL) || (value == NULL))
00284         return (-1);
00285 
00286     if (!strcmp(name, "validate")) {
00287         int newvalidate = *((int *) value);
00288 
00289         if ((!ctxt->validate) && (newvalidate != 0)) {
00290             if (ctxt->vctxt.warning == NULL)
00291                 ctxt->vctxt.warning = xmlParserValidityWarning;
00292             if (ctxt->vctxt.error == NULL)
00293                 ctxt->vctxt.error = xmlParserValidityError;
00294             ctxt->vctxt.nodeMax = 0;
00295         }
00296         ctxt->validate = newvalidate;
00297     } else if (!strcmp(name, "keep blanks")) {
00298         ctxt->keepBlanks = *((int *) value);
00299     } else if (!strcmp(name, "disable SAX")) {
00300         ctxt->disableSAX = *((int *) value);
00301     } else if (!strcmp(name, "fetch external entities")) {
00302         ctxt->loadsubset = *((int *) value);
00303     } else if (!strcmp(name, "substitute entities")) {
00304         ctxt->replaceEntities = *((int *) value);
00305     } else if (!strcmp(name, "gather line info")) {
00306         ctxt->record_info = *((int *) value);
00307     } else if (!strcmp(name, "user data")) {
00308         ctxt->userData = *((void **) value);
00309     } else if (!strcmp(name, "is html")) {
00310         ctxt->html = *((int *) value);
00311     } else if (!strcmp(name, "is standalone")) {
00312         ctxt->standalone = *((int *) value);
00313     } else if (!strcmp(name, "document")) {
00314         ctxt->myDoc = *((xmlDocPtr *) value);
00315     } else if (!strcmp(name, "is well formed")) {
00316         ctxt->wellFormed = *((int *) value);
00317     } else if (!strcmp(name, "is valid")) {
00318         ctxt->valid = *((int *) value);
00319     } else if (!strcmp(name, "SAX block")) {
00320         ctxt->sax = *((xmlSAXHandlerPtr *) value);
00321     } else if (!strcmp(name, "SAX function internalSubset")) {
00322         ctxt->sax->internalSubset = *((internalSubsetSAXFunc *) value);
00323     } else if (!strcmp(name, "SAX function isStandalone")) {
00324         ctxt->sax->isStandalone = *((isStandaloneSAXFunc *) value);
00325     } else if (!strcmp(name, "SAX function hasInternalSubset")) {
00326         ctxt->sax->hasInternalSubset =
00327             *((hasInternalSubsetSAXFunc *) value);
00328     } else if (!strcmp(name, "SAX function hasExternalSubset")) {
00329         ctxt->sax->hasExternalSubset =
00330             *((hasExternalSubsetSAXFunc *) value);
00331     } else if (!strcmp(name, "SAX function resolveEntity")) {
00332         ctxt->sax->resolveEntity = *((resolveEntitySAXFunc *) value);
00333     } else if (!strcmp(name, "SAX function getEntity")) {
00334         ctxt->sax->getEntity = *((getEntitySAXFunc *) value);
00335     } else if (!strcmp(name, "SAX function entityDecl")) {
00336         ctxt->sax->entityDecl = *((entityDeclSAXFunc *) value);
00337     } else if (!strcmp(name, "SAX function notationDecl")) {
00338         ctxt->sax->notationDecl = *((notationDeclSAXFunc *) value);
00339     } else if (!strcmp(name, "SAX function attributeDecl")) {
00340         ctxt->sax->attributeDecl = *((attributeDeclSAXFunc *) value);
00341     } else if (!strcmp(name, "SAX function elementDecl")) {
00342         ctxt->sax->elementDecl = *((elementDeclSAXFunc *) value);
00343     } else if (!strcmp(name, "SAX function unparsedEntityDecl")) {
00344         ctxt->sax->unparsedEntityDecl =
00345             *((unparsedEntityDeclSAXFunc *) value);
00346     } else if (!strcmp(name, "SAX function setDocumentLocator")) {
00347         ctxt->sax->setDocumentLocator =
00348             *((setDocumentLocatorSAXFunc *) value);
00349     } else if (!strcmp(name, "SAX function startDocument")) {
00350         ctxt->sax->startDocument = *((startDocumentSAXFunc *) value);
00351     } else if (!strcmp(name, "SAX function endDocument")) {
00352         ctxt->sax->endDocument = *((endDocumentSAXFunc *) value);
00353     } else if (!strcmp(name, "SAX function startElement")) {
00354         ctxt->sax->startElement = *((startElementSAXFunc *) value);
00355     } else if (!strcmp(name, "SAX function endElement")) {
00356         ctxt->sax->endElement = *((endElementSAXFunc *) value);
00357     } else if (!strcmp(name, "SAX function reference")) {
00358         ctxt->sax->reference = *((referenceSAXFunc *) value);
00359     } else if (!strcmp(name, "SAX function characters")) {
00360         ctxt->sax->characters = *((charactersSAXFunc *) value);
00361     } else if (!strcmp(name, "SAX function ignorableWhitespace")) {
00362         ctxt->sax->ignorableWhitespace =
00363             *((ignorableWhitespaceSAXFunc *) value);
00364     } else if (!strcmp(name, "SAX function processingInstruction")) {
00365         ctxt->sax->processingInstruction =
00366             *((processingInstructionSAXFunc *) value);
00367     } else if (!strcmp(name, "SAX function comment")) {
00368         ctxt->sax->comment = *((commentSAXFunc *) value);
00369     } else if (!strcmp(name, "SAX function warning")) {
00370         ctxt->sax->warning = *((warningSAXFunc *) value);
00371     } else if (!strcmp(name, "SAX function error")) {
00372         ctxt->sax->error = *((errorSAXFunc *) value);
00373     } else if (!strcmp(name, "SAX function fatalError")) {
00374         ctxt->sax->fatalError = *((fatalErrorSAXFunc *) value);
00375     } else if (!strcmp(name, "SAX function getParameterEntity")) {
00376         ctxt->sax->getParameterEntity =
00377             *((getParameterEntitySAXFunc *) value);
00378     } else if (!strcmp(name, "SAX function cdataBlock")) {
00379         ctxt->sax->cdataBlock = *((cdataBlockSAXFunc *) value);
00380     } else if (!strcmp(name, "SAX function externalSubset")) {
00381         ctxt->sax->externalSubset = *((externalSubsetSAXFunc *) value);
00382     } else {
00383         return (-1);
00384     }
00385     return (0);
00386 }
00387 
00409 xmlChar *
00410 xmlDecodeEntities(xmlParserCtxtPtr ctxt ATTRIBUTE_UNUSED,
00411                   int len ATTRIBUTE_UNUSED, int what ATTRIBUTE_UNUSED,
00412                   xmlChar end ATTRIBUTE_UNUSED,
00413                   xmlChar end2 ATTRIBUTE_UNUSED,
00414                   xmlChar end3 ATTRIBUTE_UNUSED)
00415 {
00416     static int deprecated = 0;
00417 
00418     if (!deprecated) {
00419         xmlGenericError(xmlGenericErrorContext,
00420                         "xmlDecodeEntities() deprecated function reached\n");
00421         deprecated = 1;
00422     }
00423     return (NULL);
00424 }
00425 
00443 xmlChar *
00444 xmlNamespaceParseNCName(xmlParserCtxtPtr ctxt ATTRIBUTE_UNUSED)
00445 {
00446     static int deprecated = 0;
00447 
00448     if (!deprecated) {
00449         xmlGenericError(xmlGenericErrorContext,
00450                         "xmlNamespaceParseNCName() deprecated function reached\n");
00451         deprecated = 1;
00452     }
00453     return (NULL);
00454 }
00455 
00476 xmlChar *
00477 xmlNamespaceParseQName(xmlParserCtxtPtr ctxt ATTRIBUTE_UNUSED,
00478                        xmlChar ** prefix ATTRIBUTE_UNUSED)
00479 {
00480 
00481     static int deprecated = 0;
00482 
00483     if (!deprecated) {
00484         xmlGenericError(xmlGenericErrorContext,
00485                         "xmlNamespaceParseQName() deprecated function reached\n");
00486         deprecated = 1;
00487     }
00488     return (NULL);
00489 }
00490 
00507 xmlChar *
00508 xmlNamespaceParseNSDef(xmlParserCtxtPtr ctxt ATTRIBUTE_UNUSED)
00509 {
00510     static int deprecated = 0;
00511 
00512     if (!deprecated) {
00513         xmlGenericError(xmlGenericErrorContext,
00514                         "xmlNamespaceParseNSDef() deprecated function reached\n");
00515         deprecated = 1;
00516     }
00517     return (NULL);
00518 }
00519 
00530 xmlChar *
00531 xmlParseQuotedString(xmlParserCtxtPtr ctxt ATTRIBUTE_UNUSED)
00532 {
00533     static int deprecated = 0;
00534 
00535     if (!deprecated) {
00536         xmlGenericError(xmlGenericErrorContext,
00537                         "xmlParseQuotedString() deprecated function reached\n");
00538         deprecated = 1;
00539     }
00540     return (NULL);
00541 }
00542 
00558 void
00559 xmlParseNamespace(xmlParserCtxtPtr ctxt ATTRIBUTE_UNUSED)
00560 {
00561     static int deprecated = 0;
00562 
00563     if (!deprecated) {
00564         xmlGenericError(xmlGenericErrorContext,
00565                         "xmlParseNamespace() deprecated function reached\n");
00566         deprecated = 1;
00567     }
00568 }
00569 
00590 xmlChar *
00591 xmlScanName(xmlParserCtxtPtr ctxt ATTRIBUTE_UNUSED)
00592 {
00593     static int deprecated = 0;
00594 
00595     if (!deprecated) {
00596         xmlGenericError(xmlGenericErrorContext,
00597                         "xmlScanName() deprecated function reached\n");
00598         deprecated = 1;
00599     }
00600     return (NULL);
00601 }
00602 
00630 void
00631 xmlParserHandleReference(xmlParserCtxtPtr ctxt ATTRIBUTE_UNUSED)
00632 {
00633     static int deprecated = 0;
00634 
00635     if (!deprecated) {
00636         xmlGenericError(xmlGenericErrorContext,
00637                         "xmlParserHandleReference() deprecated function reached\n");
00638         deprecated = 1;
00639     }
00640 
00641     return;
00642 }
00643 
00655 void
00656 xmlHandleEntity(xmlParserCtxtPtr ctxt ATTRIBUTE_UNUSED,
00657                 xmlEntityPtr entity ATTRIBUTE_UNUSED)
00658 {
00659     static int deprecated = 0;
00660 
00661     if (!deprecated) {
00662         xmlGenericError(xmlGenericErrorContext,
00663                         "xmlHandleEntity() deprecated function reached\n");
00664         deprecated = 1;
00665     }
00666 }
00667 
00678 xmlNsPtr
00679 xmlNewGlobalNs(xmlDocPtr doc ATTRIBUTE_UNUSED,
00680                const xmlChar * href ATTRIBUTE_UNUSED,
00681                const xmlChar * prefix ATTRIBUTE_UNUSED)
00682 {
00683     static int deprecated = 0;
00684 
00685     if (!deprecated) {
00686         xmlGenericError(xmlGenericErrorContext,
00687                         "xmlNewGlobalNs() deprecated function reached\n");
00688         deprecated = 1;
00689     }
00690     return (NULL);
00691 }
00692 
00700 void
00701 xmlUpgradeOldNs(xmlDocPtr doc ATTRIBUTE_UNUSED)
00702 {
00703     static int deprecated = 0;
00704 
00705     if (!deprecated) {
00706         xmlGenericError(xmlGenericErrorContext,
00707                         "xmlUpgradeOldNs() deprecated function reached\n");
00708         deprecated = 1;
00709     }
00710 }
00711 
00725 const xmlChar *
00726 xmlEncodeEntities(xmlDocPtr doc ATTRIBUTE_UNUSED,
00727                   const xmlChar * input ATTRIBUTE_UNUSED)
00728 {
00729     static int warning = 1;
00730 
00731     if (warning) {
00732         xmlGenericError(xmlGenericErrorContext,
00733                         "Deprecated API xmlEncodeEntities() used\n");
00734         xmlGenericError(xmlGenericErrorContext,
00735                         "   change code to use xmlEncodeEntitiesReentrant()\n");
00736         warning = 0;
00737     }
00738     return (NULL);
00739 }
00740 
00741 /************************************************************************
00742  *                                  *
00743  *      Old set of SAXv1 functions              *
00744  *                                  *
00745  ************************************************************************/
00746 static int deprecated_v1_msg = 0;
00747 
00748 #define DEPRECATED(n)                       \
00749     if (deprecated_v1_msg == 0)                 \
00750     xmlGenericError(xmlGenericErrorContext,         \
00751       "Use of deprecated SAXv1 function %s\n", n);      \
00752     deprecated_v1_msg++;
00753 
00763 const xmlChar *
00764 getPublicId(void *ctx)
00765 {
00766     DEPRECATED("getPublicId")
00767         return (xmlSAX2GetPublicId(ctx));
00768 }
00769 
00780 const xmlChar *
00781 getSystemId(void *ctx)
00782 {
00783     DEPRECATED("getSystemId")
00784         return (xmlSAX2GetSystemId(ctx));
00785 }
00786 
00796 int
00797 getLineNumber(void *ctx)
00798 {
00799     DEPRECATED("getLineNumber")
00800         return (xmlSAX2GetLineNumber(ctx));
00801 }
00802 
00812 int
00813 getColumnNumber(void *ctx)
00814 {
00815     DEPRECATED("getColumnNumber")
00816         return (xmlSAX2GetColumnNumber(ctx));
00817 }
00818 
00828 int
00829 isStandalone(void *ctx)
00830 {
00831     DEPRECATED("isStandalone")
00832         return (xmlSAX2IsStandalone(ctx));
00833 }
00834 
00844 int
00845 hasInternalSubset(void *ctx)
00846 {
00847     DEPRECATED("hasInternalSubset")
00848         return (xmlSAX2HasInternalSubset(ctx));
00849 }
00850 
00860 int
00861 hasExternalSubset(void *ctx)
00862 {
00863     DEPRECATED("hasExternalSubset")
00864         return (xmlSAX2HasExternalSubset(ctx));
00865 }
00866 
00877 void
00878 internalSubset(void *ctx, const xmlChar * name,
00879                const xmlChar * ExternalID, const xmlChar * SystemID)
00880 {
00881     DEPRECATED("internalSubset")
00882         xmlSAX2InternalSubset(ctx, name, ExternalID, SystemID);
00883 }
00884 
00895 void
00896 externalSubset(void *ctx, const xmlChar * name,
00897                const xmlChar * ExternalID, const xmlChar * SystemID)
00898 {
00899     DEPRECATED("externalSubset")
00900         xmlSAX2ExternalSubset(ctx, name, ExternalID, SystemID);
00901 }
00902 
00918 xmlParserInputPtr
00919 resolveEntity(void *ctx, const xmlChar * publicId,
00920               const xmlChar * systemId)
00921 {
00922     DEPRECATED("resolveEntity")
00923         return (xmlSAX2ResolveEntity(ctx, publicId, systemId));
00924 }
00925 
00936 xmlEntityPtr
00937 getEntity(void *ctx, const xmlChar * name)
00938 {
00939     DEPRECATED("getEntity")
00940         return (xmlSAX2GetEntity(ctx, name));
00941 }
00942 
00953 xmlEntityPtr
00954 getParameterEntity(void *ctx, const xmlChar * name)
00955 {
00956     DEPRECATED("getParameterEntity")
00957         return (xmlSAX2GetParameterEntity(ctx, name));
00958 }
00959 
00960 
00973 void
00974 entityDecl(void *ctx, const xmlChar * name, int type,
00975            const xmlChar * publicId, const xmlChar * systemId,
00976            xmlChar * content)
00977 {
00978     DEPRECATED("entityDecl")
00979         xmlSAX2EntityDecl(ctx, name, type, publicId, systemId, content);
00980 }
00981 
00995 void
00996 attributeDecl(void *ctx, const xmlChar * elem, const xmlChar * fullname,
00997               int type, int def, const xmlChar * defaultValue,
00998               xmlEnumerationPtr tree)
00999 {
01000     DEPRECATED("attributeDecl")
01001         xmlSAX2AttributeDecl(ctx, elem, fullname, type, def, defaultValue,
01002                              tree);
01003 }
01004 
01015 void
01016 elementDecl(void *ctx, const xmlChar * name, int type,
01017             xmlElementContentPtr content)
01018 {
01019     DEPRECATED("elementDecl")
01020         xmlSAX2ElementDecl(ctx, name, type, content);
01021 }
01022 
01033 void
01034 notationDecl(void *ctx, const xmlChar * name,
01035              const xmlChar * publicId, const xmlChar * systemId)
01036 {
01037     DEPRECATED("notationDecl")
01038         xmlSAX2NotationDecl(ctx, name, publicId, systemId);
01039 }
01040 
01052 void
01053 unparsedEntityDecl(void *ctx, const xmlChar * name,
01054                    const xmlChar * publicId, const xmlChar * systemId,
01055                    const xmlChar * notationName)
01056 {
01057     DEPRECATED("unparsedEntityDecl")
01058         xmlSAX2UnparsedEntityDecl(ctx, name, publicId, systemId,
01059                                   notationName);
01060 }
01061 
01071 void
01072 setDocumentLocator(void *ctx ATTRIBUTE_UNUSED,
01073                    xmlSAXLocatorPtr loc ATTRIBUTE_UNUSED)
01074 {
01075     DEPRECATED("setDocumentLocator")
01076 }
01077 
01085 void
01086 startDocument(void *ctx)
01087 {
01088    /* don't be too painful for glade users */
01089    /*  DEPRECATED("startDocument") */
01090         xmlSAX2StartDocument(ctx);
01091 }
01092 
01100 void
01101 endDocument(void *ctx)
01102 {
01103     DEPRECATED("endDocument")
01104         xmlSAX2EndDocument(ctx);
01105 }
01106 
01119 void
01120 attribute(void *ctx ATTRIBUTE_UNUSED,
01121           const xmlChar * fullname ATTRIBUTE_UNUSED,
01122           const xmlChar * value ATTRIBUTE_UNUSED)
01123 {
01124     DEPRECATED("attribute")
01125 }
01126 
01136 void
01137 startElement(void *ctx, const xmlChar * fullname, const xmlChar ** atts)
01138 {
01139     xmlSAX2StartElement(ctx, fullname, atts);
01140 }
01141 
01150 void
01151 endElement(void *ctx, const xmlChar * name ATTRIBUTE_UNUSED)
01152 {
01153     DEPRECATED("endElement")
01154         xmlSAX2EndElement(ctx, name);
01155 }
01156 
01165 void
01166 reference(void *ctx, const xmlChar * name)
01167 {
01168     DEPRECATED("reference")
01169         xmlSAX2Reference(ctx, name);
01170 }
01171 
01181 void
01182 characters(void *ctx, const xmlChar * ch, int len)
01183 {
01184     DEPRECATED("characters")
01185         xmlSAX2Characters(ctx, ch, len);
01186 }
01187 
01198 void
01199 ignorableWhitespace(void *ctx ATTRIBUTE_UNUSED,
01200                     const xmlChar * ch ATTRIBUTE_UNUSED,
01201                     int len ATTRIBUTE_UNUSED)
01202 {
01203     DEPRECATED("ignorableWhitespace")
01204 }
01205 
01215 void
01216 processingInstruction(void *ctx, const xmlChar * target,
01217                       const xmlChar * data)
01218 {
01219     DEPRECATED("processingInstruction")
01220         xmlSAX2ProcessingInstruction(ctx, target, data);
01221 }
01222 
01232 void
01233 globalNamespace(void *ctx ATTRIBUTE_UNUSED,
01234                 const xmlChar * href ATTRIBUTE_UNUSED,
01235                 const xmlChar * prefix ATTRIBUTE_UNUSED)
01236 {
01237     DEPRECATED("globalNamespace")
01238 }
01239 
01249 void
01250 setNamespace(void *ctx ATTRIBUTE_UNUSED,
01251              const xmlChar * name ATTRIBUTE_UNUSED)
01252 {
01253     DEPRECATED("setNamespace")
01254 }
01255 
01266 xmlNsPtr
01267 getNamespace(void *ctx ATTRIBUTE_UNUSED)
01268 {
01269     DEPRECATED("getNamespace")
01270         return (NULL);
01271 }
01272 
01285 int
01286 checkNamespace(void *ctx ATTRIBUTE_UNUSED,
01287                xmlChar * namespace ATTRIBUTE_UNUSED)
01288 {
01289     DEPRECATED("checkNamespace")
01290         return (0);
01291 }
01292 
01302 void
01303 namespaceDecl(void *ctx ATTRIBUTE_UNUSED,
01304               const xmlChar * href ATTRIBUTE_UNUSED,
01305               const xmlChar * prefix ATTRIBUTE_UNUSED)
01306 {
01307     DEPRECATED("namespaceDecl")
01308 }
01309 
01318 void
01319 comment(void *ctx, const xmlChar * value)
01320 {
01321     DEPRECATED("comment")
01322         xmlSAX2Comment(ctx, value);
01323 }
01324 
01334 void
01335 cdataBlock(void *ctx, const xmlChar * value, int len)
01336 {
01337     DEPRECATED("cdataBlock")
01338         xmlSAX2CDataBlock(ctx, value, len);
01339 }
01340 #define bottom_legacy
01341 #include "elfgcchack.h"
01342 #endif /* LIBXML_LEGACY_ENABLED */
01343
Generated on Sun May 27 2012 04:26:52 for ReactOS by
1.7.6.1