| /* | |
| * relaxng.c : implementation of the Relax-NG handling and validity checking | |
| * | |
| * See Copyright for the status of this software. | |
| * | |
| * Daniel Veillard <veillard@redhat.com> | |
| */ | |
| /** | |
| * TODO: | |
| * - add support for DTD compatibility spec | |
| * http://www.oasis-open.org/committees/relax-ng/compatibility-20011203.html | |
| * - report better mem allocations pbms at runtime and abort immediately. | |
| */ | |
| #define IN_LIBXML | |
| #include "libxml.h" | |
| #ifdef LIBXML_SCHEMAS_ENABLED | |
| #include <string.h> | |
| #include <stdio.h> | |
| #include <libxml/xmlmemory.h> | |
| #include <libxml/parser.h> | |
| #include <libxml/parserInternals.h> | |
| #include <libxml/hash.h> | |
| #include <libxml/uri.h> | |
| #include <libxml/relaxng.h> | |
| #include <libxml/xmlschemastypes.h> | |
| #include <libxml/xmlautomata.h> | |
| #include <libxml/xmlregexp.h> | |
| #include <libxml/xmlschemastypes.h> | |
| /* | |
| * The Relax-NG namespace | |
| */ | |
| static const xmlChar *xmlRelaxNGNs = (const xmlChar *) | |
| "http://relaxng.org/ns/structure/1.0"; | |
| #define IS_RELAXNG(node, typ) \ | |
| ((node != NULL) && (node->ns != NULL) && \ | |
| (node->type == XML_ELEMENT_NODE) && \ | |
| (xmlStrEqual(node->name, (const xmlChar *) typ)) && \ | |
| (xmlStrEqual(node->ns->href, xmlRelaxNGNs))) | |
| #if 0 | |
| #define DEBUG 1 | |
| #define DEBUG_GRAMMAR 1 | |
| #define DEBUG_CONTENT 1 | |
| #define DEBUG_TYPE 1 | |
| #define DEBUG_VALID 1 | |
| #define DEBUG_INTERLEAVE 1 | |
| #define DEBUG_LIST 1 | |
| #define DEBUG_INCLUDE 1 | |
| #define DEBUG_ERROR 1 | |
| #define DEBUG_COMPILE 1 | |
| #define DEBUG_PROGRESSIVE 1 | |
| #endif | |
| #define MAX_ERROR 5 | |
| #define TODO \ | |
| xmlGenericError(xmlGenericErrorContext, \ | |
| "Unimplemented block at %s:%d\n", \ | |
| __FILE__, __LINE__); | |
| typedef struct _xmlRelaxNGSchema xmlRelaxNGSchema; | |
| typedef xmlRelaxNGSchema *xmlRelaxNGSchemaPtr; | |
| typedef struct _xmlRelaxNGDefine xmlRelaxNGDefine; | |
| typedef xmlRelaxNGDefine *xmlRelaxNGDefinePtr; | |
| typedef struct _xmlRelaxNGDocument xmlRelaxNGDocument; | |
| typedef xmlRelaxNGDocument *xmlRelaxNGDocumentPtr; | |
| typedef struct _xmlRelaxNGInclude xmlRelaxNGInclude; | |
| typedef xmlRelaxNGInclude *xmlRelaxNGIncludePtr; | |
| typedef enum { | |
| XML_RELAXNG_COMBINE_UNDEFINED = 0, /* undefined */ | |
| XML_RELAXNG_COMBINE_CHOICE, /* choice */ | |
| XML_RELAXNG_COMBINE_INTERLEAVE /* interleave */ | |
| } xmlRelaxNGCombine; | |
| typedef enum { | |
| XML_RELAXNG_CONTENT_ERROR = -1, | |
| XML_RELAXNG_CONTENT_EMPTY = 0, | |
| XML_RELAXNG_CONTENT_SIMPLE, | |
| XML_RELAXNG_CONTENT_COMPLEX | |
| } xmlRelaxNGContentType; | |
| typedef struct _xmlRelaxNGGrammar xmlRelaxNGGrammar; | |
| typedef xmlRelaxNGGrammar *xmlRelaxNGGrammarPtr; | |
| struct _xmlRelaxNGGrammar { | |
| xmlRelaxNGGrammarPtr parent; /* the parent grammar if any */ | |
| xmlRelaxNGGrammarPtr children; /* the children grammar if any */ | |
| xmlRelaxNGGrammarPtr next; /* the next grammar if any */ | |
| xmlRelaxNGDefinePtr start; /* <start> content */ | |
| xmlRelaxNGCombine combine; /* the default combine value */ | |
| xmlRelaxNGDefinePtr startList; /* list of <start> definitions */ | |
| xmlHashTablePtr defs; /* define* */ | |
| xmlHashTablePtr refs; /* references */ | |
| }; | |
| typedef enum { | |
| XML_RELAXNG_NOOP = -1, /* a no operation from simplification */ | |
| XML_RELAXNG_EMPTY = 0, /* an empty pattern */ | |
| XML_RELAXNG_NOT_ALLOWED, /* not allowed top */ | |
| XML_RELAXNG_EXCEPT, /* except present in nameclass defs */ | |
| XML_RELAXNG_TEXT, /* textual content */ | |
| XML_RELAXNG_ELEMENT, /* an element */ | |
| XML_RELAXNG_DATATYPE, /* extenal data type definition */ | |
| XML_RELAXNG_PARAM, /* extenal data type parameter */ | |
| XML_RELAXNG_VALUE, /* value from an extenal data type definition */ | |
| XML_RELAXNG_LIST, /* a list of patterns */ | |
| XML_RELAXNG_ATTRIBUTE, /* an attrbute following a pattern */ | |
| XML_RELAXNG_DEF, /* a definition */ | |
| XML_RELAXNG_REF, /* reference to a definition */ | |
| XML_RELAXNG_EXTERNALREF, /* reference to an external def */ | |
| XML_RELAXNG_PARENTREF, /* reference to a def in the parent grammar */ | |
| XML_RELAXNG_OPTIONAL, /* optional patterns */ | |
| XML_RELAXNG_ZEROORMORE, /* zero or more non empty patterns */ | |
| XML_RELAXNG_ONEORMORE, /* one or more non empty patterns */ | |
| XML_RELAXNG_CHOICE, /* a choice between non empty patterns */ | |
| XML_RELAXNG_GROUP, /* a pair/group of non empty patterns */ | |
| XML_RELAXNG_INTERLEAVE, /* interleaving choice of non-empty patterns */ | |
| XML_RELAXNG_START /* Used to keep track of starts on grammars */ | |
| } xmlRelaxNGType; | |
| #define IS_NULLABLE (1 << 0) | |
| #define IS_NOT_NULLABLE (1 << 1) | |
| #define IS_INDETERMINIST (1 << 2) | |
| #define IS_MIXED (1 << 3) | |
| #define IS_TRIABLE (1 << 4) | |
| #define IS_PROCESSED (1 << 5) | |
| #define IS_COMPILABLE (1 << 6) | |
| #define IS_NOT_COMPILABLE (1 << 7) | |
| #define IS_EXTERNAL_REF (1 << 8) | |
| struct _xmlRelaxNGDefine { | |
| xmlRelaxNGType type; /* the type of definition */ | |
| xmlNodePtr node; /* the node in the source */ | |
| xmlChar *name; /* the element local name if present */ | |
| xmlChar *ns; /* the namespace local name if present */ | |
| xmlChar *value; /* value when available */ | |
| void *data; /* data lib or specific pointer */ | |
| xmlRelaxNGDefinePtr content; /* the expected content */ | |
| xmlRelaxNGDefinePtr parent; /* the parent definition, if any */ | |
| xmlRelaxNGDefinePtr next; /* list within grouping sequences */ | |
| xmlRelaxNGDefinePtr attrs; /* list of attributes for elements */ | |
| xmlRelaxNGDefinePtr nameClass; /* the nameClass definition if any */ | |
| xmlRelaxNGDefinePtr nextHash; /* next define in defs/refs hash tables */ | |
| short depth; /* used for the cycle detection */ | |
| short dflags; /* define related flags */ | |
| xmlRegexpPtr contModel; /* a compiled content model if available */ | |
| }; | |
| /** | |
| * _xmlRelaxNG: | |
| * | |
| * A RelaxNGs definition | |
| */ | |
| struct _xmlRelaxNG { | |
| void *_private; /* unused by the library for users or bindings */ | |
| xmlRelaxNGGrammarPtr topgrammar; | |
| xmlDocPtr doc; | |
| int idref; /* requires idref checking */ | |
| xmlHashTablePtr defs; /* define */ | |
| xmlHashTablePtr refs; /* references */ | |
| xmlRelaxNGDocumentPtr documents; /* all the documents loaded */ | |
| xmlRelaxNGIncludePtr includes; /* all the includes loaded */ | |
| int defNr; /* number of defines used */ | |
| xmlRelaxNGDefinePtr *defTab; /* pointer to the allocated definitions */ | |
| }; | |
| #define XML_RELAXNG_IN_ATTRIBUTE (1 << 0) | |
| #define XML_RELAXNG_IN_ONEORMORE (1 << 1) | |
| #define XML_RELAXNG_IN_LIST (1 << 2) | |
| #define XML_RELAXNG_IN_DATAEXCEPT (1 << 3) | |
| #define XML_RELAXNG_IN_START (1 << 4) | |
| #define XML_RELAXNG_IN_OOMGROUP (1 << 5) | |
| #define XML_RELAXNG_IN_OOMINTERLEAVE (1 << 6) | |
| #define XML_RELAXNG_IN_EXTERNALREF (1 << 7) | |
| #define XML_RELAXNG_IN_ANYEXCEPT (1 << 8) | |
| #define XML_RELAXNG_IN_NSEXCEPT (1 << 9) | |
| struct _xmlRelaxNGParserCtxt { | |
| void *userData; /* user specific data block */ | |
| xmlRelaxNGValidityErrorFunc error; /* the callback in case of errors */ | |
| xmlRelaxNGValidityWarningFunc warning; /* the callback in case of warning */ | |
| xmlStructuredErrorFunc serror; | |
| xmlRelaxNGValidErr err; | |
| xmlRelaxNGPtr schema; /* The schema in use */ | |
| xmlRelaxNGGrammarPtr grammar; /* the current grammar */ | |
| xmlRelaxNGGrammarPtr parentgrammar; /* the parent grammar */ | |
| int flags; /* parser flags */ | |
| int nbErrors; /* number of errors at parse time */ | |
| int nbWarnings; /* number of warnings at parse time */ | |
| const xmlChar *define; /* the current define scope */ | |
| xmlRelaxNGDefinePtr def; /* the current define */ | |
| int nbInterleaves; | |
| xmlHashTablePtr interleaves; /* keep track of all the interleaves */ | |
| xmlRelaxNGDocumentPtr documents; /* all the documents loaded */ | |
| xmlRelaxNGIncludePtr includes; /* all the includes loaded */ | |
| xmlChar *URL; | |
| xmlDocPtr document; | |
| int defNr; /* number of defines used */ | |
| int defMax; /* number of defines aloocated */ | |
| xmlRelaxNGDefinePtr *defTab; /* pointer to the allocated definitions */ | |
| const char *buffer; | |
| int size; | |
| /* the document stack */ | |
| xmlRelaxNGDocumentPtr doc; /* Current parsed external ref */ | |
| int docNr; /* Depth of the parsing stack */ | |
| int docMax; /* Max depth of the parsing stack */ | |
| xmlRelaxNGDocumentPtr *docTab; /* array of docs */ | |
| /* the include stack */ | |
| xmlRelaxNGIncludePtr inc; /* Current parsed include */ | |
| int incNr; /* Depth of the include parsing stack */ | |
| int incMax; /* Max depth of the parsing stack */ | |
| xmlRelaxNGIncludePtr *incTab; /* array of incs */ | |
| int idref; /* requires idref checking */ | |
| /* used to compile content models */ | |
| xmlAutomataPtr am; /* the automata */ | |
| xmlAutomataStatePtr state; /* used to build the automata */ | |
| int crng; /* compact syntax and other flags */ | |
| int freedoc; /* need to free the document */ | |
| }; | |
| #define FLAGS_IGNORABLE 1 | |
| #define FLAGS_NEGATIVE 2 | |
| #define FLAGS_MIXED_CONTENT 4 | |
| #define FLAGS_NOERROR 8 | |
| /** | |
| * xmlRelaxNGInterleaveGroup: | |
| * | |
| * A RelaxNGs partition set associated to lists of definitions | |
| */ | |
| typedef struct _xmlRelaxNGInterleaveGroup xmlRelaxNGInterleaveGroup; | |
| typedef xmlRelaxNGInterleaveGroup *xmlRelaxNGInterleaveGroupPtr; | |
| struct _xmlRelaxNGInterleaveGroup { | |
| xmlRelaxNGDefinePtr rule; /* the rule to satisfy */ | |
| xmlRelaxNGDefinePtr *defs; /* the array of element definitions */ | |
| xmlRelaxNGDefinePtr *attrs; /* the array of attributes definitions */ | |
| }; | |
| #define IS_DETERMINIST 1 | |
| #define IS_NEEDCHECK 2 | |
| /** | |
| * xmlRelaxNGPartitions: | |
| * | |
| * A RelaxNGs partition associated to an interleave group | |
| */ | |
| typedef struct _xmlRelaxNGPartition xmlRelaxNGPartition; | |
| typedef xmlRelaxNGPartition *xmlRelaxNGPartitionPtr; | |
| struct _xmlRelaxNGPartition { | |
| int nbgroups; /* number of groups in the partitions */ | |
| xmlHashTablePtr triage; /* hash table used to direct nodes to the | |
| * right group when possible */ | |
| int flags; /* determinist ? */ | |
| xmlRelaxNGInterleaveGroupPtr *groups; | |
| }; | |
| /** | |
| * xmlRelaxNGValidState: | |
| * | |
| * A RelaxNGs validation state | |
| */ | |
| #define MAX_ATTR 20 | |
| typedef struct _xmlRelaxNGValidState xmlRelaxNGValidState; | |
| typedef xmlRelaxNGValidState *xmlRelaxNGValidStatePtr; | |
| struct _xmlRelaxNGValidState { | |
| xmlNodePtr node; /* the current node */ | |
| xmlNodePtr seq; /* the sequence of children left to validate */ | |
| int nbAttrs; /* the number of attributes */ | |
| int maxAttrs; /* the size of attrs */ | |
| int nbAttrLeft; /* the number of attributes left to validate */ | |
| xmlChar *value; /* the value when operating on string */ | |
| xmlChar *endvalue; /* the end value when operating on string */ | |
| xmlAttrPtr *attrs; /* the array of attributes */ | |
| }; | |
| /** | |
| * xmlRelaxNGStates: | |
| * | |
| * A RelaxNGs container for validation state | |
| */ | |
| typedef struct _xmlRelaxNGStates xmlRelaxNGStates; | |
| typedef xmlRelaxNGStates *xmlRelaxNGStatesPtr; | |
| struct _xmlRelaxNGStates { | |
| int nbState; /* the number of states */ | |
| int maxState; /* the size of the array */ | |
| xmlRelaxNGValidStatePtr *tabState; | |
| }; | |
| #define ERROR_IS_DUP 1 | |
| /** | |
| * xmlRelaxNGValidError: | |
| * | |
| * A RelaxNGs validation error | |
| */ | |
| typedef struct _xmlRelaxNGValidError xmlRelaxNGValidError; | |
| typedef xmlRelaxNGValidError *xmlRelaxNGValidErrorPtr; | |
| struct _xmlRelaxNGValidError { | |
| xmlRelaxNGValidErr err; /* the error number */ | |
| int flags; /* flags */ | |
| xmlNodePtr node; /* the current node */ | |
| xmlNodePtr seq; /* the current child */ | |
| const xmlChar *arg1; /* first arg */ | |
| const xmlChar *arg2; /* second arg */ | |
| }; | |
| /** | |
| * xmlRelaxNGValidCtxt: | |
| * | |
| * A RelaxNGs validation context | |
| */ | |
| struct _xmlRelaxNGValidCtxt { | |
| void *userData; /* user specific data block */ | |
| xmlRelaxNGValidityErrorFunc error; /* the callback in case of errors */ | |
| xmlRelaxNGValidityWarningFunc warning; /* the callback in case of warning */ | |
| xmlStructuredErrorFunc serror; | |
| int nbErrors; /* number of errors in validation */ | |
| xmlRelaxNGPtr schema; /* The schema in use */ | |
| xmlDocPtr doc; /* the document being validated */ | |
| int flags; /* validation flags */ | |
| int depth; /* validation depth */ | |
| int idref; /* requires idref checking */ | |
| int errNo; /* the first error found */ | |
| /* | |
| * Errors accumulated in branches may have to be stacked to be | |
| * provided back when it's sure they affect validation. | |
| */ | |
| xmlRelaxNGValidErrorPtr err; /* Last error */ | |
| int errNr; /* Depth of the error stack */ | |
| int errMax; /* Max depth of the error stack */ | |
| xmlRelaxNGValidErrorPtr errTab; /* stack of errors */ | |
| xmlRelaxNGValidStatePtr state; /* the current validation state */ | |
| xmlRelaxNGStatesPtr states; /* the accumulated state list */ | |
| xmlRelaxNGStatesPtr freeState; /* the pool of free valid states */ | |
| int freeStatesNr; | |
| int freeStatesMax; | |
| xmlRelaxNGStatesPtr *freeStates; /* the pool of free state groups */ | |
| /* | |
| * This is used for "progressive" validation | |
| */ | |
| xmlRegExecCtxtPtr elem; /* the current element regexp */ | |
| int elemNr; /* the number of element validated */ | |
| int elemMax; /* the max depth of elements */ | |
| xmlRegExecCtxtPtr *elemTab; /* the stack of regexp runtime */ | |
| int pstate; /* progressive state */ | |
| xmlNodePtr pnode; /* the current node */ | |
| xmlRelaxNGDefinePtr pdef; /* the non-streamable definition */ | |
| int perr; /* signal error in content model | |
| * outside the regexp */ | |
| }; | |
| /** | |
| * xmlRelaxNGInclude: | |
| * | |
| * Structure associated to a RelaxNGs document element | |
| */ | |
| struct _xmlRelaxNGInclude { | |
| xmlRelaxNGIncludePtr next; /* keep a chain of includes */ | |
| xmlChar *href; /* the normalized href value */ | |
| xmlDocPtr doc; /* the associated XML document */ | |
| xmlRelaxNGDefinePtr content; /* the definitions */ | |
| xmlRelaxNGPtr schema; /* the schema */ | |
| }; | |
| /** | |
| * xmlRelaxNGDocument: | |
| * | |
| * Structure associated to a RelaxNGs document element | |
| */ | |
| struct _xmlRelaxNGDocument { | |
| xmlRelaxNGDocumentPtr next; /* keep a chain of documents */ | |
| xmlChar *href; /* the normalized href value */ | |
| xmlDocPtr doc; /* the associated XML document */ | |
| xmlRelaxNGDefinePtr content; /* the definitions */ | |
| xmlRelaxNGPtr schema; /* the schema */ | |
| int externalRef; /* 1 if an external ref */ | |
| }; | |
| /************************************************************************ | |
| * * | |
| * Some factorized error routines * | |
| * * | |
| ************************************************************************/ | |
| /** | |
| * xmlRngPErrMemory: | |
| * @ctxt: an Relax-NG parser context | |
| * @extra: extra informations | |
| * | |
| * Handle a redefinition of attribute error | |
| */ | |
| static void | |
| xmlRngPErrMemory(xmlRelaxNGParserCtxtPtr ctxt, const char *extra) | |
| { | |
| xmlStructuredErrorFunc schannel = NULL; | |
| xmlGenericErrorFunc channel = NULL; | |
| void *data = NULL; | |
| if (ctxt != NULL) { | |
| if (ctxt->serror != NULL) | |
| schannel = ctxt->serror; | |
| else | |
| channel = ctxt->error; | |
| data = ctxt->userData; | |
| ctxt->nbErrors++; | |
| } | |
| if (extra) | |
| __xmlRaiseError(schannel, channel, data, | |
| NULL, NULL, XML_FROM_RELAXNGP, | |
| XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, extra, | |
| NULL, NULL, 0, 0, | |
| "Memory allocation failed : %s\n", extra); | |
| else | |
| __xmlRaiseError(schannel, channel, data, | |
| NULL, NULL, XML_FROM_RELAXNGP, | |
| XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, NULL, | |
| NULL, NULL, 0, 0, "Memory allocation failed\n"); | |
| } | |
| /** | |
| * xmlRngVErrMemory: | |
| * @ctxt: a Relax-NG validation context | |
| * @extra: extra informations | |
| * | |
| * Handle a redefinition of attribute error | |
| */ | |
| static void | |
| xmlRngVErrMemory(xmlRelaxNGValidCtxtPtr ctxt, const char *extra) | |
| { | |
| xmlStructuredErrorFunc schannel = NULL; | |
| xmlGenericErrorFunc channel = NULL; | |
| void *data = NULL; | |
| if (ctxt != NULL) { | |
| if (ctxt->serror != NULL) | |
| schannel = ctxt->serror; | |
| else | |
| channel = ctxt->error; | |
| data = ctxt->userData; | |
| ctxt->nbErrors++; | |
| } | |
| if (extra) | |
| __xmlRaiseError(schannel, channel, data, | |
| NULL, NULL, XML_FROM_RELAXNGV, | |
| XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, extra, | |
| NULL, NULL, 0, 0, | |
| "Memory allocation failed : %s\n", extra); | |
| else | |
| __xmlRaiseError(schannel, channel, data, | |
| NULL, NULL, XML_FROM_RELAXNGV, | |
| XML_ERR_NO_MEMORY, XML_ERR_FATAL, NULL, 0, NULL, | |
| NULL, NULL, 0, 0, "Memory allocation failed\n"); | |
| } | |
| /** | |
| * xmlRngPErr: | |
| * @ctxt: a Relax-NG parser context | |
| * @node: the node raising the error | |
| * @error: the error code | |
| * @msg: message | |
| * @str1: extra info | |
| * @str2: extra info | |
| * | |
| * Handle a Relax NG Parsing error | |
| */ | |
| static void LIBXML_ATTR_FORMAT(4,0) | |
| xmlRngPErr(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node, int error, | |
| const char *msg, const xmlChar * str1, const xmlChar * str2) | |
| { | |
| xmlStructuredErrorFunc schannel = NULL; | |
| xmlGenericErrorFunc channel = NULL; | |
| void *data = NULL; | |
| if (ctxt != NULL) { | |
| if (ctxt->serror != NULL) | |
| schannel = ctxt->serror; | |
| else | |
| channel = ctxt->error; | |
| data = ctxt->userData; | |
| ctxt->nbErrors++; | |
| } | |
| __xmlRaiseError(schannel, channel, data, | |
| NULL, node, XML_FROM_RELAXNGP, | |
| error, XML_ERR_ERROR, NULL, 0, | |
| (const char *) str1, (const char *) str2, NULL, 0, 0, | |
| msg, str1, str2); | |
| } | |
| /** | |
| * xmlRngVErr: | |
| * @ctxt: a Relax-NG validation context | |
| * @node: the node raising the error | |
| * @error: the error code | |
| * @msg: message | |
| * @str1: extra info | |
| * @str2: extra info | |
| * | |
| * Handle a Relax NG Validation error | |
| */ | |
| static void LIBXML_ATTR_FORMAT(4,0) | |
| xmlRngVErr(xmlRelaxNGValidCtxtPtr ctxt, xmlNodePtr node, int error, | |
| const char *msg, const xmlChar * str1, const xmlChar * str2) | |
| { | |
| xmlStructuredErrorFunc schannel = NULL; | |
| xmlGenericErrorFunc channel = NULL; | |
| void *data = NULL; | |
| if (ctxt != NULL) { | |
| if (ctxt->serror != NULL) | |
| schannel = ctxt->serror; | |
| else | |
| channel = ctxt->error; | |
| data = ctxt->userData; | |
| ctxt->nbErrors++; | |
| } | |
| __xmlRaiseError(schannel, channel, data, | |
| NULL, node, XML_FROM_RELAXNGV, | |
| error, XML_ERR_ERROR, NULL, 0, | |
| (const char *) str1, (const char *) str2, NULL, 0, 0, | |
| msg, str1, str2); | |
| } | |
| /************************************************************************ | |
| * * | |
| * Preliminary type checking interfaces * | |
| * * | |
| ************************************************************************/ | |
| /** | |
| * xmlRelaxNGTypeHave: | |
| * @data: data needed for the library | |
| * @type: the type name | |
| * @value: the value to check | |
| * | |
| * Function provided by a type library to check if a type is exported | |
| * | |
| * Returns 1 if yes, 0 if no and -1 in case of error. | |
| */ | |
| typedef int (*xmlRelaxNGTypeHave) (void *data, const xmlChar * type); | |
| /** | |
| * xmlRelaxNGTypeCheck: | |
| * @data: data needed for the library | |
| * @type: the type name | |
| * @value: the value to check | |
| * @result: place to store the result if needed | |
| * | |
| * Function provided by a type library to check if a value match a type | |
| * | |
| * Returns 1 if yes, 0 if no and -1 in case of error. | |
| */ | |
| typedef int (*xmlRelaxNGTypeCheck) (void *data, const xmlChar * type, | |
| const xmlChar * value, void **result, | |
| xmlNodePtr node); | |
| /** | |
| * xmlRelaxNGFacetCheck: | |
| * @data: data needed for the library | |
| * @type: the type name | |
| * @facet: the facet name | |
| * @val: the facet value | |
| * @strval: the string value | |
| * @value: the value to check | |
| * | |
| * Function provided by a type library to check a value facet | |
| * | |
| * Returns 1 if yes, 0 if no and -1 in case of error. | |
| */ | |
| typedef int (*xmlRelaxNGFacetCheck) (void *data, const xmlChar * type, | |
| const xmlChar * facet, | |
| const xmlChar * val, | |
| const xmlChar * strval, void *value); | |
| /** | |
| * xmlRelaxNGTypeFree: | |
| * @data: data needed for the library | |
| * @result: the value to free | |
| * | |
| * Function provided by a type library to free a returned result | |
| */ | |
| typedef void (*xmlRelaxNGTypeFree) (void *data, void *result); | |
| /** | |
| * xmlRelaxNGTypeCompare: | |
| * @data: data needed for the library | |
| * @type: the type name | |
| * @value1: the first value | |
| * @value2: the second value | |
| * | |
| * Function provided by a type library to compare two values accordingly | |
| * to a type. | |
| * | |
| * Returns 1 if yes, 0 if no and -1 in case of error. | |
| */ | |
| typedef int (*xmlRelaxNGTypeCompare) (void *data, const xmlChar * type, | |
| const xmlChar * value1, | |
| xmlNodePtr ctxt1, | |
| void *comp1, | |
| const xmlChar * value2, | |
| xmlNodePtr ctxt2); | |
| typedef struct _xmlRelaxNGTypeLibrary xmlRelaxNGTypeLibrary; | |
| typedef xmlRelaxNGTypeLibrary *xmlRelaxNGTypeLibraryPtr; | |
| struct _xmlRelaxNGTypeLibrary { | |
| const xmlChar *namespace; /* the datatypeLibrary value */ | |
| void *data; /* data needed for the library */ | |
| xmlRelaxNGTypeHave have; /* the export function */ | |
| xmlRelaxNGTypeCheck check; /* the checking function */ | |
| xmlRelaxNGTypeCompare comp; /* the compare function */ | |
| xmlRelaxNGFacetCheck facet; /* the facet check function */ | |
| xmlRelaxNGTypeFree freef; /* the freeing function */ | |
| }; | |
| /************************************************************************ | |
| * * | |
| * Allocation functions * | |
| * * | |
| ************************************************************************/ | |
| static void xmlRelaxNGFreeGrammar(xmlRelaxNGGrammarPtr grammar); | |
| static void xmlRelaxNGFreeDefine(xmlRelaxNGDefinePtr define); | |
| static void xmlRelaxNGNormExtSpace(xmlChar * value); | |
| static void xmlRelaxNGFreeInnerSchema(xmlRelaxNGPtr schema); | |
| static int xmlRelaxNGEqualValidState(xmlRelaxNGValidCtxtPtr ctxt | |
| ATTRIBUTE_UNUSED, | |
| xmlRelaxNGValidStatePtr state1, | |
| xmlRelaxNGValidStatePtr state2); | |
| static void xmlRelaxNGFreeValidState(xmlRelaxNGValidCtxtPtr ctxt, | |
| xmlRelaxNGValidStatePtr state); | |
| /** | |
| * xmlRelaxNGFreeDocument: | |
| * @docu: a document structure | |
| * | |
| * Deallocate a RelaxNG document structure. | |
| */ | |
| static void | |
| xmlRelaxNGFreeDocument(xmlRelaxNGDocumentPtr docu) | |
| { | |
| if (docu == NULL) | |
| return; | |
| if (docu->href != NULL) | |
| xmlFree(docu->href); | |
| if (docu->doc != NULL) | |
| xmlFreeDoc(docu->doc); | |
| if (docu->schema != NULL) | |
| xmlRelaxNGFreeInnerSchema(docu->schema); | |
| xmlFree(docu); | |
| } | |
| /** | |
| * xmlRelaxNGFreeDocumentList: | |
| * @docu: a list of document structure | |
| * | |
| * Deallocate a RelaxNG document structures. | |
| */ | |
| static void | |
| xmlRelaxNGFreeDocumentList(xmlRelaxNGDocumentPtr docu) | |
| { | |
| xmlRelaxNGDocumentPtr next; | |
| while (docu != NULL) { | |
| next = docu->next; | |
| xmlRelaxNGFreeDocument(docu); | |
| docu = next; | |
| } | |
| } | |
| /** | |
| * xmlRelaxNGFreeInclude: | |
| * @incl: a include structure | |
| * | |
| * Deallocate a RelaxNG include structure. | |
| */ | |
| static void | |
| xmlRelaxNGFreeInclude(xmlRelaxNGIncludePtr incl) | |
| { | |
| if (incl == NULL) | |
| return; | |
| if (incl->href != NULL) | |
| xmlFree(incl->href); | |
| if (incl->doc != NULL) | |
| xmlFreeDoc(incl->doc); | |
| if (incl->schema != NULL) | |
| xmlRelaxNGFree(incl->schema); | |
| xmlFree(incl); | |
| } | |
| /** | |
| * xmlRelaxNGFreeIncludeList: | |
| * @incl: a include structure list | |
| * | |
| * Deallocate a RelaxNG include structure. | |
| */ | |
| static void | |
| xmlRelaxNGFreeIncludeList(xmlRelaxNGIncludePtr incl) | |
| { | |
| xmlRelaxNGIncludePtr next; | |
| while (incl != NULL) { | |
| next = incl->next; | |
| xmlRelaxNGFreeInclude(incl); | |
| incl = next; | |
| } | |
| } | |
| /** | |
| * xmlRelaxNGNewRelaxNG: | |
| * @ctxt: a Relax-NG validation context (optional) | |
| * | |
| * Allocate a new RelaxNG structure. | |
| * | |
| * Returns the newly allocated structure or NULL in case or error | |
| */ | |
| static xmlRelaxNGPtr | |
| xmlRelaxNGNewRelaxNG(xmlRelaxNGParserCtxtPtr ctxt) | |
| { | |
| xmlRelaxNGPtr ret; | |
| ret = (xmlRelaxNGPtr) xmlMalloc(sizeof(xmlRelaxNG)); | |
| if (ret == NULL) { | |
| xmlRngPErrMemory(ctxt, NULL); | |
| return (NULL); | |
| } | |
| memset(ret, 0, sizeof(xmlRelaxNG)); | |
| return (ret); | |
| } | |
| /** | |
| * xmlRelaxNGFreeInnerSchema: | |
| * @schema: a schema structure | |
| * | |
| * Deallocate a RelaxNG schema structure. | |
| */ | |
| static void | |
| xmlRelaxNGFreeInnerSchema(xmlRelaxNGPtr schema) | |
| { | |
| if (schema == NULL) | |
| return; | |
| if (schema->doc != NULL) | |
| xmlFreeDoc(schema->doc); | |
| if (schema->defTab != NULL) { | |
| int i; | |
| for (i = 0; i < schema->defNr; i++) | |
| xmlRelaxNGFreeDefine(schema->defTab[i]); | |
| xmlFree(schema->defTab); | |
| } | |
| xmlFree(schema); | |
| } | |
| /** | |
| * xmlRelaxNGFree: | |
| * @schema: a schema structure | |
| * | |
| * Deallocate a RelaxNG structure. | |
| */ | |
| void | |
| xmlRelaxNGFree(xmlRelaxNGPtr schema) | |
| { | |
| if (schema == NULL) | |
| return; | |
| if (schema->topgrammar != NULL) | |
| xmlRelaxNGFreeGrammar(schema->topgrammar); | |
| if (schema->doc != NULL) | |
| xmlFreeDoc(schema->doc); | |
| if (schema->documents != NULL) | |
| xmlRelaxNGFreeDocumentList(schema->documents); | |
| if (schema->includes != NULL) | |
| xmlRelaxNGFreeIncludeList(schema->includes); | |
| if (schema->defTab != NULL) { | |
| int i; | |
| for (i = 0; i < schema->defNr; i++) | |
| xmlRelaxNGFreeDefine(schema->defTab[i]); | |
| xmlFree(schema->defTab); | |
| } | |
| xmlFree(schema); | |
| } | |
| /** | |
| * xmlRelaxNGNewGrammar: | |
| * @ctxt: a Relax-NG validation context (optional) | |
| * | |
| * Allocate a new RelaxNG grammar. | |
| * | |
| * Returns the newly allocated structure or NULL in case or error | |
| */ | |
| static xmlRelaxNGGrammarPtr | |
| xmlRelaxNGNewGrammar(xmlRelaxNGParserCtxtPtr ctxt) | |
| { | |
| xmlRelaxNGGrammarPtr ret; | |
| ret = (xmlRelaxNGGrammarPtr) xmlMalloc(sizeof(xmlRelaxNGGrammar)); | |
| if (ret == NULL) { | |
| xmlRngPErrMemory(ctxt, NULL); | |
| return (NULL); | |
| } | |
| memset(ret, 0, sizeof(xmlRelaxNGGrammar)); | |
| return (ret); | |
| } | |
| /** | |
| * xmlRelaxNGFreeGrammar: | |
| * @grammar: a grammar structure | |
| * | |
| * Deallocate a RelaxNG grammar structure. | |
| */ | |
| static void | |
| xmlRelaxNGFreeGrammar(xmlRelaxNGGrammarPtr grammar) | |
| { | |
| if (grammar == NULL) | |
| return; | |
| if (grammar->children != NULL) { | |
| xmlRelaxNGFreeGrammar(grammar->children); | |
| } | |
| if (grammar->next != NULL) { | |
| xmlRelaxNGFreeGrammar(grammar->next); | |
| } | |
| if (grammar->refs != NULL) { | |
| xmlHashFree(grammar->refs, NULL); | |
| } | |
| if (grammar->defs != NULL) { | |
| xmlHashFree(grammar->defs, NULL); | |
| } | |
| xmlFree(grammar); | |
| } | |
| /** | |
| * xmlRelaxNGNewDefine: | |
| * @ctxt: a Relax-NG validation context | |
| * @node: the node in the input document. | |
| * | |
| * Allocate a new RelaxNG define. | |
| * | |
| * Returns the newly allocated structure or NULL in case or error | |
| */ | |
| static xmlRelaxNGDefinePtr | |
| xmlRelaxNGNewDefine(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node) | |
| { | |
| xmlRelaxNGDefinePtr ret; | |
| if (ctxt->defMax == 0) { | |
| ctxt->defMax = 16; | |
| ctxt->defNr = 0; | |
| ctxt->defTab = (xmlRelaxNGDefinePtr *) | |
| xmlMalloc(ctxt->defMax * sizeof(xmlRelaxNGDefinePtr)); | |
| if (ctxt->defTab == NULL) { | |
| xmlRngPErrMemory(ctxt, "allocating define\n"); | |
| return (NULL); | |
| } | |
| } else if (ctxt->defMax <= ctxt->defNr) { | |
| xmlRelaxNGDefinePtr *tmp; | |
| ctxt->defMax *= 2; | |
| tmp = (xmlRelaxNGDefinePtr *) xmlRealloc(ctxt->defTab, | |
| ctxt->defMax * | |
| sizeof | |
| (xmlRelaxNGDefinePtr)); | |
| if (tmp == NULL) { | |
| xmlRngPErrMemory(ctxt, "allocating define\n"); | |
| return (NULL); | |
| } | |
| ctxt->defTab = tmp; | |
| } | |
| ret = (xmlRelaxNGDefinePtr) xmlMalloc(sizeof(xmlRelaxNGDefine)); | |
| if (ret == NULL) { | |
| xmlRngPErrMemory(ctxt, "allocating define\n"); | |
| return (NULL); | |
| } | |
| memset(ret, 0, sizeof(xmlRelaxNGDefine)); | |
| ctxt->defTab[ctxt->defNr++] = ret; | |
| ret->node = node; | |
| ret->depth = -1; | |
| return (ret); | |
| } | |
| /** | |
| * xmlRelaxNGFreePartition: | |
| * @partitions: a partition set structure | |
| * | |
| * Deallocate RelaxNG partition set structures. | |
| */ | |
| static void | |
| xmlRelaxNGFreePartition(xmlRelaxNGPartitionPtr partitions) | |
| { | |
| xmlRelaxNGInterleaveGroupPtr group; | |
| int j; | |
| if (partitions != NULL) { | |
| if (partitions->groups != NULL) { | |
| for (j = 0; j < partitions->nbgroups; j++) { | |
| group = partitions->groups[j]; | |
| if (group != NULL) { | |
| if (group->defs != NULL) | |
| xmlFree(group->defs); | |
| if (group->attrs != NULL) | |
| xmlFree(group->attrs); | |
| xmlFree(group); | |
| } | |
| } | |
| xmlFree(partitions->groups); | |
| } | |
| if (partitions->triage != NULL) { | |
| xmlHashFree(partitions->triage, NULL); | |
| } | |
| xmlFree(partitions); | |
| } | |
| } | |
| /** | |
| * xmlRelaxNGFreeDefine: | |
| * @define: a define structure | |
| * | |
| * Deallocate a RelaxNG define structure. | |
| */ | |
| static void | |
| xmlRelaxNGFreeDefine(xmlRelaxNGDefinePtr define) | |
| { | |
| if (define == NULL) | |
| return; | |
| if ((define->type == XML_RELAXNG_VALUE) && (define->attrs != NULL)) { | |
| xmlRelaxNGTypeLibraryPtr lib; | |
| lib = (xmlRelaxNGTypeLibraryPtr) define->data; | |
| if ((lib != NULL) && (lib->freef != NULL)) | |
| lib->freef(lib->data, (void *) define->attrs); | |
| } | |
| if ((define->data != NULL) && (define->type == XML_RELAXNG_INTERLEAVE)) | |
| xmlRelaxNGFreePartition((xmlRelaxNGPartitionPtr) define->data); | |
| if ((define->data != NULL) && (define->type == XML_RELAXNG_CHOICE)) | |
| xmlHashFree((xmlHashTablePtr) define->data, NULL); | |
| if (define->name != NULL) | |
| xmlFree(define->name); | |
| if (define->ns != NULL) | |
| xmlFree(define->ns); | |
| if (define->value != NULL) | |
| xmlFree(define->value); | |
| if (define->contModel != NULL) | |
| xmlRegFreeRegexp(define->contModel); | |
| xmlFree(define); | |
| } | |
| /** | |
| * xmlRelaxNGNewStates: | |
| * @ctxt: a Relax-NG validation context | |
| * @size: the default size for the container | |
| * | |
| * Allocate a new RelaxNG validation state container | |
| * | |
| * Returns the newly allocated structure or NULL in case or error | |
| */ | |
| static xmlRelaxNGStatesPtr | |
| xmlRelaxNGNewStates(xmlRelaxNGValidCtxtPtr ctxt, int size) | |
| { | |
| xmlRelaxNGStatesPtr ret; | |
| if ((ctxt != NULL) && | |
| (ctxt->freeStates != NULL) && (ctxt->freeStatesNr > 0)) { | |
| ctxt->freeStatesNr--; | |
| ret = ctxt->freeStates[ctxt->freeStatesNr]; | |
| ret->nbState = 0; | |
| return (ret); | |
| } | |
| if (size < 16) | |
| size = 16; | |
| ret = (xmlRelaxNGStatesPtr) xmlMalloc(sizeof(xmlRelaxNGStates) + | |
| (size - | |
| 1) * | |
| sizeof(xmlRelaxNGValidStatePtr)); | |
| if (ret == NULL) { | |
| xmlRngVErrMemory(ctxt, "allocating states\n"); | |
| return (NULL); | |
| } | |
| ret->nbState = 0; | |
| ret->maxState = size; | |
| ret->tabState = (xmlRelaxNGValidStatePtr *) xmlMalloc((size) * | |
| sizeof | |
| (xmlRelaxNGValidStatePtr)); | |
| if (ret->tabState == NULL) { | |
| xmlRngVErrMemory(ctxt, "allocating states\n"); | |
| xmlFree(ret); | |
| return (NULL); | |
| } | |
| return (ret); | |
| } | |
| /** | |
| * xmlRelaxNGAddStateUniq: | |
| * @ctxt: a Relax-NG validation context | |
| * @states: the states container | |
| * @state: the validation state | |
| * | |
| * Add a RelaxNG validation state to the container without checking | |
| * for unicity. | |
| * | |
| * Return 1 in case of success and 0 if this is a duplicate and -1 on error | |
| */ | |
| static int | |
| xmlRelaxNGAddStatesUniq(xmlRelaxNGValidCtxtPtr ctxt, | |
| xmlRelaxNGStatesPtr states, | |
| xmlRelaxNGValidStatePtr state) | |
| { | |
| if (state == NULL) { | |
| return (-1); | |
| } | |
| if (states->nbState >= states->maxState) { | |
| xmlRelaxNGValidStatePtr *tmp; | |
| int size; | |
| size = states->maxState * 2; | |
| tmp = (xmlRelaxNGValidStatePtr *) xmlRealloc(states->tabState, | |
| (size) * | |
| sizeof | |
| (xmlRelaxNGValidStatePtr)); | |
| if (tmp == NULL) { | |
| xmlRngVErrMemory(ctxt, "adding states\n"); | |
| return (-1); | |
| } | |
| states->tabState = tmp; | |
| states->maxState = size; | |
| } | |
| states->tabState[states->nbState++] = state; | |
| return (1); | |
| } | |
| /** | |
| * xmlRelaxNGAddState: | |
| * @ctxt: a Relax-NG validation context | |
| * @states: the states container | |
| * @state: the validation state | |
| * | |
| * Add a RelaxNG validation state to the container | |
| * | |
| * Return 1 in case of success and 0 if this is a duplicate and -1 on error | |
| */ | |
| static int | |
| xmlRelaxNGAddStates(xmlRelaxNGValidCtxtPtr ctxt, | |
| xmlRelaxNGStatesPtr states, | |
| xmlRelaxNGValidStatePtr state) | |
| { | |
| int i; | |
| if (state == NULL || states == NULL) { | |
| return (-1); | |
| } | |
| if (states->nbState >= states->maxState) { | |
| xmlRelaxNGValidStatePtr *tmp; | |
| int size; | |
| size = states->maxState * 2; | |
| tmp = (xmlRelaxNGValidStatePtr *) xmlRealloc(states->tabState, | |
| (size) * | |
| sizeof | |
| (xmlRelaxNGValidStatePtr)); | |
| if (tmp == NULL) { | |
| xmlRngVErrMemory(ctxt, "adding states\n"); | |
| return (-1); | |
| } | |
| states->tabState = tmp; | |
| states->maxState = size; | |
| } | |
| for (i = 0; i < states->nbState; i++) { | |
| if (xmlRelaxNGEqualValidState(ctxt, state, states->tabState[i])) { | |
| xmlRelaxNGFreeValidState(ctxt, state); | |
| return (0); | |
| } | |
| } | |
| states->tabState[states->nbState++] = state; | |
| return (1); | |
| } | |
| /** | |
| * xmlRelaxNGFreeStates: | |
| * @ctxt: a Relax-NG validation context | |
| * @states: teh container | |
| * | |
| * Free a RelaxNG validation state container | |
| */ | |
| static void | |
| xmlRelaxNGFreeStates(xmlRelaxNGValidCtxtPtr ctxt, | |
| xmlRelaxNGStatesPtr states) | |
| { | |
| if (states == NULL) | |
| return; | |
| if ((ctxt != NULL) && (ctxt->freeStates == NULL)) { | |
| ctxt->freeStatesMax = 40; | |
| ctxt->freeStatesNr = 0; | |
| ctxt->freeStates = (xmlRelaxNGStatesPtr *) | |
| xmlMalloc(ctxt->freeStatesMax * sizeof(xmlRelaxNGStatesPtr)); | |
| if (ctxt->freeStates == NULL) { | |
| xmlRngVErrMemory(ctxt, "storing states\n"); | |
| } | |
| } else if ((ctxt != NULL) | |
| && (ctxt->freeStatesNr >= ctxt->freeStatesMax)) { | |
| xmlRelaxNGStatesPtr *tmp; | |
| tmp = (xmlRelaxNGStatesPtr *) xmlRealloc(ctxt->freeStates, | |
| 2 * ctxt->freeStatesMax * | |
| sizeof | |
| (xmlRelaxNGStatesPtr)); | |
| if (tmp == NULL) { | |
| xmlRngVErrMemory(ctxt, "storing states\n"); | |
| xmlFree(states->tabState); | |
| xmlFree(states); | |
| return; | |
| } | |
| ctxt->freeStates = tmp; | |
| ctxt->freeStatesMax *= 2; | |
| } | |
| if ((ctxt == NULL) || (ctxt->freeStates == NULL)) { | |
| xmlFree(states->tabState); | |
| xmlFree(states); | |
| } else { | |
| ctxt->freeStates[ctxt->freeStatesNr++] = states; | |
| } | |
| } | |
| /** | |
| * xmlRelaxNGNewValidState: | |
| * @ctxt: a Relax-NG validation context | |
| * @node: the current node or NULL for the document | |
| * | |
| * Allocate a new RelaxNG validation state | |
| * | |
| * Returns the newly allocated structure or NULL in case or error | |
| */ | |
| static xmlRelaxNGValidStatePtr | |
| xmlRelaxNGNewValidState(xmlRelaxNGValidCtxtPtr ctxt, xmlNodePtr node) | |
| { | |
| xmlRelaxNGValidStatePtr ret; | |
| xmlAttrPtr attr; | |
| xmlAttrPtr attrs[MAX_ATTR]; | |
| int nbAttrs = 0; | |
| xmlNodePtr root = NULL; | |
| if (node == NULL) { | |
| root = xmlDocGetRootElement(ctxt->doc); | |
| if (root == NULL) | |
| return (NULL); | |
| } else { | |
| attr = node->properties; | |
| while (attr != NULL) { | |
| if (nbAttrs < MAX_ATTR) | |
| attrs[nbAttrs++] = attr; | |
| else | |
| nbAttrs++; | |
| attr = attr->next; | |
| } | |
| } | |
| if ((ctxt->freeState != NULL) && (ctxt->freeState->nbState > 0)) { | |
| ctxt->freeState->nbState--; | |
| ret = ctxt->freeState->tabState[ctxt->freeState->nbState]; | |
| } else { | |
| ret = | |
| (xmlRelaxNGValidStatePtr) | |
| xmlMalloc(sizeof(xmlRelaxNGValidState)); | |
| if (ret == NULL) { | |
| xmlRngVErrMemory(ctxt, "allocating states\n"); | |
| return (NULL); | |
| } | |
| memset(ret, 0, sizeof(xmlRelaxNGValidState)); | |
| } | |
| ret->value = NULL; | |
| ret->endvalue = NULL; | |
| if (node == NULL) { | |
| ret->node = (xmlNodePtr) ctxt->doc; | |
| ret->seq = root; | |
| } else { | |
| ret->node = node; | |
| ret->seq = node->children; | |
| } | |
| ret->nbAttrs = 0; | |
| if (nbAttrs > 0) { | |
| if (ret->attrs == NULL) { | |
| if (nbAttrs < 4) | |
| ret->maxAttrs = 4; | |
| else | |
| ret->maxAttrs = nbAttrs; | |
| ret->attrs = (xmlAttrPtr *) xmlMalloc(ret->maxAttrs * | |
| sizeof(xmlAttrPtr)); | |
| if (ret->attrs == NULL) { | |
| xmlRngVErrMemory(ctxt, "allocating states\n"); | |
| return (ret); | |
| } | |
| } else if (ret->maxAttrs < nbAttrs) { | |
| xmlAttrPtr *tmp; | |
| tmp = (xmlAttrPtr *) xmlRealloc(ret->attrs, nbAttrs * | |
| sizeof(xmlAttrPtr)); | |
| if (tmp == NULL) { | |
| xmlRngVErrMemory(ctxt, "allocating states\n"); | |
| return (ret); | |
| } | |
| ret->attrs = tmp; | |
| ret->maxAttrs = nbAttrs; | |
| } | |
| ret->nbAttrs = nbAttrs; | |
| if (nbAttrs < MAX_ATTR) { | |
| memcpy(ret->attrs, attrs, sizeof(xmlAttrPtr) * nbAttrs); | |
| } else { | |
| attr = node->properties; | |
| nbAttrs = 0; | |
| while (attr != NULL) { | |
| ret->attrs[nbAttrs++] = attr; | |
| attr = attr->next; | |
| } | |
| } | |
| } | |
| ret->nbAttrLeft = ret->nbAttrs; | |
| return (ret); | |
| } | |
| /** | |
| * xmlRelaxNGCopyValidState: | |
| * @ctxt: a Relax-NG validation context | |
| * @state: a validation state | |
| * | |
| * Copy the validation state | |
| * | |
| * Returns the newly allocated structure or NULL in case or error | |
| */ | |
| static xmlRelaxNGValidStatePtr | |
| xmlRelaxNGCopyValidState(xmlRelaxNGValidCtxtPtr ctxt, | |
| xmlRelaxNGValidStatePtr state) | |
| { | |
| xmlRelaxNGValidStatePtr ret; | |
| unsigned int maxAttrs; | |
| xmlAttrPtr *attrs; | |
| if (state == NULL) | |
| return (NULL); | |
| if ((ctxt->freeState != NULL) && (ctxt->freeState->nbState > 0)) { | |
| ctxt->freeState->nbState--; | |
| ret = ctxt->freeState->tabState[ctxt->freeState->nbState]; | |
| } else { | |
| ret = | |
| (xmlRelaxNGValidStatePtr) | |
| xmlMalloc(sizeof(xmlRelaxNGValidState)); | |
| if (ret == NULL) { | |
| xmlRngVErrMemory(ctxt, "allocating states\n"); | |
| return (NULL); | |
| } | |
| memset(ret, 0, sizeof(xmlRelaxNGValidState)); | |
| } | |
| attrs = ret->attrs; | |
| maxAttrs = ret->maxAttrs; | |
| memcpy(ret, state, sizeof(xmlRelaxNGValidState)); | |
| ret->attrs = attrs; | |
| ret->maxAttrs = maxAttrs; | |
| if (state->nbAttrs > 0) { | |
| if (ret->attrs == NULL) { | |
| ret->maxAttrs = state->maxAttrs; | |
| ret->attrs = (xmlAttrPtr *) xmlMalloc(ret->maxAttrs * | |
| sizeof(xmlAttrPtr)); | |
| if (ret->attrs == NULL) { | |
| xmlRngVErrMemory(ctxt, "allocating states\n"); | |
| ret->nbAttrs = 0; | |
| return (ret); | |
| } | |
| } else if (ret->maxAttrs < state->nbAttrs) { | |
| xmlAttrPtr *tmp; | |
| tmp = (xmlAttrPtr *) xmlRealloc(ret->attrs, state->maxAttrs * | |
| sizeof(xmlAttrPtr)); | |
| if (tmp == NULL) { | |
| xmlRngVErrMemory(ctxt, "allocating states\n"); | |
| ret->nbAttrs = 0; | |
| return (ret); | |
| } | |
| ret->maxAttrs = state->maxAttrs; | |
| ret->attrs = tmp; | |
| } | |
| memcpy(ret->attrs, state->attrs, | |
| state->nbAttrs * sizeof(xmlAttrPtr)); | |
| } | |
| return (ret); | |
| } | |
| /** | |
| * xmlRelaxNGEqualValidState: | |
| * @ctxt: a Relax-NG validation context | |
| * @state1: a validation state | |
| * @state2: a validation state | |
| * | |
| * Compare the validation states for equality | |
| * | |
| * Returns 1 if equald, 0 otherwise | |
| */ | |
| static int | |
| xmlRelaxNGEqualValidState(xmlRelaxNGValidCtxtPtr ctxt ATTRIBUTE_UNUSED, | |
| xmlRelaxNGValidStatePtr state1, | |
| xmlRelaxNGValidStatePtr state2) | |
| { | |
| int i; | |
| if ((state1 == NULL) || (state2 == NULL)) | |
| return (0); | |
| if (state1 == state2) | |
| return (1); | |
| if (state1->node != state2->node) | |
| return (0); | |
| if (state1->seq != state2->seq) | |
| return (0); | |
| if (state1->nbAttrLeft != state2->nbAttrLeft) | |
| return (0); | |
| if (state1->nbAttrs != state2->nbAttrs) | |
| return (0); | |
| if (state1->endvalue != state2->endvalue) | |
| return (0); | |
| if ((state1->value != state2->value) && | |
| (!xmlStrEqual(state1->value, state2->value))) | |
| return (0); | |
| for (i = 0; i < state1->nbAttrs; i++) { | |
| if (state1->attrs[i] != state2->attrs[i]) | |
| return (0); | |
| } | |
| return (1); | |
| } | |
| /** | |
| * xmlRelaxNGFreeValidState: | |
| * @state: a validation state structure | |
| * | |
| * Deallocate a RelaxNG validation state structure. | |
| */ | |
| static void | |
| xmlRelaxNGFreeValidState(xmlRelaxNGValidCtxtPtr ctxt, | |
| xmlRelaxNGValidStatePtr state) | |
| { | |
| if (state == NULL) | |
| return; | |
| if ((ctxt != NULL) && (ctxt->freeState == NULL)) { | |
| ctxt->freeState = xmlRelaxNGNewStates(ctxt, 40); | |
| } | |
| if ((ctxt == NULL) || (ctxt->freeState == NULL)) { | |
| if (state->attrs != NULL) | |
| xmlFree(state->attrs); | |
| xmlFree(state); | |
| } else { | |
| xmlRelaxNGAddStatesUniq(ctxt, ctxt->freeState, state); | |
| } | |
| } | |
| /************************************************************************ | |
| * * | |
| * Semi internal functions * | |
| * * | |
| ************************************************************************/ | |
| /** | |
| * xmlRelaxParserSetFlag: | |
| * @ctxt: a RelaxNG parser context | |
| * @flags: a set of flags values | |
| * | |
| * Semi private function used to pass informations to a parser context | |
| * which are a combination of xmlRelaxNGParserFlag . | |
| * | |
| * Returns 0 if success and -1 in case of error | |
| */ | |
| int | |
| xmlRelaxParserSetFlag(xmlRelaxNGParserCtxtPtr ctxt, int flags) | |
| { | |
| if (ctxt == NULL) return(-1); | |
| if (flags & XML_RELAXNGP_FREE_DOC) { | |
| ctxt->crng |= XML_RELAXNGP_FREE_DOC; | |
| flags -= XML_RELAXNGP_FREE_DOC; | |
| } | |
| if (flags & XML_RELAXNGP_CRNG) { | |
| ctxt->crng |= XML_RELAXNGP_CRNG; | |
| flags -= XML_RELAXNGP_CRNG; | |
| } | |
| if (flags != 0) return(-1); | |
| return(0); | |
| } | |
| /************************************************************************ | |
| * * | |
| * Document functions * | |
| * * | |
| ************************************************************************/ | |
| static xmlDocPtr xmlRelaxNGCleanupDoc(xmlRelaxNGParserCtxtPtr ctxt, | |
| xmlDocPtr doc); | |
| /** | |
| * xmlRelaxNGIncludePush: | |
| * @ctxt: the parser context | |
| * @value: the element doc | |
| * | |
| * Pushes a new include on top of the include stack | |
| * | |
| * Returns 0 in case of error, the index in the stack otherwise | |
| */ | |
| static int | |
| xmlRelaxNGIncludePush(xmlRelaxNGParserCtxtPtr ctxt, | |
| xmlRelaxNGIncludePtr value) | |
| { | |
| if (ctxt->incTab == NULL) { | |
| ctxt->incMax = 4; | |
| ctxt->incNr = 0; | |
| ctxt->incTab = | |
| (xmlRelaxNGIncludePtr *) xmlMalloc(ctxt->incMax * | |
| sizeof(ctxt->incTab[0])); | |
| if (ctxt->incTab == NULL) { | |
| xmlRngPErrMemory(ctxt, "allocating include\n"); | |
| return (0); | |
| } | |
| } | |
| if (ctxt->incNr >= ctxt->incMax) { | |
| ctxt->incMax *= 2; | |
| ctxt->incTab = | |
| (xmlRelaxNGIncludePtr *) xmlRealloc(ctxt->incTab, | |
| ctxt->incMax * | |
| sizeof(ctxt->incTab[0])); | |
| if (ctxt->incTab == NULL) { | |
| xmlRngPErrMemory(ctxt, "allocating include\n"); | |
| return (0); | |
| } | |
| } | |
| ctxt->incTab[ctxt->incNr] = value; | |
| ctxt->inc = value; | |
| return (ctxt->incNr++); | |
| } | |
| /** | |
| * xmlRelaxNGIncludePop: | |
| * @ctxt: the parser context | |
| * | |
| * Pops the top include from the include stack | |
| * | |
| * Returns the include just removed | |
| */ | |
| static xmlRelaxNGIncludePtr | |
| xmlRelaxNGIncludePop(xmlRelaxNGParserCtxtPtr ctxt) | |
| { | |
| xmlRelaxNGIncludePtr ret; | |
| if (ctxt->incNr <= 0) | |
| return (NULL); | |
| ctxt->incNr--; | |
| if (ctxt->incNr > 0) | |
| ctxt->inc = ctxt->incTab[ctxt->incNr - 1]; | |
| else | |
| ctxt->inc = NULL; | |
| ret = ctxt->incTab[ctxt->incNr]; | |
| ctxt->incTab[ctxt->incNr] = NULL; | |
| return (ret); | |
| } | |
| /** | |
| * xmlRelaxNGRemoveRedefine: | |
| * @ctxt: the parser context | |
| * @URL: the normalized URL | |
| * @target: the included target | |
| * @name: the define name to eliminate | |
| * | |
| * Applies the elimination algorithm of 4.7 | |
| * | |
| * Returns 0 in case of error, 1 in case of success. | |
| */ | |
| static int | |
| xmlRelaxNGRemoveRedefine(xmlRelaxNGParserCtxtPtr ctxt, | |
| const xmlChar * URL ATTRIBUTE_UNUSED, | |
| xmlNodePtr target, const xmlChar * name) | |
| { | |
| int found = 0; | |
| xmlNodePtr tmp, tmp2; | |
| xmlChar *name2; | |
| #ifdef DEBUG_INCLUDE | |
| if (name == NULL) | |
| xmlGenericError(xmlGenericErrorContext, | |
| "Elimination of <include> start from %s\n", URL); | |
| else | |
| xmlGenericError(xmlGenericErrorContext, | |
| "Elimination of <include> define %s from %s\n", | |
| name, URL); | |
| #endif | |
| tmp = target; | |
| while (tmp != NULL) { | |
| tmp2 = tmp->next; | |
| if ((name == NULL) && (IS_RELAXNG(tmp, "start"))) { | |
| found = 1; | |
| xmlUnlinkNode(tmp); | |
| xmlFreeNode(tmp); | |
| } else if ((name != NULL) && (IS_RELAXNG(tmp, "define"))) { | |
| name2 = xmlGetProp(tmp, BAD_CAST "name"); | |
| xmlRelaxNGNormExtSpace(name2); | |
| if (name2 != NULL) { | |
| if (xmlStrEqual(name, name2)) { | |
| found = 1; | |
| xmlUnlinkNode(tmp); | |
| xmlFreeNode(tmp); | |
| } | |
| xmlFree(name2); | |
| } | |
| } else if (IS_RELAXNG(tmp, "include")) { | |
| xmlChar *href = NULL; | |
| xmlRelaxNGDocumentPtr inc = tmp->psvi; | |
| if ((inc != NULL) && (inc->doc != NULL) && | |
| (inc->doc->children != NULL)) { | |
| if (xmlStrEqual | |
| (inc->doc->children->name, BAD_CAST "grammar")) { | |
| #ifdef DEBUG_INCLUDE | |
| href = xmlGetProp(tmp, BAD_CAST "href"); | |
| #endif | |
| if (xmlRelaxNGRemoveRedefine(ctxt, href, | |
| xmlDocGetRootElement(inc->doc)->children, | |
| name) == 1) { | |
| found = 1; | |
| } | |
| #ifdef DEBUG_INCLUDE | |
| if (href != NULL) | |
| xmlFree(href); | |
| #endif | |
| } | |
| } | |
| } | |
| tmp = tmp2; | |
| } | |
| return (found); | |
| } | |
| /** | |
| * xmlRelaxNGLoadInclude: | |
| * @ctxt: the parser context | |
| * @URL: the normalized URL | |
| * @node: the include node. | |
| * @ns: the namespace passed from the context. | |
| * | |
| * First lookup if the document is already loaded into the parser context, | |
| * check against recursion. If not found the resource is loaded and | |
| * the content is preprocessed before being returned back to the caller. | |
| * | |
| * Returns the xmlRelaxNGIncludePtr or NULL in case of error | |
| */ | |
| static xmlRelaxNGIncludePtr | |
| xmlRelaxNGLoadInclude(xmlRelaxNGParserCtxtPtr ctxt, const xmlChar * URL, | |
| xmlNodePtr node, const xmlChar * ns) | |
| { | |
| xmlRelaxNGIncludePtr ret = NULL; | |
| xmlDocPtr doc; | |
| int i; | |
| xmlNodePtr root, cur; | |
| #ifdef DEBUG_INCLUDE | |
| xmlGenericError(xmlGenericErrorContext, | |
| "xmlRelaxNGLoadInclude(%s)\n", URL); | |
| #endif | |
| /* | |
| * check against recursion in the stack | |
| */ | |
| for (i = 0; i < ctxt->incNr; i++) { | |
| if (xmlStrEqual(ctxt->incTab[i]->href, URL)) { | |
| xmlRngPErr(ctxt, NULL, XML_RNGP_INCLUDE_RECURSE, | |
| "Detected an Include recursion for %s\n", URL, | |
| NULL); | |
| return (NULL); | |
| } | |
| } | |
| /* | |
| * load the document | |
| */ | |
| doc = xmlReadFile((const char *) URL,NULL,0); | |
| if (doc == NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_PARSE_ERROR, | |
| "xmlRelaxNG: could not load %s\n", URL, NULL); | |
| return (NULL); | |
| } | |
| #ifdef DEBUG_INCLUDE | |
| xmlGenericError(xmlGenericErrorContext, "Parsed %s Okay\n", URL); | |
| #endif | |
| /* | |
| * Allocate the document structures and register it first. | |
| */ | |
| ret = (xmlRelaxNGIncludePtr) xmlMalloc(sizeof(xmlRelaxNGInclude)); | |
| if (ret == NULL) { | |
| xmlRngPErrMemory(ctxt, "allocating include\n"); | |
| xmlFreeDoc(doc); | |
| return (NULL); | |
| } | |
| memset(ret, 0, sizeof(xmlRelaxNGInclude)); | |
| ret->doc = doc; | |
| ret->href = xmlStrdup(URL); | |
| ret->next = ctxt->includes; | |
| ctxt->includes = ret; | |
| /* | |
| * transmit the ns if needed | |
| */ | |
| if (ns != NULL) { | |
| root = xmlDocGetRootElement(doc); | |
| if (root != NULL) { | |
| if (xmlHasProp(root, BAD_CAST "ns") == NULL) { | |
| xmlSetProp(root, BAD_CAST "ns", ns); | |
| } | |
| } | |
| } | |
| /* | |
| * push it on the stack | |
| */ | |
| xmlRelaxNGIncludePush(ctxt, ret); | |
| /* | |
| * Some preprocessing of the document content, this include recursing | |
| * in the include stack. | |
| */ | |
| #ifdef DEBUG_INCLUDE | |
| xmlGenericError(xmlGenericErrorContext, "cleanup of %s\n", URL); | |
| #endif | |
| doc = xmlRelaxNGCleanupDoc(ctxt, doc); | |
| if (doc == NULL) { | |
| ctxt->inc = NULL; | |
| return (NULL); | |
| } | |
| /* | |
| * Pop up the include from the stack | |
| */ | |
| xmlRelaxNGIncludePop(ctxt); | |
| #ifdef DEBUG_INCLUDE | |
| xmlGenericError(xmlGenericErrorContext, "Checking of %s\n", URL); | |
| #endif | |
| /* | |
| * Check that the top element is a grammar | |
| */ | |
| root = xmlDocGetRootElement(doc); | |
| if (root == NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_EMPTY, | |
| "xmlRelaxNG: included document is empty %s\n", URL, | |
| NULL); | |
| return (NULL); | |
| } | |
| if (!IS_RELAXNG(root, "grammar")) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_GRAMMAR_MISSING, | |
| "xmlRelaxNG: included document %s root is not a grammar\n", | |
| URL, NULL); | |
| return (NULL); | |
| } | |
| /* | |
| * Elimination of redefined rules in the include. | |
| */ | |
| cur = node->children; | |
| while (cur != NULL) { | |
| if (IS_RELAXNG(cur, "start")) { | |
| int found = 0; | |
| found = | |
| xmlRelaxNGRemoveRedefine(ctxt, URL, root->children, NULL); | |
| if (!found) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_START_MISSING, | |
| "xmlRelaxNG: include %s has a start but not the included grammar\n", | |
| URL, NULL); | |
| } | |
| } else if (IS_RELAXNG(cur, "define")) { | |
| xmlChar *name; | |
| name = xmlGetProp(cur, BAD_CAST "name"); | |
| if (name == NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_NAME_MISSING, | |
| "xmlRelaxNG: include %s has define without name\n", | |
| URL, NULL); | |
| } else { | |
| int found; | |
| xmlRelaxNGNormExtSpace(name); | |
| found = xmlRelaxNGRemoveRedefine(ctxt, URL, | |
| root->children, name); | |
| if (!found) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_MISSING, | |
| "xmlRelaxNG: include %s has a define %s but not the included grammar\n", | |
| URL, name); | |
| } | |
| xmlFree(name); | |
| } | |
| } | |
| cur = cur->next; | |
| } | |
| return (ret); | |
| } | |
| /** | |
| * xmlRelaxNGValidErrorPush: | |
| * @ctxt: the validation context | |
| * @err: the error code | |
| * @arg1: the first string argument | |
| * @arg2: the second string argument | |
| * @dup: arg need to be duplicated | |
| * | |
| * Pushes a new error on top of the error stack | |
| * | |
| * Returns 0 in case of error, the index in the stack otherwise | |
| */ | |
| static int | |
| xmlRelaxNGValidErrorPush(xmlRelaxNGValidCtxtPtr ctxt, | |
| xmlRelaxNGValidErr err, const xmlChar * arg1, | |
| const xmlChar * arg2, int dup) | |
| { | |
| xmlRelaxNGValidErrorPtr cur; | |
| #ifdef DEBUG_ERROR | |
| xmlGenericError(xmlGenericErrorContext, | |
| "Pushing error %d at %d on stack\n", err, ctxt->errNr); | |
| #endif | |
| if (ctxt->errTab == NULL) { | |
| ctxt->errMax = 8; | |
| ctxt->errNr = 0; | |
| ctxt->errTab = | |
| (xmlRelaxNGValidErrorPtr) xmlMalloc(ctxt->errMax * | |
| sizeof | |
| (xmlRelaxNGValidError)); | |
| if (ctxt->errTab == NULL) { | |
| xmlRngVErrMemory(ctxt, "pushing error\n"); | |
| return (0); | |
| } | |
| ctxt->err = NULL; | |
| } | |
| if (ctxt->errNr >= ctxt->errMax) { | |
| ctxt->errMax *= 2; | |
| ctxt->errTab = | |
| (xmlRelaxNGValidErrorPtr) xmlRealloc(ctxt->errTab, | |
| ctxt->errMax * | |
| sizeof | |
| (xmlRelaxNGValidError)); | |
| if (ctxt->errTab == NULL) { | |
| xmlRngVErrMemory(ctxt, "pushing error\n"); | |
| return (0); | |
| } | |
| ctxt->err = &ctxt->errTab[ctxt->errNr - 1]; | |
| } | |
| if ((ctxt->err != NULL) && (ctxt->state != NULL) && | |
| (ctxt->err->node == ctxt->state->node) && (ctxt->err->err == err)) | |
| return (ctxt->errNr); | |
| cur = &ctxt->errTab[ctxt->errNr]; | |
| cur->err = err; | |
| if (dup) { | |
| cur->arg1 = xmlStrdup(arg1); | |
| cur->arg2 = xmlStrdup(arg2); | |
| cur->flags = ERROR_IS_DUP; | |
| } else { | |
| cur->arg1 = arg1; | |
| cur->arg2 = arg2; | |
| cur->flags = 0; | |
| } | |
| if (ctxt->state != NULL) { | |
| cur->node = ctxt->state->node; | |
| cur->seq = ctxt->state->seq; | |
| } else { | |
| cur->node = NULL; | |
| cur->seq = NULL; | |
| } | |
| ctxt->err = cur; | |
| return (ctxt->errNr++); | |
| } | |
| /** | |
| * xmlRelaxNGValidErrorPop: | |
| * @ctxt: the validation context | |
| * | |
| * Pops the top error from the error stack | |
| */ | |
| static void | |
| xmlRelaxNGValidErrorPop(xmlRelaxNGValidCtxtPtr ctxt) | |
| { | |
| xmlRelaxNGValidErrorPtr cur; | |
| if (ctxt->errNr <= 0) { | |
| ctxt->err = NULL; | |
| return; | |
| } | |
| ctxt->errNr--; | |
| if (ctxt->errNr > 0) | |
| ctxt->err = &ctxt->errTab[ctxt->errNr - 1]; | |
| else | |
| ctxt->err = NULL; | |
| cur = &ctxt->errTab[ctxt->errNr]; | |
| if (cur->flags & ERROR_IS_DUP) { | |
| if (cur->arg1 != NULL) | |
| xmlFree((xmlChar *) cur->arg1); | |
| cur->arg1 = NULL; | |
| if (cur->arg2 != NULL) | |
| xmlFree((xmlChar *) cur->arg2); | |
| cur->arg2 = NULL; | |
| cur->flags = 0; | |
| } | |
| } | |
| /** | |
| * xmlRelaxNGDocumentPush: | |
| * @ctxt: the parser context | |
| * @value: the element doc | |
| * | |
| * Pushes a new doc on top of the doc stack | |
| * | |
| * Returns 0 in case of error, the index in the stack otherwise | |
| */ | |
| static int | |
| xmlRelaxNGDocumentPush(xmlRelaxNGParserCtxtPtr ctxt, | |
| xmlRelaxNGDocumentPtr value) | |
| { | |
| if (ctxt->docTab == NULL) { | |
| ctxt->docMax = 4; | |
| ctxt->docNr = 0; | |
| ctxt->docTab = | |
| (xmlRelaxNGDocumentPtr *) xmlMalloc(ctxt->docMax * | |
| sizeof(ctxt->docTab[0])); | |
| if (ctxt->docTab == NULL) { | |
| xmlRngPErrMemory(ctxt, "adding document\n"); | |
| return (0); | |
| } | |
| } | |
| if (ctxt->docNr >= ctxt->docMax) { | |
| ctxt->docMax *= 2; | |
| ctxt->docTab = | |
| (xmlRelaxNGDocumentPtr *) xmlRealloc(ctxt->docTab, | |
| ctxt->docMax * | |
| sizeof(ctxt->docTab[0])); | |
| if (ctxt->docTab == NULL) { | |
| xmlRngPErrMemory(ctxt, "adding document\n"); | |
| return (0); | |
| } | |
| } | |
| ctxt->docTab[ctxt->docNr] = value; | |
| ctxt->doc = value; | |
| return (ctxt->docNr++); | |
| } | |
| /** | |
| * xmlRelaxNGDocumentPop: | |
| * @ctxt: the parser context | |
| * | |
| * Pops the top doc from the doc stack | |
| * | |
| * Returns the doc just removed | |
| */ | |
| static xmlRelaxNGDocumentPtr | |
| xmlRelaxNGDocumentPop(xmlRelaxNGParserCtxtPtr ctxt) | |
| { | |
| xmlRelaxNGDocumentPtr ret; | |
| if (ctxt->docNr <= 0) | |
| return (NULL); | |
| ctxt->docNr--; | |
| if (ctxt->docNr > 0) | |
| ctxt->doc = ctxt->docTab[ctxt->docNr - 1]; | |
| else | |
| ctxt->doc = NULL; | |
| ret = ctxt->docTab[ctxt->docNr]; | |
| ctxt->docTab[ctxt->docNr] = NULL; | |
| return (ret); | |
| } | |
| /** | |
| * xmlRelaxNGLoadExternalRef: | |
| * @ctxt: the parser context | |
| * @URL: the normalized URL | |
| * @ns: the inherited ns if any | |
| * | |
| * First lookup if the document is already loaded into the parser context, | |
| * check against recursion. If not found the resource is loaded and | |
| * the content is preprocessed before being returned back to the caller. | |
| * | |
| * Returns the xmlRelaxNGDocumentPtr or NULL in case of error | |
| */ | |
| static xmlRelaxNGDocumentPtr | |
| xmlRelaxNGLoadExternalRef(xmlRelaxNGParserCtxtPtr ctxt, | |
| const xmlChar * URL, const xmlChar * ns) | |
| { | |
| xmlRelaxNGDocumentPtr ret = NULL; | |
| xmlDocPtr doc; | |
| xmlNodePtr root; | |
| int i; | |
| /* | |
| * check against recursion in the stack | |
| */ | |
| for (i = 0; i < ctxt->docNr; i++) { | |
| if (xmlStrEqual(ctxt->docTab[i]->href, URL)) { | |
| xmlRngPErr(ctxt, NULL, XML_RNGP_EXTERNALREF_RECURSE, | |
| "Detected an externalRef recursion for %s\n", URL, | |
| NULL); | |
| return (NULL); | |
| } | |
| } | |
| /* | |
| * load the document | |
| */ | |
| doc = xmlReadFile((const char *) URL,NULL,0); | |
| if (doc == NULL) { | |
| xmlRngPErr(ctxt, NULL, XML_RNGP_PARSE_ERROR, | |
| "xmlRelaxNG: could not load %s\n", URL, NULL); | |
| return (NULL); | |
| } | |
| /* | |
| * Allocate the document structures and register it first. | |
| */ | |
| ret = (xmlRelaxNGDocumentPtr) xmlMalloc(sizeof(xmlRelaxNGDocument)); | |
| if (ret == NULL) { | |
| xmlRngPErr(ctxt, (xmlNodePtr) doc, XML_ERR_NO_MEMORY, | |
| "xmlRelaxNG: allocate memory for doc %s\n", URL, NULL); | |
| xmlFreeDoc(doc); | |
| return (NULL); | |
| } | |
| memset(ret, 0, sizeof(xmlRelaxNGDocument)); | |
| ret->doc = doc; | |
| ret->href = xmlStrdup(URL); | |
| ret->next = ctxt->documents; | |
| ret->externalRef = 1; | |
| ctxt->documents = ret; | |
| /* | |
| * transmit the ns if needed | |
| */ | |
| if (ns != NULL) { | |
| root = xmlDocGetRootElement(doc); | |
| if (root != NULL) { | |
| if (xmlHasProp(root, BAD_CAST "ns") == NULL) { | |
| xmlSetProp(root, BAD_CAST "ns", ns); | |
| } | |
| } | |
| } | |
| /* | |
| * push it on the stack and register it in the hash table | |
| */ | |
| xmlRelaxNGDocumentPush(ctxt, ret); | |
| /* | |
| * Some preprocessing of the document content | |
| */ | |
| doc = xmlRelaxNGCleanupDoc(ctxt, doc); | |
| if (doc == NULL) { | |
| ctxt->doc = NULL; | |
| return (NULL); | |
| } | |
| xmlRelaxNGDocumentPop(ctxt); | |
| return (ret); | |
| } | |
| /************************************************************************ | |
| * * | |
| * Error functions * | |
| * * | |
| ************************************************************************/ | |
| #define VALID_ERR(a) xmlRelaxNGAddValidError(ctxt, a, NULL, NULL, 0); | |
| #define VALID_ERR2(a, b) xmlRelaxNGAddValidError(ctxt, a, b, NULL, 0); | |
| #define VALID_ERR3(a, b, c) xmlRelaxNGAddValidError(ctxt, a, b, c, 0); | |
| #define VALID_ERR2P(a, b) xmlRelaxNGAddValidError(ctxt, a, b, NULL, 1); | |
| #define VALID_ERR3P(a, b, c) xmlRelaxNGAddValidError(ctxt, a, b, c, 1); | |
| static const char * | |
| xmlRelaxNGDefName(xmlRelaxNGDefinePtr def) | |
| { | |
| if (def == NULL) | |
| return ("none"); | |
| switch (def->type) { | |
| case XML_RELAXNG_EMPTY: | |
| return ("empty"); | |
| case XML_RELAXNG_NOT_ALLOWED: | |
| return ("notAllowed"); | |
| case XML_RELAXNG_EXCEPT: | |
| return ("except"); | |
| case XML_RELAXNG_TEXT: | |
| return ("text"); | |
| case XML_RELAXNG_ELEMENT: | |
| return ("element"); | |
| case XML_RELAXNG_DATATYPE: | |
| return ("datatype"); | |
| case XML_RELAXNG_VALUE: | |
| return ("value"); | |
| case XML_RELAXNG_LIST: | |
| return ("list"); | |
| case XML_RELAXNG_ATTRIBUTE: | |
| return ("attribute"); | |
| case XML_RELAXNG_DEF: | |
| return ("def"); | |
| case XML_RELAXNG_REF: | |
| return ("ref"); | |
| case XML_RELAXNG_EXTERNALREF: | |
| return ("externalRef"); | |
| case XML_RELAXNG_PARENTREF: | |
| return ("parentRef"); | |
| case XML_RELAXNG_OPTIONAL: | |
| return ("optional"); | |
| case XML_RELAXNG_ZEROORMORE: | |
| return ("zeroOrMore"); | |
| case XML_RELAXNG_ONEORMORE: | |
| return ("oneOrMore"); | |
| case XML_RELAXNG_CHOICE: | |
| return ("choice"); | |
| case XML_RELAXNG_GROUP: | |
| return ("group"); | |
| case XML_RELAXNG_INTERLEAVE: | |
| return ("interleave"); | |
| case XML_RELAXNG_START: | |
| return ("start"); | |
| case XML_RELAXNG_NOOP: | |
| return ("noop"); | |
| case XML_RELAXNG_PARAM: | |
| return ("param"); | |
| } | |
| return ("unknown"); | |
| } | |
| /** | |
| * xmlRelaxNGGetErrorString: | |
| * @err: the error code | |
| * @arg1: the first string argument | |
| * @arg2: the second string argument | |
| * | |
| * computes a formatted error string for the given error code and args | |
| * | |
| * Returns the error string, it must be deallocated by the caller | |
| */ | |
| static xmlChar * | |
| xmlRelaxNGGetErrorString(xmlRelaxNGValidErr err, const xmlChar * arg1, | |
| const xmlChar * arg2) | |
| { | |
| char msg[1000]; | |
| xmlChar *result; | |
| if (arg1 == NULL) | |
| arg1 = BAD_CAST ""; | |
| if (arg2 == NULL) | |
| arg2 = BAD_CAST ""; | |
| msg[0] = 0; | |
| switch (err) { | |
| case XML_RELAXNG_OK: | |
| return (NULL); | |
| case XML_RELAXNG_ERR_MEMORY: | |
| return (xmlCharStrdup("out of memory\n")); | |
| case XML_RELAXNG_ERR_TYPE: | |
| snprintf(msg, 1000, "failed to validate type %s\n", arg1); | |
| break; | |
| case XML_RELAXNG_ERR_TYPEVAL: | |
| snprintf(msg, 1000, "Type %s doesn't allow value '%s'\n", arg1, | |
| arg2); | |
| break; | |
| case XML_RELAXNG_ERR_DUPID: | |
| snprintf(msg, 1000, "ID %s redefined\n", arg1); | |
| break; | |
| case XML_RELAXNG_ERR_TYPECMP: | |
| snprintf(msg, 1000, "failed to compare type %s\n", arg1); | |
| break; | |
| case XML_RELAXNG_ERR_NOSTATE: | |
| return (xmlCharStrdup("Internal error: no state\n")); | |
| case XML_RELAXNG_ERR_NODEFINE: | |
| return (xmlCharStrdup("Internal error: no define\n")); | |
| case XML_RELAXNG_ERR_INTERNAL: | |
| snprintf(msg, 1000, "Internal error: %s\n", arg1); | |
| break; | |
| case XML_RELAXNG_ERR_LISTEXTRA: | |
| snprintf(msg, 1000, "Extra data in list: %s\n", arg1); | |
| break; | |
| case XML_RELAXNG_ERR_INTERNODATA: | |
| return (xmlCharStrdup | |
| ("Internal: interleave block has no data\n")); | |
| case XML_RELAXNG_ERR_INTERSEQ: | |
| return (xmlCharStrdup("Invalid sequence in interleave\n")); | |
| case XML_RELAXNG_ERR_INTEREXTRA: | |
| snprintf(msg, 1000, "Extra element %s in interleave\n", arg1); | |
| break; | |
| case XML_RELAXNG_ERR_ELEMNAME: | |
| snprintf(msg, 1000, "Expecting element %s, got %s\n", arg1, | |
| arg2); | |
| break; | |
| case XML_RELAXNG_ERR_ELEMNONS: | |
| snprintf(msg, 1000, "Expecting a namespace for element %s\n", | |
| arg1); | |
| break; | |
| case XML_RELAXNG_ERR_ELEMWRONGNS: | |
| snprintf(msg, 1000, | |
| "Element %s has wrong namespace: expecting %s\n", arg1, | |
| arg2); | |
| break; | |
| case XML_RELAXNG_ERR_ELEMWRONG: | |
| snprintf(msg, 1000, "Did not expect element %s there\n", arg1); | |
| break; | |
| case XML_RELAXNG_ERR_TEXTWRONG: | |
| snprintf(msg, 1000, | |
| "Did not expect text in element %s content\n", arg1); | |
| break; | |
| case XML_RELAXNG_ERR_ELEMEXTRANS: | |
| snprintf(msg, 1000, "Expecting no namespace for element %s\n", | |
| arg1); | |
| break; | |
| case XML_RELAXNG_ERR_ELEMNOTEMPTY: | |
| snprintf(msg, 1000, "Expecting element %s to be empty\n", arg1); | |
| break; | |
| case XML_RELAXNG_ERR_NOELEM: | |
| snprintf(msg, 1000, "Expecting an element %s, got nothing\n", | |
| arg1); | |
| break; | |
| case XML_RELAXNG_ERR_NOTELEM: | |
| return (xmlCharStrdup("Expecting an element got text\n")); | |
| case XML_RELAXNG_ERR_ATTRVALID: | |
| snprintf(msg, 1000, "Element %s failed to validate attributes\n", | |
| arg1); | |
| break; | |
| case XML_RELAXNG_ERR_CONTENTVALID: | |
| snprintf(msg, 1000, "Element %s failed to validate content\n", | |
| arg1); | |
| break; | |
| case XML_RELAXNG_ERR_EXTRACONTENT: | |
| snprintf(msg, 1000, "Element %s has extra content: %s\n", | |
| arg1, arg2); | |
| break; | |
| case XML_RELAXNG_ERR_INVALIDATTR: | |
| snprintf(msg, 1000, "Invalid attribute %s for element %s\n", | |
| arg1, arg2); | |
| break; | |
| case XML_RELAXNG_ERR_LACKDATA: | |
| snprintf(msg, 1000, "Datatype element %s contains no data\n", | |
| arg1); | |
| break; | |
| case XML_RELAXNG_ERR_DATAELEM: | |
| snprintf(msg, 1000, "Datatype element %s has child elements\n", | |
| arg1); | |
| break; | |
| case XML_RELAXNG_ERR_VALELEM: | |
| snprintf(msg, 1000, "Value element %s has child elements\n", | |
| arg1); | |
| break; | |
| case XML_RELAXNG_ERR_LISTELEM: | |
| snprintf(msg, 1000, "List element %s has child elements\n", | |
| arg1); | |
| break; | |
| case XML_RELAXNG_ERR_DATATYPE: | |
| snprintf(msg, 1000, "Error validating datatype %s\n", arg1); | |
| break; | |
| case XML_RELAXNG_ERR_VALUE: | |
| snprintf(msg, 1000, "Error validating value %s\n", arg1); | |
| break; | |
| case XML_RELAXNG_ERR_LIST: | |
| return (xmlCharStrdup("Error validating list\n")); | |
| case XML_RELAXNG_ERR_NOGRAMMAR: | |
| return (xmlCharStrdup("No top grammar defined\n")); | |
| case XML_RELAXNG_ERR_EXTRADATA: | |
| return (xmlCharStrdup("Extra data in the document\n")); | |
| default: | |
| return (xmlCharStrdup("Unknown error !\n")); | |
| } | |
| if (msg[0] == 0) { | |
| snprintf(msg, 1000, "Unknown error code %d\n", err); | |
| } | |
| msg[1000 - 1] = 0; | |
| result = xmlCharStrdup(msg); | |
| return (xmlEscapeFormatString(&result)); | |
| } | |
| /** | |
| * xmlRelaxNGShowValidError: | |
| * @ctxt: the validation context | |
| * @err: the error number | |
| * @node: the node | |
| * @child: the node child generating the problem. | |
| * @arg1: the first argument | |
| * @arg2: the second argument | |
| * | |
| * Show a validation error. | |
| */ | |
| static void | |
| xmlRelaxNGShowValidError(xmlRelaxNGValidCtxtPtr ctxt, | |
| xmlRelaxNGValidErr err, xmlNodePtr node, | |
| xmlNodePtr child, const xmlChar * arg1, | |
| const xmlChar * arg2) | |
| { | |
| xmlChar *msg; | |
| if (ctxt->flags & FLAGS_NOERROR) | |
| return; | |
| #ifdef DEBUG_ERROR | |
| xmlGenericError(xmlGenericErrorContext, "Show error %d\n", err); | |
| #endif | |
| msg = xmlRelaxNGGetErrorString(err, arg1, arg2); | |
| if (msg == NULL) | |
| return; | |
| if (ctxt->errNo == XML_RELAXNG_OK) | |
| ctxt->errNo = err; | |
| xmlRngVErr(ctxt, (child == NULL ? node : child), err, | |
| (const char *) msg, arg1, arg2); | |
| xmlFree(msg); | |
| } | |
| /** | |
| * xmlRelaxNGPopErrors: | |
| * @ctxt: the validation context | |
| * @level: the error level in the stack | |
| * | |
| * pop and discard all errors until the given level is reached | |
| */ | |
| static void | |
| xmlRelaxNGPopErrors(xmlRelaxNGValidCtxtPtr ctxt, int level) | |
| { | |
| int i; | |
| xmlRelaxNGValidErrorPtr err; | |
| #ifdef DEBUG_ERROR | |
| xmlGenericError(xmlGenericErrorContext, | |
| "Pop errors till level %d\n", level); | |
| #endif | |
| for (i = level; i < ctxt->errNr; i++) { | |
| err = &ctxt->errTab[i]; | |
| if (err->flags & ERROR_IS_DUP) { | |
| if (err->arg1 != NULL) | |
| xmlFree((xmlChar *) err->arg1); | |
| err->arg1 = NULL; | |
| if (err->arg2 != NULL) | |
| xmlFree((xmlChar *) err->arg2); | |
| err->arg2 = NULL; | |
| err->flags = 0; | |
| } | |
| } | |
| ctxt->errNr = level; | |
| if (ctxt->errNr <= 0) | |
| ctxt->err = NULL; | |
| } | |
| /** | |
| * xmlRelaxNGDumpValidError: | |
| * @ctxt: the validation context | |
| * | |
| * Show all validation error over a given index. | |
| */ | |
| static void | |
| xmlRelaxNGDumpValidError(xmlRelaxNGValidCtxtPtr ctxt) | |
| { | |
| int i, j, k; | |
| xmlRelaxNGValidErrorPtr err, dup; | |
| #ifdef DEBUG_ERROR | |
| xmlGenericError(xmlGenericErrorContext, | |
| "Dumping error stack %d errors\n", ctxt->errNr); | |
| #endif | |
| for (i = 0, k = 0; i < ctxt->errNr; i++) { | |
| err = &ctxt->errTab[i]; | |
| if (k < MAX_ERROR) { | |
| for (j = 0; j < i; j++) { | |
| dup = &ctxt->errTab[j]; | |
| if ((err->err == dup->err) && (err->node == dup->node) && | |
| (xmlStrEqual(err->arg1, dup->arg1)) && | |
| (xmlStrEqual(err->arg2, dup->arg2))) { | |
| goto skip; | |
| } | |
| } | |
| xmlRelaxNGShowValidError(ctxt, err->err, err->node, err->seq, | |
| err->arg1, err->arg2); | |
| k++; | |
| } | |
| skip: | |
| if (err->flags & ERROR_IS_DUP) { | |
| if (err->arg1 != NULL) | |
| xmlFree((xmlChar *) err->arg1); | |
| err->arg1 = NULL; | |
| if (err->arg2 != NULL) | |
| xmlFree((xmlChar *) err->arg2); | |
| err->arg2 = NULL; | |
| err->flags = 0; | |
| } | |
| } | |
| ctxt->errNr = 0; | |
| } | |
| /** | |
| * xmlRelaxNGAddValidError: | |
| * @ctxt: the validation context | |
| * @err: the error number | |
| * @arg1: the first argument | |
| * @arg2: the second argument | |
| * @dup: need to dup the args | |
| * | |
| * Register a validation error, either generating it if it's sure | |
| * or stacking it for later handling if unsure. | |
| */ | |
| static void | |
| xmlRelaxNGAddValidError(xmlRelaxNGValidCtxtPtr ctxt, | |
| xmlRelaxNGValidErr err, const xmlChar * arg1, | |
| const xmlChar * arg2, int dup) | |
| { | |
| if (ctxt == NULL) | |
| return; | |
| if (ctxt->flags & FLAGS_NOERROR) | |
| return; | |
| #ifdef DEBUG_ERROR | |
| xmlGenericError(xmlGenericErrorContext, "Adding error %d\n", err); | |
| #endif | |
| /* | |
| * generate the error directly | |
| */ | |
| if (((ctxt->flags & FLAGS_IGNORABLE) == 0) || | |
| (ctxt->flags & FLAGS_NEGATIVE)) { | |
| xmlNodePtr node, seq; | |
| /* | |
| * Flush first any stacked error which might be the | |
| * real cause of the problem. | |
| */ | |
| if (ctxt->errNr != 0) | |
| xmlRelaxNGDumpValidError(ctxt); | |
| if (ctxt->state != NULL) { | |
| node = ctxt->state->node; | |
| seq = ctxt->state->seq; | |
| } else { | |
| node = seq = NULL; | |
| } | |
| if ((node == NULL) && (seq == NULL)) { | |
| node = ctxt->pnode; | |
| } | |
| xmlRelaxNGShowValidError(ctxt, err, node, seq, arg1, arg2); | |
| } | |
| /* | |
| * Stack the error for later processing if needed | |
| */ | |
| else { | |
| xmlRelaxNGValidErrorPush(ctxt, err, arg1, arg2, dup); | |
| } | |
| } | |
| /************************************************************************ | |
| * * | |
| * Type library hooks * | |
| * * | |
| ************************************************************************/ | |
| static xmlChar *xmlRelaxNGNormalize(xmlRelaxNGValidCtxtPtr ctxt, | |
| const xmlChar * str); | |
| /** | |
| * xmlRelaxNGSchemaTypeHave: | |
| * @data: data needed for the library | |
| * @type: the type name | |
| * | |
| * Check if the given type is provided by | |
| * the W3C XMLSchema Datatype library. | |
| * | |
| * Returns 1 if yes, 0 if no and -1 in case of error. | |
| */ | |
| static int | |
| xmlRelaxNGSchemaTypeHave(void *data ATTRIBUTE_UNUSED, const xmlChar * type) | |
| { | |
| xmlSchemaTypePtr typ; | |
| if (type == NULL) | |
| return (-1); | |
| typ = xmlSchemaGetPredefinedType(type, | |
| BAD_CAST | |
| "http://www.w3.org/2001/XMLSchema"); | |
| if (typ == NULL) | |
| return (0); | |
| return (1); | |
| } | |
| /** | |
| * xmlRelaxNGSchemaTypeCheck: | |
| * @data: data needed for the library | |
| * @type: the type name | |
| * @value: the value to check | |
| * @node: the node | |
| * | |
| * Check if the given type and value are validated by | |
| * the W3C XMLSchema Datatype library. | |
| * | |
| * Returns 1 if yes, 0 if no and -1 in case of error. | |
| */ | |
| static int | |
| xmlRelaxNGSchemaTypeCheck(void *data ATTRIBUTE_UNUSED, | |
| const xmlChar * type, | |
| const xmlChar * value, | |
| void **result, xmlNodePtr node) | |
| { | |
| xmlSchemaTypePtr typ; | |
| int ret; | |
| if ((type == NULL) || (value == NULL)) | |
| return (-1); | |
| typ = xmlSchemaGetPredefinedType(type, | |
| BAD_CAST | |
| "http://www.w3.org/2001/XMLSchema"); | |
| if (typ == NULL) | |
| return (-1); | |
| ret = xmlSchemaValPredefTypeNode(typ, value, | |
| (xmlSchemaValPtr *) result, node); | |
| if (ret == 2) /* special ID error code */ | |
| return (2); | |
| if (ret == 0) | |
| return (1); | |
| if (ret > 0) | |
| return (0); | |
| return (-1); | |
| } | |
| /** | |
| * xmlRelaxNGSchemaFacetCheck: | |
| * @data: data needed for the library | |
| * @type: the type name | |
| * @facet: the facet name | |
| * @val: the facet value | |
| * @strval: the string value | |
| * @value: the value to check | |
| * | |
| * Function provided by a type library to check a value facet | |
| * | |
| * Returns 1 if yes, 0 if no and -1 in case of error. | |
| */ | |
| static int | |
| xmlRelaxNGSchemaFacetCheck(void *data ATTRIBUTE_UNUSED, | |
| const xmlChar * type, const xmlChar * facetname, | |
| const xmlChar * val, const xmlChar * strval, | |
| void *value) | |
| { | |
| xmlSchemaFacetPtr facet; | |
| xmlSchemaTypePtr typ; | |
| int ret; | |
| if ((type == NULL) || (strval == NULL)) | |
| return (-1); | |
| typ = xmlSchemaGetPredefinedType(type, | |
| BAD_CAST | |
| "http://www.w3.org/2001/XMLSchema"); | |
| if (typ == NULL) | |
| return (-1); | |
| facet = xmlSchemaNewFacet(); | |
| if (facet == NULL) | |
| return (-1); | |
| if (xmlStrEqual(facetname, BAD_CAST "minInclusive")) { | |
| facet->type = XML_SCHEMA_FACET_MININCLUSIVE; | |
| } else if (xmlStrEqual(facetname, BAD_CAST "minExclusive")) { | |
| facet->type = XML_SCHEMA_FACET_MINEXCLUSIVE; | |
| } else if (xmlStrEqual(facetname, BAD_CAST "maxInclusive")) { | |
| facet->type = XML_SCHEMA_FACET_MAXINCLUSIVE; | |
| } else if (xmlStrEqual(facetname, BAD_CAST "maxExclusive")) { | |
| facet->type = XML_SCHEMA_FACET_MAXEXCLUSIVE; | |
| } else if (xmlStrEqual(facetname, BAD_CAST "totalDigits")) { | |
| facet->type = XML_SCHEMA_FACET_TOTALDIGITS; | |
| } else if (xmlStrEqual(facetname, BAD_CAST "fractionDigits")) { | |
| facet->type = XML_SCHEMA_FACET_FRACTIONDIGITS; | |
| } else if (xmlStrEqual(facetname, BAD_CAST "pattern")) { | |
| facet->type = XML_SCHEMA_FACET_PATTERN; | |
| } else if (xmlStrEqual(facetname, BAD_CAST "enumeration")) { | |
| facet->type = XML_SCHEMA_FACET_ENUMERATION; | |
| } else if (xmlStrEqual(facetname, BAD_CAST "whiteSpace")) { | |
| facet->type = XML_SCHEMA_FACET_WHITESPACE; | |
| } else if (xmlStrEqual(facetname, BAD_CAST "length")) { | |
| facet->type = XML_SCHEMA_FACET_LENGTH; | |
| } else if (xmlStrEqual(facetname, BAD_CAST "maxLength")) { | |
| facet->type = XML_SCHEMA_FACET_MAXLENGTH; | |
| } else if (xmlStrEqual(facetname, BAD_CAST "minLength")) { | |
| facet->type = XML_SCHEMA_FACET_MINLENGTH; | |
| } else { | |
| xmlSchemaFreeFacet(facet); | |
| return (-1); | |
| } | |
| facet->value = val; | |
| ret = xmlSchemaCheckFacet(facet, typ, NULL, type); | |
| if (ret != 0) { | |
| xmlSchemaFreeFacet(facet); | |
| return (-1); | |
| } | |
| ret = xmlSchemaValidateFacet(typ, facet, strval, value); | |
| xmlSchemaFreeFacet(facet); | |
| if (ret != 0) | |
| return (-1); | |
| return (0); | |
| } | |
| /** | |
| * xmlRelaxNGSchemaFreeValue: | |
| * @data: data needed for the library | |
| * @value: the value to free | |
| * | |
| * Function provided by a type library to free a Schemas value | |
| * | |
| * Returns 1 if yes, 0 if no and -1 in case of error. | |
| */ | |
| static void | |
| xmlRelaxNGSchemaFreeValue(void *data ATTRIBUTE_UNUSED, void *value) | |
| { | |
| xmlSchemaFreeValue(value); | |
| } | |
| /** | |
| * xmlRelaxNGSchemaTypeCompare: | |
| * @data: data needed for the library | |
| * @type: the type name | |
| * @value1: the first value | |
| * @value2: the second value | |
| * | |
| * Compare two values for equality accordingly a type from the W3C XMLSchema | |
| * Datatype library. | |
| * | |
| * Returns 1 if equal, 0 if no and -1 in case of error. | |
| */ | |
| static int | |
| xmlRelaxNGSchemaTypeCompare(void *data ATTRIBUTE_UNUSED, | |
| const xmlChar * type, | |
| const xmlChar * value1, | |
| xmlNodePtr ctxt1, | |
| void *comp1, | |
| const xmlChar * value2, xmlNodePtr ctxt2) | |
| { | |
| int ret; | |
| xmlSchemaTypePtr typ; | |
| xmlSchemaValPtr res1 = NULL, res2 = NULL; | |
| if ((type == NULL) || (value1 == NULL) || (value2 == NULL)) | |
| return (-1); | |
| typ = xmlSchemaGetPredefinedType(type, | |
| BAD_CAST | |
| "http://www.w3.org/2001/XMLSchema"); | |
| if (typ == NULL) | |
| return (-1); | |
| if (comp1 == NULL) { | |
| ret = xmlSchemaValPredefTypeNode(typ, value1, &res1, ctxt1); | |
| if (ret != 0) | |
| return (-1); | |
| if (res1 == NULL) | |
| return (-1); | |
| } else { | |
| res1 = (xmlSchemaValPtr) comp1; | |
| } | |
| ret = xmlSchemaValPredefTypeNode(typ, value2, &res2, ctxt2); | |
| if (ret != 0) { | |
| if (res1 != (xmlSchemaValPtr) comp1) | |
| xmlSchemaFreeValue(res1); | |
| return (-1); | |
| } | |
| ret = xmlSchemaCompareValues(res1, res2); | |
| if (res1 != (xmlSchemaValPtr) comp1) | |
| xmlSchemaFreeValue(res1); | |
| xmlSchemaFreeValue(res2); | |
| if (ret == -2) | |
| return (-1); | |
| if (ret == 0) | |
| return (1); | |
| return (0); | |
| } | |
| /** | |
| * xmlRelaxNGDefaultTypeHave: | |
| * @data: data needed for the library | |
| * @type: the type name | |
| * | |
| * Check if the given type is provided by | |
| * the default datatype library. | |
| * | |
| * Returns 1 if yes, 0 if no and -1 in case of error. | |
| */ | |
| static int | |
| xmlRelaxNGDefaultTypeHave(void *data ATTRIBUTE_UNUSED, | |
| const xmlChar * type) | |
| { | |
| if (type == NULL) | |
| return (-1); | |
| if (xmlStrEqual(type, BAD_CAST "string")) | |
| return (1); | |
| if (xmlStrEqual(type, BAD_CAST "token")) | |
| return (1); | |
| return (0); | |
| } | |
| /** | |
| * xmlRelaxNGDefaultTypeCheck: | |
| * @data: data needed for the library | |
| * @type: the type name | |
| * @value: the value to check | |
| * @node: the node | |
| * | |
| * Check if the given type and value are validated by | |
| * the default datatype library. | |
| * | |
| * Returns 1 if yes, 0 if no and -1 in case of error. | |
| */ | |
| static int | |
| xmlRelaxNGDefaultTypeCheck(void *data ATTRIBUTE_UNUSED, | |
| const xmlChar * type ATTRIBUTE_UNUSED, | |
| const xmlChar * value ATTRIBUTE_UNUSED, | |
| void **result ATTRIBUTE_UNUSED, | |
| xmlNodePtr node ATTRIBUTE_UNUSED) | |
| { | |
| if (value == NULL) | |
| return (-1); | |
| if (xmlStrEqual(type, BAD_CAST "string")) | |
| return (1); | |
| if (xmlStrEqual(type, BAD_CAST "token")) { | |
| return (1); | |
| } | |
| return (0); | |
| } | |
| /** | |
| * xmlRelaxNGDefaultTypeCompare: | |
| * @data: data needed for the library | |
| * @type: the type name | |
| * @value1: the first value | |
| * @value2: the second value | |
| * | |
| * Compare two values accordingly a type from the default | |
| * datatype library. | |
| * | |
| * Returns 1 if yes, 0 if no and -1 in case of error. | |
| */ | |
| static int | |
| xmlRelaxNGDefaultTypeCompare(void *data ATTRIBUTE_UNUSED, | |
| const xmlChar * type, | |
| const xmlChar * value1, | |
| xmlNodePtr ctxt1 ATTRIBUTE_UNUSED, | |
| void *comp1 ATTRIBUTE_UNUSED, | |
| const xmlChar * value2, | |
| xmlNodePtr ctxt2 ATTRIBUTE_UNUSED) | |
| { | |
| int ret = -1; | |
| if (xmlStrEqual(type, BAD_CAST "string")) { | |
| ret = xmlStrEqual(value1, value2); | |
| } else if (xmlStrEqual(type, BAD_CAST "token")) { | |
| if (!xmlStrEqual(value1, value2)) { | |
| xmlChar *nval, *nvalue; | |
| /* | |
| * TODO: trivial optimizations are possible by | |
| * computing at compile-time | |
| */ | |
| nval = xmlRelaxNGNormalize(NULL, value1); | |
| nvalue = xmlRelaxNGNormalize(NULL, value2); | |
| if ((nval == NULL) || (nvalue == NULL)) | |
| ret = -1; | |
| else if (xmlStrEqual(nval, nvalue)) | |
| ret = 1; | |
| else | |
| ret = 0; | |
| if (nval != NULL) | |
| xmlFree(nval); | |
| if (nvalue != NULL) | |
| xmlFree(nvalue); | |
| } else | |
| ret = 1; | |
| } | |
| return (ret); | |
| } | |
| static int xmlRelaxNGTypeInitialized = 0; | |
| static xmlHashTablePtr xmlRelaxNGRegisteredTypes = NULL; | |
| /** | |
| * xmlRelaxNGFreeTypeLibrary: | |
| * @lib: the type library structure | |
| * @namespace: the URI bound to the library | |
| * | |
| * Free the structure associated to the type library | |
| */ | |
| static void | |
| xmlRelaxNGFreeTypeLibrary(xmlRelaxNGTypeLibraryPtr lib, | |
| const xmlChar * namespace ATTRIBUTE_UNUSED) | |
| { | |
| if (lib == NULL) | |
| return; | |
| if (lib->namespace != NULL) | |
| xmlFree((xmlChar *) lib->namespace); | |
| xmlFree(lib); | |
| } | |
| /** | |
| * xmlRelaxNGRegisterTypeLibrary: | |
| * @namespace: the URI bound to the library | |
| * @data: data associated to the library | |
| * @have: the provide function | |
| * @check: the checking function | |
| * @comp: the comparison function | |
| * | |
| * Register a new type library | |
| * | |
| * Returns 0 in case of success and -1 in case of error. | |
| */ | |
| static int | |
| xmlRelaxNGRegisterTypeLibrary(const xmlChar * namespace, void *data, | |
| xmlRelaxNGTypeHave have, | |
| xmlRelaxNGTypeCheck check, | |
| xmlRelaxNGTypeCompare comp, | |
| xmlRelaxNGFacetCheck facet, | |
| xmlRelaxNGTypeFree freef) | |
| { | |
| xmlRelaxNGTypeLibraryPtr lib; | |
| int ret; | |
| if ((xmlRelaxNGRegisteredTypes == NULL) || (namespace == NULL) || | |
| (check == NULL) || (comp == NULL)) | |
| return (-1); | |
| if (xmlHashLookup(xmlRelaxNGRegisteredTypes, namespace) != NULL) { | |
| xmlGenericError(xmlGenericErrorContext, | |
| "Relax-NG types library '%s' already registered\n", | |
| namespace); | |
| return (-1); | |
| } | |
| lib = | |
| (xmlRelaxNGTypeLibraryPtr) | |
| xmlMalloc(sizeof(xmlRelaxNGTypeLibrary)); | |
| if (lib == NULL) { | |
| xmlRngVErrMemory(NULL, "adding types library\n"); | |
| return (-1); | |
| } | |
| memset(lib, 0, sizeof(xmlRelaxNGTypeLibrary)); | |
| lib->namespace = xmlStrdup(namespace); | |
| lib->data = data; | |
| lib->have = have; | |
| lib->comp = comp; | |
| lib->check = check; | |
| lib->facet = facet; | |
| lib->freef = freef; | |
| ret = xmlHashAddEntry(xmlRelaxNGRegisteredTypes, namespace, lib); | |
| if (ret < 0) { | |
| xmlGenericError(xmlGenericErrorContext, | |
| "Relax-NG types library failed to register '%s'\n", | |
| namespace); | |
| xmlRelaxNGFreeTypeLibrary(lib, namespace); | |
| return (-1); | |
| } | |
| return (0); | |
| } | |
| /** | |
| * xmlRelaxNGInitTypes: | |
| * | |
| * Initilize the default type libraries. | |
| * | |
| * Returns 0 in case of success and -1 in case of error. | |
| */ | |
| int | |
| xmlRelaxNGInitTypes(void) | |
| { | |
| if (xmlRelaxNGTypeInitialized != 0) | |
| return (0); | |
| xmlRelaxNGRegisteredTypes = xmlHashCreate(10); | |
| if (xmlRelaxNGRegisteredTypes == NULL) { | |
| xmlGenericError(xmlGenericErrorContext, | |
| "Failed to allocate sh table for Relax-NG types\n"); | |
| return (-1); | |
| } | |
| xmlRelaxNGRegisterTypeLibrary(BAD_CAST | |
| "http://www.w3.org/2001/XMLSchema-datatypes", | |
| NULL, xmlRelaxNGSchemaTypeHave, | |
| xmlRelaxNGSchemaTypeCheck, | |
| xmlRelaxNGSchemaTypeCompare, | |
| xmlRelaxNGSchemaFacetCheck, | |
| xmlRelaxNGSchemaFreeValue); | |
| xmlRelaxNGRegisterTypeLibrary(xmlRelaxNGNs, NULL, | |
| xmlRelaxNGDefaultTypeHave, | |
| xmlRelaxNGDefaultTypeCheck, | |
| xmlRelaxNGDefaultTypeCompare, NULL, | |
| NULL); | |
| xmlRelaxNGTypeInitialized = 1; | |
| return (0); | |
| } | |
| /** | |
| * xmlRelaxNGCleanupTypes: | |
| * | |
| * Cleanup the default Schemas type library associated to RelaxNG | |
| */ | |
| void | |
| xmlRelaxNGCleanupTypes(void) | |
| { | |
| xmlSchemaCleanupTypes(); | |
| if (xmlRelaxNGTypeInitialized == 0) | |
| return; | |
| xmlHashFree(xmlRelaxNGRegisteredTypes, (xmlHashDeallocator) | |
| xmlRelaxNGFreeTypeLibrary); | |
| xmlRelaxNGTypeInitialized = 0; | |
| } | |
| /************************************************************************ | |
| * * | |
| * Compiling element content into regexp * | |
| * * | |
| * Sometime the element content can be compiled into a pure regexp, * | |
| * This allows a faster execution and streamability at that level * | |
| * * | |
| ************************************************************************/ | |
| /* from automata.c but not exported */ | |
| void xmlAutomataSetFlags(xmlAutomataPtr am, int flags); | |
| static int xmlRelaxNGTryCompile(xmlRelaxNGParserCtxtPtr ctxt, | |
| xmlRelaxNGDefinePtr def); | |
| /** | |
| * xmlRelaxNGIsCompileable: | |
| * @define: the definition to check | |
| * | |
| * Check if a definition is nullable. | |
| * | |
| * Returns 1 if yes, 0 if no and -1 in case of error | |
| */ | |
| static int | |
| xmlRelaxNGIsCompileable(xmlRelaxNGDefinePtr def) | |
| { | |
| int ret = -1; | |
| if (def == NULL) { | |
| return (-1); | |
| } | |
| if ((def->type != XML_RELAXNG_ELEMENT) && | |
| (def->dflags & IS_COMPILABLE)) | |
| return (1); | |
| if ((def->type != XML_RELAXNG_ELEMENT) && | |
| (def->dflags & IS_NOT_COMPILABLE)) | |
| return (0); | |
| switch (def->type) { | |
| case XML_RELAXNG_NOOP: | |
| ret = xmlRelaxNGIsCompileable(def->content); | |
| break; | |
| case XML_RELAXNG_TEXT: | |
| case XML_RELAXNG_EMPTY: | |
| ret = 1; | |
| break; | |
| case XML_RELAXNG_ELEMENT: | |
| /* | |
| * Check if the element content is compileable | |
| */ | |
| if (((def->dflags & IS_NOT_COMPILABLE) == 0) && | |
| ((def->dflags & IS_COMPILABLE) == 0)) { | |
| xmlRelaxNGDefinePtr list; | |
| list = def->content; | |
| while (list != NULL) { | |
| ret = xmlRelaxNGIsCompileable(list); | |
| if (ret != 1) | |
| break; | |
| list = list->next; | |
| } | |
| /* | |
| * Because the routine is recursive, we must guard against | |
| * discovering both COMPILABLE and NOT_COMPILABLE | |
| */ | |
| if (ret == 0) { | |
| def->dflags &= ~IS_COMPILABLE; | |
| def->dflags |= IS_NOT_COMPILABLE; | |
| } | |
| if ((ret == 1) && !(def->dflags &= IS_NOT_COMPILABLE)) | |
| def->dflags |= IS_COMPILABLE; | |
| #ifdef DEBUG_COMPILE | |
| if (ret == 1) { | |
| xmlGenericError(xmlGenericErrorContext, | |
| "element content for %s is compilable\n", | |
| def->name); | |
| } else if (ret == 0) { | |
| xmlGenericError(xmlGenericErrorContext, | |
| "element content for %s is not compilable\n", | |
| def->name); | |
| } else { | |
| xmlGenericError(xmlGenericErrorContext, | |
| "Problem in RelaxNGIsCompileable for element %s\n", | |
| def->name); | |
| } | |
| #endif | |
| } | |
| /* | |
| * All elements return a compileable status unless they | |
| * are generic like anyName | |
| */ | |
| if ((def->nameClass != NULL) || (def->name == NULL)) | |
| ret = 0; | |
| else | |
| ret = 1; | |
| return (ret); | |
| case XML_RELAXNG_REF: | |
| case XML_RELAXNG_EXTERNALREF: | |
| case XML_RELAXNG_PARENTREF: | |
| if (def->depth == -20) { | |
| return (1); | |
| } else { | |
| xmlRelaxNGDefinePtr list; | |
| def->depth = -20; | |
| list = def->content; | |
| while (list != NULL) { | |
| ret = xmlRelaxNGIsCompileable(list); | |
| if (ret != 1) | |
| break; | |
| list = list->next; | |
| } | |
| } | |
| break; | |
| case XML_RELAXNG_START: | |
| case XML_RELAXNG_OPTIONAL: | |
| case XML_RELAXNG_ZEROORMORE: | |
| case XML_RELAXNG_ONEORMORE: | |
| case XML_RELAXNG_CHOICE: | |
| case XML_RELAXNG_GROUP: | |
| case XML_RELAXNG_DEF:{ | |
| xmlRelaxNGDefinePtr list; | |
| list = def->content; | |
| while (list != NULL) { | |
| ret = xmlRelaxNGIsCompileable(list); | |
| if (ret != 1) | |
| break; | |
| list = list->next; | |
| } | |
| break; | |
| } | |
| case XML_RELAXNG_EXCEPT: | |
| case XML_RELAXNG_ATTRIBUTE: | |
| case XML_RELAXNG_INTERLEAVE: | |
| case XML_RELAXNG_DATATYPE: | |
| case XML_RELAXNG_LIST: | |
| case XML_RELAXNG_PARAM: | |
| case XML_RELAXNG_VALUE: | |
| case XML_RELAXNG_NOT_ALLOWED: | |
| ret = 0; | |
| break; | |
| } | |
| if (ret == 0) | |
| def->dflags |= IS_NOT_COMPILABLE; | |
| if (ret == 1) | |
| def->dflags |= IS_COMPILABLE; | |
| #ifdef DEBUG_COMPILE | |
| if (ret == 1) { | |
| xmlGenericError(xmlGenericErrorContext, | |
| "RelaxNGIsCompileable %s : true\n", | |
| xmlRelaxNGDefName(def)); | |
| } else if (ret == 0) { | |
| xmlGenericError(xmlGenericErrorContext, | |
| "RelaxNGIsCompileable %s : false\n", | |
| xmlRelaxNGDefName(def)); | |
| } else { | |
| xmlGenericError(xmlGenericErrorContext, | |
| "Problem in RelaxNGIsCompileable %s\n", | |
| xmlRelaxNGDefName(def)); | |
| } | |
| #endif | |
| return (ret); | |
| } | |
| /** | |
| * xmlRelaxNGCompile: | |
| * ctxt: the RelaxNG parser context | |
| * @define: the definition tree to compile | |
| * | |
| * Compile the set of definitions, it works recursively, till the | |
| * element boundaries, where it tries to compile the content if possible | |
| * | |
| * Returns 0 if success and -1 in case of error | |
| */ | |
| static int | |
| xmlRelaxNGCompile(xmlRelaxNGParserCtxtPtr ctxt, xmlRelaxNGDefinePtr def) | |
| { | |
| int ret = 0; | |
| xmlRelaxNGDefinePtr list; | |
| if ((ctxt == NULL) || (def == NULL)) | |
| return (-1); | |
| switch (def->type) { | |
| case XML_RELAXNG_START: | |
| if ((xmlRelaxNGIsCompileable(def) == 1) && (def->depth != -25)) { | |
| xmlAutomataPtr oldam = ctxt->am; | |
| xmlAutomataStatePtr oldstate = ctxt->state; | |
| def->depth = -25; | |
| list = def->content; | |
| ctxt->am = xmlNewAutomata(); | |
| if (ctxt->am == NULL) | |
| return (-1); | |
| /* | |
| * assume identical strings but not same pointer are different | |
| * atoms, needed for non-determinism detection | |
| * That way if 2 elements with the same name are in a choice | |
| * branch the automata is found non-deterministic and | |
| * we fallback to the normal validation which does the right | |
| * thing of exploring both choices. | |
| */ | |
| xmlAutomataSetFlags(ctxt->am, 1); | |
| ctxt->state = xmlAutomataGetInitState(ctxt->am); | |
| while (list != NULL) { | |
| xmlRelaxNGCompile(ctxt, list); | |
| list = list->next; | |
| } | |
| xmlAutomataSetFinalState(ctxt->am, ctxt->state); | |
| if (xmlAutomataIsDeterminist(ctxt->am)) | |
| def->contModel = xmlAutomataCompile(ctxt->am); | |
| xmlFreeAutomata(ctxt->am); | |
| ctxt->state = oldstate; | |
| ctxt->am = oldam; | |
| } | |
| break; | |
| case XML_RELAXNG_ELEMENT: | |
| if ((ctxt->am != NULL) && (def->name != NULL)) { | |
| ctxt->state = xmlAutomataNewTransition2(ctxt->am, | |
| ctxt->state, NULL, | |
| def->name, def->ns, | |
| def); | |
| } | |
| if ((def->dflags & IS_COMPILABLE) && (def->depth != -25)) { | |
| xmlAutomataPtr oldam = ctxt->am; | |
| xmlAutomataStatePtr oldstate = ctxt->state; | |
| def->depth = -25; | |
| list = def->content; | |
| ctxt->am = xmlNewAutomata(); | |
| if (ctxt->am == NULL) | |
| return (-1); | |
| xmlAutomataSetFlags(ctxt->am, 1); | |
| ctxt->state = xmlAutomataGetInitState(ctxt->am); | |
| while (list != NULL) { | |
| xmlRelaxNGCompile(ctxt, list); | |
| list = list->next; | |
| } | |
| xmlAutomataSetFinalState(ctxt->am, ctxt->state); | |
| def->contModel = xmlAutomataCompile(ctxt->am); | |
| if (!xmlRegexpIsDeterminist(def->contModel)) { | |
| #ifdef DEBUG_COMPILE | |
| xmlGenericError(xmlGenericErrorContext, | |
| "Content model not determinist %s\n", | |
| def->name); | |
| #endif | |
| /* | |
| * we can only use the automata if it is determinist | |
| */ | |
| xmlRegFreeRegexp(def->contModel); | |
| def->contModel = NULL; | |
| } | |
| xmlFreeAutomata(ctxt->am); | |
| ctxt->state = oldstate; | |
| ctxt->am = oldam; | |
| } else { | |
| xmlAutomataPtr oldam = ctxt->am; | |
| /* | |
| * we can't build the content model for this element content | |
| * but it still might be possible to build it for some of its | |
| * children, recurse. | |
| */ | |
| ret = xmlRelaxNGTryCompile(ctxt, def); | |
| ctxt->am = oldam; | |
| } | |
| break; | |
| case XML_RELAXNG_NOOP: | |
| ret = xmlRelaxNGCompile(ctxt, def->content); | |
| break; | |
| case XML_RELAXNG_OPTIONAL:{ | |
| xmlAutomataStatePtr oldstate = ctxt->state; | |
| list = def->content; | |
| while (list != NULL) { | |
| xmlRelaxNGCompile(ctxt, list); | |
| list = list->next; | |
| } | |
| xmlAutomataNewEpsilon(ctxt->am, oldstate, ctxt->state); | |
| break; | |
| } | |
| case XML_RELAXNG_ZEROORMORE:{ | |
| xmlAutomataStatePtr oldstate; | |
| ctxt->state = | |
| xmlAutomataNewEpsilon(ctxt->am, ctxt->state, NULL); | |
| oldstate = ctxt->state; | |
| list = def->content; | |
| while (list != NULL) { | |
| xmlRelaxNGCompile(ctxt, list); | |
| list = list->next; | |
| } | |
| xmlAutomataNewEpsilon(ctxt->am, ctxt->state, oldstate); | |
| ctxt->state = | |
| xmlAutomataNewEpsilon(ctxt->am, oldstate, NULL); | |
| break; | |
| } | |
| case XML_RELAXNG_ONEORMORE:{ | |
| xmlAutomataStatePtr oldstate; | |
| list = def->content; | |
| while (list != NULL) { | |
| xmlRelaxNGCompile(ctxt, list); | |
| list = list->next; | |
| } | |
| oldstate = ctxt->state; | |
| list = def->content; | |
| while (list != NULL) { | |
| xmlRelaxNGCompile(ctxt, list); | |
| list = list->next; | |
| } | |
| xmlAutomataNewEpsilon(ctxt->am, ctxt->state, oldstate); | |
| ctxt->state = | |
| xmlAutomataNewEpsilon(ctxt->am, oldstate, NULL); | |
| break; | |
| } | |
| case XML_RELAXNG_CHOICE:{ | |
| xmlAutomataStatePtr target = NULL; | |
| xmlAutomataStatePtr oldstate = ctxt->state; | |
| list = def->content; | |
| while (list != NULL) { | |
| ctxt->state = oldstate; | |
| ret = xmlRelaxNGCompile(ctxt, list); | |
| if (ret != 0) | |
| break; | |
| if (target == NULL) | |
| target = ctxt->state; | |
| else { | |
| xmlAutomataNewEpsilon(ctxt->am, ctxt->state, | |
| target); | |
| } | |
| list = list->next; | |
| } | |
| ctxt->state = target; | |
| break; | |
| } | |
| case XML_RELAXNG_REF: | |
| case XML_RELAXNG_EXTERNALREF: | |
| case XML_RELAXNG_PARENTREF: | |
| case XML_RELAXNG_GROUP: | |
| case XML_RELAXNG_DEF: | |
| list = def->content; | |
| while (list != NULL) { | |
| ret = xmlRelaxNGCompile(ctxt, list); | |
| if (ret != 0) | |
| break; | |
| list = list->next; | |
| } | |
| break; | |
| case XML_RELAXNG_TEXT:{ | |
| xmlAutomataStatePtr oldstate; | |
| ctxt->state = | |
| xmlAutomataNewEpsilon(ctxt->am, ctxt->state, NULL); | |
| oldstate = ctxt->state; | |
| xmlRelaxNGCompile(ctxt, def->content); | |
| xmlAutomataNewTransition(ctxt->am, ctxt->state, | |
| ctxt->state, BAD_CAST "#text", | |
| NULL); | |
| ctxt->state = | |
| xmlAutomataNewEpsilon(ctxt->am, oldstate, NULL); | |
| break; | |
| } | |
| case XML_RELAXNG_EMPTY: | |
| ctxt->state = | |
| xmlAutomataNewEpsilon(ctxt->am, ctxt->state, NULL); | |
| break; | |
| case XML_RELAXNG_EXCEPT: | |
| case XML_RELAXNG_ATTRIBUTE: | |
| case XML_RELAXNG_INTERLEAVE: | |
| case XML_RELAXNG_NOT_ALLOWED: | |
| case XML_RELAXNG_DATATYPE: | |
| case XML_RELAXNG_LIST: | |
| case XML_RELAXNG_PARAM: | |
| case XML_RELAXNG_VALUE: | |
| /* This should not happen and generate an internal error */ | |
| fprintf(stderr, "RNG internal error trying to compile %s\n", | |
| xmlRelaxNGDefName(def)); | |
| break; | |
| } | |
| return (ret); | |
| } | |
| /** | |
| * xmlRelaxNGTryCompile: | |
| * ctxt: the RelaxNG parser context | |
| * @define: the definition tree to compile | |
| * | |
| * Try to compile the set of definitions, it works recursively, | |
| * possibly ignoring parts which cannot be compiled. | |
| * | |
| * Returns 0 if success and -1 in case of error | |
| */ | |
| static int | |
| xmlRelaxNGTryCompile(xmlRelaxNGParserCtxtPtr ctxt, xmlRelaxNGDefinePtr def) | |
| { | |
| int ret = 0; | |
| xmlRelaxNGDefinePtr list; | |
| if ((ctxt == NULL) || (def == NULL)) | |
| return (-1); | |
| if ((def->type == XML_RELAXNG_START) || | |
| (def->type == XML_RELAXNG_ELEMENT)) { | |
| ret = xmlRelaxNGIsCompileable(def); | |
| if ((def->dflags & IS_COMPILABLE) && (def->depth != -25)) { | |
| ctxt->am = NULL; | |
| ret = xmlRelaxNGCompile(ctxt, def); | |
| #ifdef DEBUG_PROGRESSIVE | |
| if (ret == 0) { | |
| if (def->type == XML_RELAXNG_START) | |
| xmlGenericError(xmlGenericErrorContext, | |
| "compiled the start\n"); | |
| else | |
| xmlGenericError(xmlGenericErrorContext, | |
| "compiled element %s\n", def->name); | |
| } else { | |
| if (def->type == XML_RELAXNG_START) | |
| xmlGenericError(xmlGenericErrorContext, | |
| "failed to compile the start\n"); | |
| else | |
| xmlGenericError(xmlGenericErrorContext, | |
| "failed to compile element %s\n", | |
| def->name); | |
| } | |
| #endif | |
| return (ret); | |
| } | |
| } | |
| switch (def->type) { | |
| case XML_RELAXNG_NOOP: | |
| ret = xmlRelaxNGTryCompile(ctxt, def->content); | |
| break; | |
| case XML_RELAXNG_TEXT: | |
| case XML_RELAXNG_DATATYPE: | |
| case XML_RELAXNG_LIST: | |
| case XML_RELAXNG_PARAM: | |
| case XML_RELAXNG_VALUE: | |
| case XML_RELAXNG_EMPTY: | |
| case XML_RELAXNG_ELEMENT: | |
| ret = 0; | |
| break; | |
| case XML_RELAXNG_OPTIONAL: | |
| case XML_RELAXNG_ZEROORMORE: | |
| case XML_RELAXNG_ONEORMORE: | |
| case XML_RELAXNG_CHOICE: | |
| case XML_RELAXNG_GROUP: | |
| case XML_RELAXNG_DEF: | |
| case XML_RELAXNG_START: | |
| case XML_RELAXNG_REF: | |
| case XML_RELAXNG_EXTERNALREF: | |
| case XML_RELAXNG_PARENTREF: | |
| list = def->content; | |
| while (list != NULL) { | |
| ret = xmlRelaxNGTryCompile(ctxt, list); | |
| if (ret != 0) | |
| break; | |
| list = list->next; | |
| } | |
| break; | |
| case XML_RELAXNG_EXCEPT: | |
| case XML_RELAXNG_ATTRIBUTE: | |
| case XML_RELAXNG_INTERLEAVE: | |
| case XML_RELAXNG_NOT_ALLOWED: | |
| ret = 0; | |
| break; | |
| } | |
| return (ret); | |
| } | |
| /************************************************************************ | |
| * * | |
| * Parsing functions * | |
| * * | |
| ************************************************************************/ | |
| static xmlRelaxNGDefinePtr xmlRelaxNGParseAttribute(xmlRelaxNGParserCtxtPtr | |
| ctxt, xmlNodePtr node); | |
| static xmlRelaxNGDefinePtr xmlRelaxNGParseElement(xmlRelaxNGParserCtxtPtr | |
| ctxt, xmlNodePtr node); | |
| static xmlRelaxNGDefinePtr xmlRelaxNGParsePatterns(xmlRelaxNGParserCtxtPtr | |
| ctxt, xmlNodePtr nodes, | |
| int group); | |
| static xmlRelaxNGDefinePtr xmlRelaxNGParsePattern(xmlRelaxNGParserCtxtPtr | |
| ctxt, xmlNodePtr node); | |
| static xmlRelaxNGPtr xmlRelaxNGParseDocument(xmlRelaxNGParserCtxtPtr ctxt, | |
| xmlNodePtr node); | |
| static int xmlRelaxNGParseGrammarContent(xmlRelaxNGParserCtxtPtr ctxt, | |
| xmlNodePtr nodes); | |
| static xmlRelaxNGDefinePtr xmlRelaxNGParseNameClass(xmlRelaxNGParserCtxtPtr | |
| ctxt, xmlNodePtr node, | |
| xmlRelaxNGDefinePtr | |
| def); | |
| static xmlRelaxNGGrammarPtr xmlRelaxNGParseGrammar(xmlRelaxNGParserCtxtPtr | |
| ctxt, xmlNodePtr nodes); | |
| static int xmlRelaxNGElementMatch(xmlRelaxNGValidCtxtPtr ctxt, | |
| xmlRelaxNGDefinePtr define, | |
| xmlNodePtr elem); | |
| #define IS_BLANK_NODE(n) (xmlRelaxNGIsBlank((n)->content)) | |
| /** | |
| * xmlRelaxNGIsNullable: | |
| * @define: the definition to verify | |
| * | |
| * Check if a definition is nullable. | |
| * | |
| * Returns 1 if yes, 0 if no and -1 in case of error | |
| */ | |
| static int | |
| xmlRelaxNGIsNullable(xmlRelaxNGDefinePtr define) | |
| { | |
| int ret; | |
| if (define == NULL) | |
| return (-1); | |
| if (define->dflags & IS_NULLABLE) | |
| return (1); | |
| if (define->dflags & IS_NOT_NULLABLE) | |
| return (0); | |
| switch (define->type) { | |
| case XML_RELAXNG_EMPTY: | |
| case XML_RELAXNG_TEXT: | |
| ret = 1; | |
| break; | |
| case XML_RELAXNG_NOOP: | |
| case XML_RELAXNG_DEF: | |
| case XML_RELAXNG_REF: | |
| case XML_RELAXNG_EXTERNALREF: | |
| case XML_RELAXNG_PARENTREF: | |
| case XML_RELAXNG_ONEORMORE: | |
| ret = xmlRelaxNGIsNullable(define->content); | |
| break; | |
| case XML_RELAXNG_EXCEPT: | |
| case XML_RELAXNG_NOT_ALLOWED: | |
| case XML_RELAXNG_ELEMENT: | |
| case XML_RELAXNG_DATATYPE: | |
| case XML_RELAXNG_PARAM: | |
| case XML_RELAXNG_VALUE: | |
| case XML_RELAXNG_LIST: | |
| case XML_RELAXNG_ATTRIBUTE: | |
| ret = 0; | |
| break; | |
| case XML_RELAXNG_CHOICE:{ | |
| xmlRelaxNGDefinePtr list = define->content; | |
| while (list != NULL) { | |
| ret = xmlRelaxNGIsNullable(list); | |
| if (ret != 0) | |
| goto done; | |
| list = list->next; | |
| } | |
| ret = 0; | |
| break; | |
| } | |
| case XML_RELAXNG_START: | |
| case XML_RELAXNG_INTERLEAVE: | |
| case XML_RELAXNG_GROUP:{ | |
| xmlRelaxNGDefinePtr list = define->content; | |
| while (list != NULL) { | |
| ret = xmlRelaxNGIsNullable(list); | |
| if (ret != 1) | |
| goto done; | |
| list = list->next; | |
| } | |
| return (1); | |
| } | |
| default: | |
| return (-1); | |
| } | |
| done: | |
| if (ret == 0) | |
| define->dflags |= IS_NOT_NULLABLE; | |
| if (ret == 1) | |
| define->dflags |= IS_NULLABLE; | |
| return (ret); | |
| } | |
| /** | |
| * xmlRelaxNGIsBlank: | |
| * @str: a string | |
| * | |
| * Check if a string is ignorable c.f. 4.2. Whitespace | |
| * | |
| * Returns 1 if the string is NULL or made of blanks chars, 0 otherwise | |
| */ | |
| static int | |
| xmlRelaxNGIsBlank(xmlChar * str) | |
| { | |
| if (str == NULL) | |
| return (1); | |
| while (*str != 0) { | |
| if (!(IS_BLANK_CH(*str))) | |
| return (0); | |
| str++; | |
| } | |
| return (1); | |
| } | |
| /** | |
| * xmlRelaxNGGetDataTypeLibrary: | |
| * @ctxt: a Relax-NG parser context | |
| * @node: the current data or value element | |
| * | |
| * Applies algorithm from 4.3. datatypeLibrary attribute | |
| * | |
| * Returns the datatypeLibary value or NULL if not found | |
| */ | |
| static xmlChar * | |
| xmlRelaxNGGetDataTypeLibrary(xmlRelaxNGParserCtxtPtr ctxt ATTRIBUTE_UNUSED, | |
| xmlNodePtr node) | |
| { | |
| xmlChar *ret, *escape; | |
| if (node == NULL) | |
| return(NULL); | |
| if ((IS_RELAXNG(node, "data")) || (IS_RELAXNG(node, "value"))) { | |
| ret = xmlGetProp(node, BAD_CAST "datatypeLibrary"); | |
| if (ret != NULL) { | |
| if (ret[0] == 0) { | |
| xmlFree(ret); | |
| return (NULL); | |
| } | |
| escape = xmlURIEscapeStr(ret, BAD_CAST ":/#?"); | |
| if (escape == NULL) { | |
| return (ret); | |
| } | |
| xmlFree(ret); | |
| return (escape); | |
| } | |
| } | |
| node = node->parent; | |
| while ((node != NULL) && (node->type == XML_ELEMENT_NODE)) { | |
| ret = xmlGetProp(node, BAD_CAST "datatypeLibrary"); | |
| if (ret != NULL) { | |
| if (ret[0] == 0) { | |
| xmlFree(ret); | |
| return (NULL); | |
| } | |
| escape = xmlURIEscapeStr(ret, BAD_CAST ":/#?"); | |
| if (escape == NULL) { | |
| return (ret); | |
| } | |
| xmlFree(ret); | |
| return (escape); | |
| } | |
| node = node->parent; | |
| } | |
| return (NULL); | |
| } | |
| /** | |
| * xmlRelaxNGParseValue: | |
| * @ctxt: a Relax-NG parser context | |
| * @node: the data node. | |
| * | |
| * parse the content of a RelaxNG value node. | |
| * | |
| * Returns the definition pointer or NULL in case of error | |
| */ | |
| static xmlRelaxNGDefinePtr | |
| xmlRelaxNGParseValue(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node) | |
| { | |
| xmlRelaxNGDefinePtr def = NULL; | |
| xmlRelaxNGTypeLibraryPtr lib = NULL; | |
| xmlChar *type; | |
| xmlChar *library; | |
| int success = 0; | |
| def = xmlRelaxNGNewDefine(ctxt, node); | |
| if (def == NULL) | |
| return (NULL); | |
| def->type = XML_RELAXNG_VALUE; | |
| type = xmlGetProp(node, BAD_CAST "type"); | |
| if (type != NULL) { | |
| xmlRelaxNGNormExtSpace(type); | |
| if (xmlValidateNCName(type, 0)) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_TYPE_VALUE, | |
| "value type '%s' is not an NCName\n", type, NULL); | |
| } | |
| library = xmlRelaxNGGetDataTypeLibrary(ctxt, node); | |
| if (library == NULL) | |
| library = | |
| xmlStrdup(BAD_CAST "http://relaxng.org/ns/structure/1.0"); | |
| def->name = type; | |
| def->ns = library; | |
| lib = (xmlRelaxNGTypeLibraryPtr) | |
| xmlHashLookup(xmlRelaxNGRegisteredTypes, library); | |
| if (lib == NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_UNKNOWN_TYPE_LIB, | |
| "Use of unregistered type library '%s'\n", library, | |
| NULL); | |
| def->data = NULL; | |
| } else { | |
| def->data = lib; | |
| if (lib->have == NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_ERROR_TYPE_LIB, | |
| "Internal error with type library '%s': no 'have'\n", | |
| library, NULL); | |
| } else { | |
| success = lib->have(lib->data, def->name); | |
| if (success != 1) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_TYPE_NOT_FOUND, | |
| "Error type '%s' is not exported by type library '%s'\n", | |
| def->name, library); | |
| } | |
| } | |
| } | |
| } | |
| if (node->children == NULL) { | |
| def->value = xmlStrdup(BAD_CAST ""); | |
| } else if (((node->children->type != XML_TEXT_NODE) && | |
| (node->children->type != XML_CDATA_SECTION_NODE)) || | |
| (node->children->next != NULL)) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_TEXT_EXPECTED, | |
| "Expecting a single text value for <value>content\n", | |
| NULL, NULL); | |
| } else if (def != NULL) { | |
| def->value = xmlNodeGetContent(node); | |
| if (def->value == NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_VALUE_NO_CONTENT, | |
| "Element <value> has no content\n", NULL, NULL); | |
| } else if ((lib != NULL) && (lib->check != NULL) && (success == 1)) { | |
| void *val = NULL; | |
| success = | |
| lib->check(lib->data, def->name, def->value, &val, node); | |
| if (success != 1) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_INVALID_VALUE, | |
| "Value '%s' is not acceptable for type '%s'\n", | |
| def->value, def->name); | |
| } else { | |
| if (val != NULL) | |
| def->attrs = val; | |
| } | |
| } | |
| } | |
| return (def); | |
| } | |
| /** | |
| * xmlRelaxNGParseData: | |
| * @ctxt: a Relax-NG parser context | |
| * @node: the data node. | |
| * | |
| * parse the content of a RelaxNG data node. | |
| * | |
| * Returns the definition pointer or NULL in case of error | |
| */ | |
| static xmlRelaxNGDefinePtr | |
| xmlRelaxNGParseData(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node) | |
| { | |
| xmlRelaxNGDefinePtr def = NULL, except; | |
| xmlRelaxNGDefinePtr param, lastparam = NULL; | |
| xmlRelaxNGTypeLibraryPtr lib; | |
| xmlChar *type; | |
| xmlChar *library; | |
| xmlNodePtr content; | |
| int tmp; | |
| type = xmlGetProp(node, BAD_CAST "type"); | |
| if (type == NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_TYPE_MISSING, "data has no type\n", NULL, | |
| NULL); | |
| return (NULL); | |
| } | |
| xmlRelaxNGNormExtSpace(type); | |
| if (xmlValidateNCName(type, 0)) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_TYPE_VALUE, | |
| "data type '%s' is not an NCName\n", type, NULL); | |
| } | |
| library = xmlRelaxNGGetDataTypeLibrary(ctxt, node); | |
| if (library == NULL) | |
| library = | |
| xmlStrdup(BAD_CAST "http://relaxng.org/ns/structure/1.0"); | |
| def = xmlRelaxNGNewDefine(ctxt, node); | |
| if (def == NULL) { | |
| xmlFree(type); | |
| return (NULL); | |
| } | |
| def->type = XML_RELAXNG_DATATYPE; | |
| def->name = type; | |
| def->ns = library; | |
| lib = (xmlRelaxNGTypeLibraryPtr) | |
| xmlHashLookup(xmlRelaxNGRegisteredTypes, library); | |
| if (lib == NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_UNKNOWN_TYPE_LIB, | |
| "Use of unregistered type library '%s'\n", library, | |
| NULL); | |
| def->data = NULL; | |
| } else { | |
| def->data = lib; | |
| if (lib->have == NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_ERROR_TYPE_LIB, | |
| "Internal error with type library '%s': no 'have'\n", | |
| library, NULL); | |
| } else { | |
| tmp = lib->have(lib->data, def->name); | |
| if (tmp != 1) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_TYPE_NOT_FOUND, | |
| "Error type '%s' is not exported by type library '%s'\n", | |
| def->name, library); | |
| } else | |
| if ((xmlStrEqual | |
| (library, | |
| BAD_CAST | |
| "http://www.w3.org/2001/XMLSchema-datatypes")) | |
| && ((xmlStrEqual(def->name, BAD_CAST "IDREF")) | |
| || (xmlStrEqual(def->name, BAD_CAST "IDREFS")))) { | |
| ctxt->idref = 1; | |
| } | |
| } | |
| } | |
| content = node->children; | |
| /* | |
| * Handle optional params | |
| */ | |
| while (content != NULL) { | |
| if (!xmlStrEqual(content->name, BAD_CAST "param")) | |
| break; | |
| if (xmlStrEqual(library, | |
| BAD_CAST "http://relaxng.org/ns/structure/1.0")) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_PARAM_FORBIDDEN, | |
| "Type library '%s' does not allow type parameters\n", | |
| library, NULL); | |
| content = content->next; | |
| while ((content != NULL) && | |
| (xmlStrEqual(content->name, BAD_CAST "param"))) | |
| content = content->next; | |
| } else { | |
| param = xmlRelaxNGNewDefine(ctxt, node); | |
| if (param != NULL) { | |
| param->type = XML_RELAXNG_PARAM; | |
| param->name = xmlGetProp(content, BAD_CAST "name"); | |
| if (param->name == NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_PARAM_NAME_MISSING, | |
| "param has no name\n", NULL, NULL); | |
| } | |
| param->value = xmlNodeGetContent(content); | |
| if (lastparam == NULL) { | |
| def->attrs = lastparam = param; | |
| } else { | |
| lastparam->next = param; | |
| lastparam = param; | |
| } | |
| if (lib != NULL) { | |
| } | |
| } | |
| content = content->next; | |
| } | |
| } | |
| /* | |
| * Handle optional except | |
| */ | |
| if ((content != NULL) | |
| && (xmlStrEqual(content->name, BAD_CAST "except"))) { | |
| xmlNodePtr child; | |
| xmlRelaxNGDefinePtr tmp2, last = NULL; | |
| except = xmlRelaxNGNewDefine(ctxt, node); | |
| if (except == NULL) { | |
| return (def); | |
| } | |
| except->type = XML_RELAXNG_EXCEPT; | |
| child = content->children; | |
| def->content = except; | |
| if (child == NULL) { | |
| xmlRngPErr(ctxt, content, XML_RNGP_EXCEPT_NO_CONTENT, | |
| "except has no content\n", NULL, NULL); | |
| } | |
| while (child != NULL) { | |
| tmp2 = xmlRelaxNGParsePattern(ctxt, child); | |
| if (tmp2 != NULL) { | |
| if (last == NULL) { | |
| except->content = last = tmp2; | |
| } else { | |
| last->next = tmp2; | |
| last = tmp2; | |
| } | |
| } | |
| child = child->next; | |
| } | |
| content = content->next; | |
| } | |
| /* | |
| * Check there is no unhandled data | |
| */ | |
| if (content != NULL) { | |
| xmlRngPErr(ctxt, content, XML_RNGP_DATA_CONTENT, | |
| "Element data has unexpected content %s\n", | |
| content->name, NULL); | |
| } | |
| return (def); | |
| } | |
| static const xmlChar *invalidName = BAD_CAST "\1"; | |
| /** | |
| * xmlRelaxNGCompareNameClasses: | |
| * @defs1: the first element/attribute defs | |
| * @defs2: the second element/attribute defs | |
| * @name: the restriction on the name | |
| * @ns: the restriction on the namespace | |
| * | |
| * Compare the 2 lists of element definitions. The comparison is | |
| * that if both lists do not accept the same QNames, it returns 1 | |
| * If the 2 lists can accept the same QName the comparison returns 0 | |
| * | |
| * Returns 1 disttinct, 0 if equal | |
| */ | |
| static int | |
| xmlRelaxNGCompareNameClasses(xmlRelaxNGDefinePtr def1, | |
| xmlRelaxNGDefinePtr def2) | |
| { | |
| int ret = 1; | |
| xmlNode node; | |
| xmlNs ns; | |
| xmlRelaxNGValidCtxt ctxt; | |
| memset(&ctxt, 0, sizeof(xmlRelaxNGValidCtxt)); | |
| ctxt.flags = FLAGS_IGNORABLE | FLAGS_NOERROR; | |
| if ((def1->type == XML_RELAXNG_ELEMENT) || | |
| (def1->type == XML_RELAXNG_ATTRIBUTE)) { | |
| if (def2->type == XML_RELAXNG_TEXT) | |
| return (1); | |
| if (def1->name != NULL) { | |
| node.name = def1->name; | |
| } else { | |
| node.name = invalidName; | |
| } | |
| if (def1->ns != NULL) { | |
| if (def1->ns[0] == 0) { | |
| node.ns = NULL; | |
| } else { | |
| node.ns = &ns; | |
| ns.href = def1->ns; | |
| } | |
| } else { | |
| node.ns = NULL; | |
| } | |
| if (xmlRelaxNGElementMatch(&ctxt, def2, &node)) { | |
| if (def1->nameClass != NULL) { | |
| ret = xmlRelaxNGCompareNameClasses(def1->nameClass, def2); | |
| } else { | |
| ret = 0; | |
| } | |
| } else { | |
| ret = 1; | |
| } | |
| } else if (def1->type == XML_RELAXNG_TEXT) { | |
| if (def2->type == XML_RELAXNG_TEXT) | |
| return (0); | |
| return (1); | |
| } else if (def1->type == XML_RELAXNG_EXCEPT) { | |
| ret = xmlRelaxNGCompareNameClasses(def1->content, def2); | |
| if (ret == 0) | |
| ret = 1; | |
| else if (ret == 1) | |
| ret = 0; | |
| } else { | |
| TODO ret = 0; | |
| } | |
| if (ret == 0) | |
| return (ret); | |
| if ((def2->type == XML_RELAXNG_ELEMENT) || | |
| (def2->type == XML_RELAXNG_ATTRIBUTE)) { | |
| if (def2->name != NULL) { | |
| node.name = def2->name; | |
| } else { | |
| node.name = invalidName; | |
| } | |
| node.ns = &ns; | |
| if (def2->ns != NULL) { | |
| if (def2->ns[0] == 0) { | |
| node.ns = NULL; | |
| } else { | |
| ns.href = def2->ns; | |
| } | |
| } else { | |
| ns.href = invalidName; | |
| } | |
| if (xmlRelaxNGElementMatch(&ctxt, def1, &node)) { | |
| if (def2->nameClass != NULL) { | |
| ret = xmlRelaxNGCompareNameClasses(def2->nameClass, def1); | |
| } else { | |
| ret = 0; | |
| } | |
| } else { | |
| ret = 1; | |
| } | |
| } else { | |
| TODO ret = 0; | |
| } | |
| return (ret); | |
| } | |
| /** | |
| * xmlRelaxNGCompareElemDefLists: | |
| * @ctxt: a Relax-NG parser context | |
| * @defs1: the first list of element/attribute defs | |
| * @defs2: the second list of element/attribute defs | |
| * | |
| * Compare the 2 lists of element or attribute definitions. The comparison | |
| * is that if both lists do not accept the same QNames, it returns 1 | |
| * If the 2 lists can accept the same QName the comparison returns 0 | |
| * | |
| * Returns 1 disttinct, 0 if equal | |
| */ | |
| static int | |
| xmlRelaxNGCompareElemDefLists(xmlRelaxNGParserCtxtPtr ctxt | |
| ATTRIBUTE_UNUSED, xmlRelaxNGDefinePtr * def1, | |
| xmlRelaxNGDefinePtr * def2) | |
| { | |
| xmlRelaxNGDefinePtr *basedef2 = def2; | |
| if ((def1 == NULL) || (def2 == NULL)) | |
| return (1); | |
| if ((*def1 == NULL) || (*def2 == NULL)) | |
| return (1); | |
| while (*def1 != NULL) { | |
| while ((*def2) != NULL) { | |
| if (xmlRelaxNGCompareNameClasses(*def1, *def2) == 0) | |
| return (0); | |
| def2++; | |
| } | |
| def2 = basedef2; | |
| def1++; | |
| } | |
| return (1); | |
| } | |
| /** | |
| * xmlRelaxNGGenerateAttributes: | |
| * @ctxt: a Relax-NG parser context | |
| * @def: the definition definition | |
| * | |
| * Check if the definition can only generate attributes | |
| * | |
| * Returns 1 if yes, 0 if no and -1 in case of error. | |
| */ | |
| static int | |
| xmlRelaxNGGenerateAttributes(xmlRelaxNGParserCtxtPtr ctxt, | |
| xmlRelaxNGDefinePtr def) | |
| { | |
| xmlRelaxNGDefinePtr parent, cur, tmp; | |
| /* | |
| * Don't run that check in case of error. Infinite recursion | |
| * becomes possible. | |
| */ | |
| if (ctxt->nbErrors != 0) | |
| return (-1); | |
| parent = NULL; | |
| cur = def; | |
| while (cur != NULL) { | |
| if ((cur->type == XML_RELAXNG_ELEMENT) || | |
| (cur->type == XML_RELAXNG_TEXT) || | |
| (cur->type == XML_RELAXNG_DATATYPE) || | |
| (cur->type == XML_RELAXNG_PARAM) || | |
| (cur->type == XML_RELAXNG_LIST) || | |
| (cur->type == XML_RELAXNG_VALUE) || | |
| (cur->type == XML_RELAXNG_EMPTY)) | |
| return (0); | |
| if ((cur->type == XML_RELAXNG_CHOICE) || | |
| (cur->type == XML_RELAXNG_INTERLEAVE) || | |
| (cur->type == XML_RELAXNG_GROUP) || | |
| (cur->type == XML_RELAXNG_ONEORMORE) || | |
| (cur->type == XML_RELAXNG_ZEROORMORE) || | |
| (cur->type == XML_RELAXNG_OPTIONAL) || | |
| (cur->type == XML_RELAXNG_PARENTREF) || | |
| (cur->type == XML_RELAXNG_EXTERNALREF) || | |
| (cur->type == XML_RELAXNG_REF) || | |
| (cur->type == XML_RELAXNG_DEF)) { | |
| if (cur->content != NULL) { | |
| parent = cur; | |
| cur = cur->content; | |
| tmp = cur; | |
| while (tmp != NULL) { | |
| tmp->parent = parent; | |
| tmp = tmp->next; | |
| } | |
| continue; | |
| } | |
| } | |
| if (cur == def) | |
| break; | |
| if (cur->next != NULL) { | |
| cur = cur->next; | |
| continue; | |
| } | |
| do { | |
| cur = cur->parent; | |
| if (cur == NULL) | |
| break; | |
| if (cur == def) | |
| return (1); | |
| if (cur->next != NULL) { | |
| cur = cur->next; | |
| break; | |
| } | |
| } while (cur != NULL); | |
| } | |
| return (1); | |
| } | |
| /** | |
| * xmlRelaxNGGetElements: | |
| * @ctxt: a Relax-NG parser context | |
| * @def: the definition definition | |
| * @eora: gather elements (0) or attributes (1) | |
| * | |
| * Compute the list of top elements a definition can generate | |
| * | |
| * Returns a list of elements or NULL if none was found. | |
| */ | |
| static xmlRelaxNGDefinePtr * | |
| xmlRelaxNGGetElements(xmlRelaxNGParserCtxtPtr ctxt, | |
| xmlRelaxNGDefinePtr def, int eora) | |
| { | |
| xmlRelaxNGDefinePtr *ret = NULL, parent, cur, tmp; | |
| int len = 0; | |
| int max = 0; | |
| /* | |
| * Don't run that check in case of error. Infinite recursion | |
| * becomes possible. | |
| */ | |
| if (ctxt->nbErrors != 0) | |
| return (NULL); | |
| parent = NULL; | |
| cur = def; | |
| while (cur != NULL) { | |
| if (((eora == 0) && ((cur->type == XML_RELAXNG_ELEMENT) || | |
| (cur->type == XML_RELAXNG_TEXT))) || | |
| ((eora == 1) && (cur->type == XML_RELAXNG_ATTRIBUTE))) { | |
| if (ret == NULL) { | |
| max = 10; | |
| ret = (xmlRelaxNGDefinePtr *) | |
| xmlMalloc((max + 1) * sizeof(xmlRelaxNGDefinePtr)); | |
| if (ret == NULL) { | |
| xmlRngPErrMemory(ctxt, "getting element list\n"); | |
| return (NULL); | |
| } | |
| } else if (max <= len) { | |
| xmlRelaxNGDefinePtr *temp; | |
| max *= 2; | |
| temp = xmlRealloc(ret, | |
| (max + 1) * sizeof(xmlRelaxNGDefinePtr)); | |
| if (temp == NULL) { | |
| xmlRngPErrMemory(ctxt, "getting element list\n"); | |
| xmlFree(ret); | |
| return (NULL); | |
| } | |
| ret = temp; | |
| } | |
| ret[len++] = cur; | |
| ret[len] = NULL; | |
| } else if ((cur->type == XML_RELAXNG_CHOICE) || | |
| (cur->type == XML_RELAXNG_INTERLEAVE) || | |
| (cur->type == XML_RELAXNG_GROUP) || | |
| (cur->type == XML_RELAXNG_ONEORMORE) || | |
| (cur->type == XML_RELAXNG_ZEROORMORE) || | |
| (cur->type == XML_RELAXNG_OPTIONAL) || | |
| (cur->type == XML_RELAXNG_PARENTREF) || | |
| (cur->type == XML_RELAXNG_REF) || | |
| (cur->type == XML_RELAXNG_DEF) || | |
| (cur->type == XML_RELAXNG_EXTERNALREF)) { | |
| /* | |
| * Don't go within elements or attributes or string values. | |
| * Just gather the element top list | |
| */ | |
| if (cur->content != NULL) { | |
| parent = cur; | |
| cur = cur->content; | |
| tmp = cur; | |
| while (tmp != NULL) { | |
| tmp->parent = parent; | |
| tmp = tmp->next; | |
| } | |
| continue; | |
| } | |
| } | |
| if (cur == def) | |
| break; | |
| if (cur->next != NULL) { | |
| cur = cur->next; | |
| continue; | |
| } | |
| do { | |
| cur = cur->parent; | |
| if (cur == NULL) | |
| break; | |
| if (cur == def) | |
| return (ret); | |
| if (cur->next != NULL) { | |
| cur = cur->next; | |
| break; | |
| } | |
| } while (cur != NULL); | |
| } | |
| return (ret); | |
| } | |
| /** | |
| * xmlRelaxNGCheckChoiceDeterminism: | |
| * @ctxt: a Relax-NG parser context | |
| * @def: the choice definition | |
| * | |
| * Also used to find indeterministic pattern in choice | |
| */ | |
| static void | |
| xmlRelaxNGCheckChoiceDeterminism(xmlRelaxNGParserCtxtPtr ctxt, | |
| xmlRelaxNGDefinePtr def) | |
| { | |
| xmlRelaxNGDefinePtr **list; | |
| xmlRelaxNGDefinePtr cur; | |
| int nbchild = 0, i, j, ret; | |
| int is_nullable = 0; | |
| int is_indeterminist = 0; | |
| xmlHashTablePtr triage = NULL; | |
| int is_triable = 1; | |
| if ((def == NULL) || (def->type != XML_RELAXNG_CHOICE)) | |
| return; | |
| if (def->dflags & IS_PROCESSED) | |
| return; | |
| /* | |
| * Don't run that check in case of error. Infinite recursion | |
| * becomes possible. | |
| */ | |
| if (ctxt->nbErrors != 0) | |
| return; | |
| is_nullable = xmlRelaxNGIsNullable(def); | |
| cur = def->content; | |
| while (cur != NULL) { | |
| nbchild++; | |
| cur = cur->next; | |
| } | |
| list = (xmlRelaxNGDefinePtr **) xmlMalloc(nbchild * | |
| sizeof(xmlRelaxNGDefinePtr | |
| *)); | |
| if (list == NULL) { | |
| xmlRngPErrMemory(ctxt, "building choice\n"); | |
| return; | |
| } | |
| i = 0; | |
| /* | |
| * a bit strong but safe | |
| */ | |
| if (is_nullable == 0) { | |
| triage = xmlHashCreate(10); | |
| } else { | |
| is_triable = 0; | |
| } | |
| cur = def->content; | |
| while (cur != NULL) { | |
| list[i] = xmlRelaxNGGetElements(ctxt, cur, 0); | |
| if ((list[i] == NULL) || (list[i][0] == NULL)) { | |
| is_triable = 0; | |
| } else if (is_triable == 1) { | |
| xmlRelaxNGDefinePtr *tmp; | |
| int res; | |
| tmp = list[i]; | |
| while ((*tmp != NULL) && (is_triable == 1)) { | |
| if ((*tmp)->type == XML_RELAXNG_TEXT) { | |
| res = xmlHashAddEntry2(triage, | |
| BAD_CAST "#text", NULL, | |
| (void *) cur); | |
| if (res != 0) | |
| is_triable = -1; | |
| } else if (((*tmp)->type == XML_RELAXNG_ELEMENT) && | |
| ((*tmp)->name != NULL)) { | |
| if (((*tmp)->ns == NULL) || ((*tmp)->ns[0] == 0)) | |
| res = xmlHashAddEntry2(triage, | |
| (*tmp)->name, NULL, | |
| (void *) cur); | |
| else | |
| res = xmlHashAddEntry2(triage, | |
| (*tmp)->name, (*tmp)->ns, | |
| (void *) cur); | |
| if (res != 0) | |
| is_triable = -1; | |
| } else if ((*tmp)->type == XML_RELAXNG_ELEMENT) { | |
| if (((*tmp)->ns == NULL) || ((*tmp)->ns[0] == 0)) | |
| res = xmlHashAddEntry2(triage, | |
| BAD_CAST "#any", NULL, | |
| (void *) cur); | |
| else | |
| res = xmlHashAddEntry2(triage, | |
| BAD_CAST "#any", (*tmp)->ns, | |
| (void *) cur); | |
| if (res != 0) | |
| is_triable = -1; | |
| } else { | |
| is_triable = -1; | |
| } | |
| tmp++; | |
| } | |
| } | |
| i++; | |
| cur = cur->next; | |
| } | |
| for (i = 0; i < nbchild; i++) { | |
| if (list[i] == NULL) | |
| continue; | |
| for (j = 0; j < i; j++) { | |
| if (list[j] == NULL) | |
| continue; | |
| ret = xmlRelaxNGCompareElemDefLists(ctxt, list[i], list[j]); | |
| if (ret == 0) { | |
| is_indeterminist = 1; | |
| } | |
| } | |
| } | |
| for (i = 0; i < nbchild; i++) { | |
| if (list[i] != NULL) | |
| xmlFree(list[i]); | |
| } | |
| xmlFree(list); | |
| if (is_indeterminist) { | |
| def->dflags |= IS_INDETERMINIST; | |
| } | |
| if (is_triable == 1) { | |
| def->dflags |= IS_TRIABLE; | |
| def->data = triage; | |
| } else if (triage != NULL) { | |
| xmlHashFree(triage, NULL); | |
| } | |
| def->dflags |= IS_PROCESSED; | |
| } | |
| /** | |
| * xmlRelaxNGCheckGroupAttrs: | |
| * @ctxt: a Relax-NG parser context | |
| * @def: the group definition | |
| * | |
| * Detects violations of rule 7.3 | |
| */ | |
| static void | |
| xmlRelaxNGCheckGroupAttrs(xmlRelaxNGParserCtxtPtr ctxt, | |
| xmlRelaxNGDefinePtr def) | |
| { | |
| xmlRelaxNGDefinePtr **list; | |
| xmlRelaxNGDefinePtr cur; | |
| int nbchild = 0, i, j, ret; | |
| if ((def == NULL) || | |
| ((def->type != XML_RELAXNG_GROUP) && | |
| (def->type != XML_RELAXNG_ELEMENT))) | |
| return; | |
| if (def->dflags & IS_PROCESSED) | |
| return; | |
| /* | |
| * Don't run that check in case of error. Infinite recursion | |
| * becomes possible. | |
| */ | |
| if (ctxt->nbErrors != 0) | |
| return; | |
| cur = def->attrs; | |
| while (cur != NULL) { | |
| nbchild++; | |
| cur = cur->next; | |
| } | |
| cur = def->content; | |
| while (cur != NULL) { | |
| nbchild++; | |
| cur = cur->next; | |
| } | |
| list = (xmlRelaxNGDefinePtr **) xmlMalloc(nbchild * | |
| sizeof(xmlRelaxNGDefinePtr | |
| *)); | |
| if (list == NULL) { | |
| xmlRngPErrMemory(ctxt, "building group\n"); | |
| return; | |
| } | |
| i = 0; | |
| cur = def->attrs; | |
| while (cur != NULL) { | |
| list[i] = xmlRelaxNGGetElements(ctxt, cur, 1); | |
| i++; | |
| cur = cur->next; | |
| } | |
| cur = def->content; | |
| while (cur != NULL) { | |
| list[i] = xmlRelaxNGGetElements(ctxt, cur, 1); | |
| i++; | |
| cur = cur->next; | |
| } | |
| for (i = 0; i < nbchild; i++) { | |
| if (list[i] == NULL) | |
| continue; | |
| for (j = 0; j < i; j++) { | |
| if (list[j] == NULL) | |
| continue; | |
| ret = xmlRelaxNGCompareElemDefLists(ctxt, list[i], list[j]); | |
| if (ret == 0) { | |
| xmlRngPErr(ctxt, def->node, XML_RNGP_GROUP_ATTR_CONFLICT, | |
| "Attributes conflicts in group\n", NULL, NULL); | |
| } | |
| } | |
| } | |
| for (i = 0; i < nbchild; i++) { | |
| if (list[i] != NULL) | |
| xmlFree(list[i]); | |
| } | |
| xmlFree(list); | |
| def->dflags |= IS_PROCESSED; | |
| } | |
| /** | |
| * xmlRelaxNGComputeInterleaves: | |
| * @def: the interleave definition | |
| * @ctxt: a Relax-NG parser context | |
| * @name: the definition name | |
| * | |
| * A lot of work for preprocessing interleave definitions | |
| * is potentially needed to get a decent execution speed at runtime | |
| * - trying to get a total order on the element nodes generated | |
| * by the interleaves, order the list of interleave definitions | |
| * following that order. | |
| * - if <text/> is used to handle mixed content, it is better to | |
| * flag this in the define and simplify the runtime checking | |
| * algorithm | |
| */ | |
| static void | |
| xmlRelaxNGComputeInterleaves(xmlRelaxNGDefinePtr def, | |
| xmlRelaxNGParserCtxtPtr ctxt, | |
| xmlChar * name ATTRIBUTE_UNUSED) | |
| { | |
| xmlRelaxNGDefinePtr cur, *tmp; | |
| xmlRelaxNGPartitionPtr partitions = NULL; | |
| xmlRelaxNGInterleaveGroupPtr *groups = NULL; | |
| xmlRelaxNGInterleaveGroupPtr group; | |
| int i, j, ret, res; | |
| int nbgroups = 0; | |
| int nbchild = 0; | |
| int is_mixed = 0; | |
| int is_determinist = 1; | |
| /* | |
| * Don't run that check in case of error. Infinite recursion | |
| * becomes possible. | |
| */ | |
| if (ctxt->nbErrors != 0) | |
| return; | |
| #ifdef DEBUG_INTERLEAVE | |
| xmlGenericError(xmlGenericErrorContext, | |
| "xmlRelaxNGComputeInterleaves(%s)\n", name); | |
| #endif | |
| cur = def->content; | |
| while (cur != NULL) { | |
| nbchild++; | |
| cur = cur->next; | |
| } | |
| #ifdef DEBUG_INTERLEAVE | |
| xmlGenericError(xmlGenericErrorContext, " %d child\n", nbchild); | |
| #endif | |
| groups = (xmlRelaxNGInterleaveGroupPtr *) | |
| xmlMalloc(nbchild * sizeof(xmlRelaxNGInterleaveGroupPtr)); | |
| if (groups == NULL) | |
| goto error; | |
| cur = def->content; | |
| while (cur != NULL) { | |
| groups[nbgroups] = (xmlRelaxNGInterleaveGroupPtr) | |
| xmlMalloc(sizeof(xmlRelaxNGInterleaveGroup)); | |
| if (groups[nbgroups] == NULL) | |
| goto error; | |
| if (cur->type == XML_RELAXNG_TEXT) | |
| is_mixed++; | |
| groups[nbgroups]->rule = cur; | |
| groups[nbgroups]->defs = xmlRelaxNGGetElements(ctxt, cur, 0); | |
| groups[nbgroups]->attrs = xmlRelaxNGGetElements(ctxt, cur, 1); | |
| nbgroups++; | |
| cur = cur->next; | |
| } | |
| #ifdef DEBUG_INTERLEAVE | |
| xmlGenericError(xmlGenericErrorContext, " %d groups\n", nbgroups); | |
| #endif | |
| /* | |
| * Let's check that all rules makes a partitions according to 7.4 | |
| */ | |
| partitions = (xmlRelaxNGPartitionPtr) | |
| xmlMalloc(sizeof(xmlRelaxNGPartition)); | |
| if (partitions == NULL) | |
| goto error; | |
| memset(partitions, 0, sizeof(xmlRelaxNGPartition)); | |
| partitions->nbgroups = nbgroups; | |
| partitions->triage = xmlHashCreate(nbgroups); | |
| for (i = 0; i < nbgroups; i++) { | |
| group = groups[i]; | |
| for (j = i + 1; j < nbgroups; j++) { | |
| if (groups[j] == NULL) | |
| continue; | |
| ret = xmlRelaxNGCompareElemDefLists(ctxt, group->defs, | |
| groups[j]->defs); | |
| if (ret == 0) { | |
| xmlRngPErr(ctxt, def->node, XML_RNGP_ELEM_TEXT_CONFLICT, | |
| "Element or text conflicts in interleave\n", | |
| NULL, NULL); | |
| } | |
| ret = xmlRelaxNGCompareElemDefLists(ctxt, group->attrs, | |
| groups[j]->attrs); | |
| if (ret == 0) { | |
| xmlRngPErr(ctxt, def->node, XML_RNGP_ATTR_CONFLICT, | |
| "Attributes conflicts in interleave\n", NULL, | |
| NULL); | |
| } | |
| } | |
| tmp = group->defs; | |
| if ((tmp != NULL) && (*tmp != NULL)) { | |
| while (*tmp != NULL) { | |
| if ((*tmp)->type == XML_RELAXNG_TEXT) { | |
| res = xmlHashAddEntry2(partitions->triage, | |
| BAD_CAST "#text", NULL, | |
| (void *) (long) (i + 1)); | |
| if (res != 0) | |
| is_determinist = -1; | |
| } else if (((*tmp)->type == XML_RELAXNG_ELEMENT) && | |
| ((*tmp)->name != NULL)) { | |
| if (((*tmp)->ns == NULL) || ((*tmp)->ns[0] == 0)) | |
| res = xmlHashAddEntry2(partitions->triage, | |
| (*tmp)->name, NULL, | |
| (void *) (long) (i + 1)); | |
| else | |
| res = xmlHashAddEntry2(partitions->triage, | |
| (*tmp)->name, (*tmp)->ns, | |
| (void *) (long) (i + 1)); | |
| if (res != 0) | |
| is_determinist = -1; | |
| } else if ((*tmp)->type == XML_RELAXNG_ELEMENT) { | |
| if (((*tmp)->ns == NULL) || ((*tmp)->ns[0] == 0)) | |
| res = xmlHashAddEntry2(partitions->triage, | |
| BAD_CAST "#any", NULL, | |
| (void *) (long) (i + 1)); | |
| else | |
| res = xmlHashAddEntry2(partitions->triage, | |
| BAD_CAST "#any", (*tmp)->ns, | |
| (void *) (long) (i + 1)); | |
| if ((*tmp)->nameClass != NULL) | |
| is_determinist = 2; | |
| if (res != 0) | |
| is_determinist = -1; | |
| } else { | |
| is_determinist = -1; | |
| } | |
| tmp++; | |
| } | |
| } else { | |
| is_determinist = 0; | |
| } | |
| } | |
| partitions->groups = groups; | |
| /* | |
| * and save the partition list back in the def | |
| */ | |
| def->data = partitions; | |
| if (is_mixed != 0) | |
| def->dflags |= IS_MIXED; | |
| if (is_determinist == 1) | |
| partitions->flags = IS_DETERMINIST; | |
| if (is_determinist == 2) | |
| partitions->flags = IS_DETERMINIST | IS_NEEDCHECK; | |
| return; | |
| error: | |
| xmlRngPErrMemory(ctxt, "in interleave computation\n"); | |
| if (groups != NULL) { | |
| for (i = 0; i < nbgroups; i++) | |
| if (groups[i] != NULL) { | |
| if (groups[i]->defs != NULL) | |
| xmlFree(groups[i]->defs); | |
| xmlFree(groups[i]); | |
| } | |
| xmlFree(groups); | |
| } | |
| xmlRelaxNGFreePartition(partitions); | |
| } | |
| /** | |
| * xmlRelaxNGParseInterleave: | |
| * @ctxt: a Relax-NG parser context | |
| * @node: the data node. | |
| * | |
| * parse the content of a RelaxNG interleave node. | |
| * | |
| * Returns the definition pointer or NULL in case of error | |
| */ | |
| static xmlRelaxNGDefinePtr | |
| xmlRelaxNGParseInterleave(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node) | |
| { | |
| xmlRelaxNGDefinePtr def = NULL; | |
| xmlRelaxNGDefinePtr last = NULL, cur; | |
| xmlNodePtr child; | |
| def = xmlRelaxNGNewDefine(ctxt, node); | |
| if (def == NULL) { | |
| return (NULL); | |
| } | |
| def->type = XML_RELAXNG_INTERLEAVE; | |
| if (ctxt->interleaves == NULL) | |
| ctxt->interleaves = xmlHashCreate(10); | |
| if (ctxt->interleaves == NULL) { | |
| xmlRngPErrMemory(ctxt, "create interleaves\n"); | |
| } else { | |
| char name[32]; | |
| snprintf(name, 32, "interleave%d", ctxt->nbInterleaves++); | |
| if (xmlHashAddEntry(ctxt->interleaves, BAD_CAST name, def) < 0) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_INTERLEAVE_ADD, | |
| "Failed to add %s to hash table\n", | |
| (const xmlChar *) name, NULL); | |
| } | |
| } | |
| child = node->children; | |
| if (child == NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_INTERLEAVE_NO_CONTENT, | |
| "Element interleave is empty\n", NULL, NULL); | |
| } | |
| while (child != NULL) { | |
| if (IS_RELAXNG(child, "element")) { | |
| cur = xmlRelaxNGParseElement(ctxt, child); | |
| } else { | |
| cur = xmlRelaxNGParsePattern(ctxt, child); | |
| } | |
| if (cur != NULL) { | |
| cur->parent = def; | |
| if (last == NULL) { | |
| def->content = last = cur; | |
| } else { | |
| last->next = cur; | |
| last = cur; | |
| } | |
| } | |
| child = child->next; | |
| } | |
| return (def); | |
| } | |
| /** | |
| * xmlRelaxNGParseInclude: | |
| * @ctxt: a Relax-NG parser context | |
| * @node: the include node | |
| * | |
| * Integrate the content of an include node in the current grammar | |
| * | |
| * Returns 0 in case of success or -1 in case of error | |
| */ | |
| static int | |
| xmlRelaxNGParseInclude(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node) | |
| { | |
| xmlRelaxNGIncludePtr incl; | |
| xmlNodePtr root; | |
| int ret = 0, tmp; | |
| incl = node->psvi; | |
| if (incl == NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_INCLUDE_EMPTY, | |
| "Include node has no data\n", NULL, NULL); | |
| return (-1); | |
| } | |
| root = xmlDocGetRootElement(incl->doc); | |
| if (root == NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_EMPTY, "Include document is empty\n", | |
| NULL, NULL); | |
| return (-1); | |
| } | |
| if (!xmlStrEqual(root->name, BAD_CAST "grammar")) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_GRAMMAR_MISSING, | |
| "Include document root is not a grammar\n", NULL, NULL); | |
| return (-1); | |
| } | |
| /* | |
| * Merge the definition from both the include and the internal list | |
| */ | |
| if (root->children != NULL) { | |
| tmp = xmlRelaxNGParseGrammarContent(ctxt, root->children); | |
| if (tmp != 0) | |
| ret = -1; | |
| } | |
| if (node->children != NULL) { | |
| tmp = xmlRelaxNGParseGrammarContent(ctxt, node->children); | |
| if (tmp != 0) | |
| ret = -1; | |
| } | |
| return (ret); | |
| } | |
| /** | |
| * xmlRelaxNGParseDefine: | |
| * @ctxt: a Relax-NG parser context | |
| * @node: the define node | |
| * | |
| * parse the content of a RelaxNG define element node. | |
| * | |
| * Returns 0 in case of success or -1 in case of error | |
| */ | |
| static int | |
| xmlRelaxNGParseDefine(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node) | |
| { | |
| xmlChar *name; | |
| int ret = 0, tmp; | |
| xmlRelaxNGDefinePtr def; | |
| const xmlChar *olddefine; | |
| name = xmlGetProp(node, BAD_CAST "name"); | |
| if (name == NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_NAME_MISSING, | |
| "define has no name\n", NULL, NULL); | |
| } else { | |
| xmlRelaxNGNormExtSpace(name); | |
| if (xmlValidateNCName(name, 0)) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_INVALID_DEFINE_NAME, | |
| "define name '%s' is not an NCName\n", name, NULL); | |
| } | |
| def = xmlRelaxNGNewDefine(ctxt, node); | |
| if (def == NULL) { | |
| xmlFree(name); | |
| return (-1); | |
| } | |
| def->type = XML_RELAXNG_DEF; | |
| def->name = name; | |
| if (node->children == NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_EMPTY, | |
| "define has no children\n", NULL, NULL); | |
| } else { | |
| olddefine = ctxt->define; | |
| ctxt->define = name; | |
| def->content = | |
| xmlRelaxNGParsePatterns(ctxt, node->children, 0); | |
| ctxt->define = olddefine; | |
| } | |
| if (ctxt->grammar->defs == NULL) | |
| ctxt->grammar->defs = xmlHashCreate(10); | |
| if (ctxt->grammar->defs == NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_CREATE_FAILED, | |
| "Could not create definition hash\n", NULL, NULL); | |
| ret = -1; | |
| } else { | |
| tmp = xmlHashAddEntry(ctxt->grammar->defs, name, def); | |
| if (tmp < 0) { | |
| xmlRelaxNGDefinePtr prev; | |
| prev = xmlHashLookup(ctxt->grammar->defs, name); | |
| if (prev == NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_CREATE_FAILED, | |
| "Internal error on define aggregation of %s\n", | |
| name, NULL); | |
| ret = -1; | |
| } else { | |
| while (prev->nextHash != NULL) | |
| prev = prev->nextHash; | |
| prev->nextHash = def; | |
| } | |
| } | |
| } | |
| } | |
| return (ret); | |
| } | |
| /** | |
| * xmlRelaxNGParseImportRef: | |
| * @payload: the parser context | |
| * @data: the current grammar | |
| * @name: the reference name | |
| * | |
| * Import import one references into the current grammar | |
| */ | |
| static void | |
| xmlRelaxNGParseImportRef(void *payload, void *data, xmlChar *name) { | |
| xmlRelaxNGParserCtxtPtr ctxt = (xmlRelaxNGParserCtxtPtr) data; | |
| xmlRelaxNGDefinePtr def = (xmlRelaxNGDefinePtr) payload; | |
| int tmp; | |
| def->dflags |= IS_EXTERNAL_REF; | |
| tmp = xmlHashAddEntry(ctxt->grammar->refs, name, def); | |
| if (tmp < 0) { | |
| xmlRelaxNGDefinePtr prev; | |
| prev = (xmlRelaxNGDefinePtr) | |
| xmlHashLookup(ctxt->grammar->refs, def->name); | |
| if (prev == NULL) { | |
| if (def->name != NULL) { | |
| xmlRngPErr(ctxt, NULL, XML_RNGP_REF_CREATE_FAILED, | |
| "Error refs definitions '%s'\n", | |
| def->name, NULL); | |
| } else { | |
| xmlRngPErr(ctxt, NULL, XML_RNGP_REF_CREATE_FAILED, | |
| "Error refs definitions\n", | |
| NULL, NULL); | |
| } | |
| } else { | |
| def->nextHash = prev->nextHash; | |
| prev->nextHash = def; | |
| } | |
| } | |
| } | |
| /** | |
| * xmlRelaxNGParseImportRefs: | |
| * @ctxt: the parser context | |
| * @grammar: the sub grammar | |
| * | |
| * Import references from the subgrammar into the current grammar | |
| * | |
| * Returns 0 in case of success, -1 in case of failure | |
| */ | |
| static int | |
| xmlRelaxNGParseImportRefs(xmlRelaxNGParserCtxtPtr ctxt, | |
| xmlRelaxNGGrammarPtr grammar) { | |
| if ((ctxt == NULL) || (grammar == NULL) || (ctxt->grammar == NULL)) | |
| return(-1); | |
| if (grammar->refs == NULL) | |
| return(0); | |
| if (ctxt->grammar->refs == NULL) | |
| ctxt->grammar->refs = xmlHashCreate(10); | |
| if (ctxt->grammar->refs == NULL) { | |
| xmlRngPErr(ctxt, NULL, XML_RNGP_REF_CREATE_FAILED, | |
| "Could not create references hash\n", NULL, NULL); | |
| return(-1); | |
| } | |
| xmlHashScan(grammar->refs, xmlRelaxNGParseImportRef, ctxt); | |
| return(0); | |
| } | |
| /** | |
| * xmlRelaxNGProcessExternalRef: | |
| * @ctxt: the parser context | |
| * @node: the externlRef node | |
| * | |
| * Process and compile an externlRef node | |
| * | |
| * Returns the xmlRelaxNGDefinePtr or NULL in case of error | |
| */ | |
| static xmlRelaxNGDefinePtr | |
| xmlRelaxNGProcessExternalRef(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node) | |
| { | |
| xmlRelaxNGDocumentPtr docu; | |
| xmlNodePtr root, tmp; | |
| xmlChar *ns; | |
| int newNs = 0, oldflags; | |
| xmlRelaxNGDefinePtr def; | |
| docu = node->psvi; | |
| if (docu != NULL) { | |
| def = xmlRelaxNGNewDefine(ctxt, node); | |
| if (def == NULL) | |
| return (NULL); | |
| def->type = XML_RELAXNG_EXTERNALREF; | |
| if (docu->content == NULL) { | |
| /* | |
| * Then do the parsing for good | |
| */ | |
| root = xmlDocGetRootElement(docu->doc); | |
| if (root == NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_EXTERNALREF_EMTPY, | |
| "xmlRelaxNGParse: %s is empty\n", ctxt->URL, | |
| NULL); | |
| return (NULL); | |
| } | |
| /* | |
| * ns transmission rules | |
| */ | |
| ns = xmlGetProp(root, BAD_CAST "ns"); | |
| if (ns == NULL) { | |
| tmp = node; | |
| while ((tmp != NULL) && (tmp->type == XML_ELEMENT_NODE)) { | |
| ns = xmlGetProp(tmp, BAD_CAST "ns"); | |
| if (ns != NULL) { | |
| break; | |
| } | |
| tmp = tmp->parent; | |
| } | |
| if (ns != NULL) { | |
| xmlSetProp(root, BAD_CAST "ns", ns); | |
| newNs = 1; | |
| xmlFree(ns); | |
| } | |
| } else { | |
| xmlFree(ns); | |
| } | |
| /* | |
| * Parsing to get a precompiled schemas. | |
| */ | |
| oldflags = ctxt->flags; | |
| ctxt->flags |= XML_RELAXNG_IN_EXTERNALREF; | |
| docu->schema = xmlRelaxNGParseDocument(ctxt, root); | |
| ctxt->flags = oldflags; | |
| if ((docu->schema != NULL) && | |
| (docu->schema->topgrammar != NULL)) { | |
| docu->content = docu->schema->topgrammar->start; | |
| if (docu->schema->topgrammar->refs) | |
| xmlRelaxNGParseImportRefs(ctxt, docu->schema->topgrammar); | |
| } | |
| /* | |
| * the externalRef may be reused in a different ns context | |
| */ | |
| if (newNs == 1) { | |
| xmlUnsetProp(root, BAD_CAST "ns"); | |
| } | |
| } | |
| def->content = docu->content; | |
| } else { | |
| def = NULL; | |
| } | |
| return (def); | |
| } | |
| /** | |
| * xmlRelaxNGParsePattern: | |
| * @ctxt: a Relax-NG parser context | |
| * @node: the pattern node. | |
| * | |
| * parse the content of a RelaxNG pattern node. | |
| * | |
| * Returns the definition pointer or NULL in case of error or if no | |
| * pattern is generated. | |
| */ | |
| static xmlRelaxNGDefinePtr | |
| xmlRelaxNGParsePattern(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node) | |
| { | |
| xmlRelaxNGDefinePtr def = NULL; | |
| if (node == NULL) { | |
| return (NULL); | |
| } | |
| if (IS_RELAXNG(node, "element")) { | |
| def = xmlRelaxNGParseElement(ctxt, node); | |
| } else if (IS_RELAXNG(node, "attribute")) { | |
| def = xmlRelaxNGParseAttribute(ctxt, node); | |
| } else if (IS_RELAXNG(node, "empty")) { | |
| def = xmlRelaxNGNewDefine(ctxt, node); | |
| if (def == NULL) | |
| return (NULL); | |
| def->type = XML_RELAXNG_EMPTY; | |
| if (node->children != NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_NOT_EMPTY, | |
| "empty: had a child node\n", NULL, NULL); | |
| } | |
| } else if (IS_RELAXNG(node, "text")) { | |
| def = xmlRelaxNGNewDefine(ctxt, node); | |
| if (def == NULL) | |
| return (NULL); | |
| def->type = XML_RELAXNG_TEXT; | |
| if (node->children != NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_TEXT_HAS_CHILD, | |
| "text: had a child node\n", NULL, NULL); | |
| } | |
| } else if (IS_RELAXNG(node, "zeroOrMore")) { | |
| def = xmlRelaxNGNewDefine(ctxt, node); | |
| if (def == NULL) | |
| return (NULL); | |
| def->type = XML_RELAXNG_ZEROORMORE; | |
| if (node->children == NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT, | |
| "Element %s is empty\n", node->name, NULL); | |
| } else { | |
| def->content = | |
| xmlRelaxNGParsePatterns(ctxt, node->children, 1); | |
| } | |
| } else if (IS_RELAXNG(node, "oneOrMore")) { | |
| def = xmlRelaxNGNewDefine(ctxt, node); | |
| if (def == NULL) | |
| return (NULL); | |
| def->type = XML_RELAXNG_ONEORMORE; | |
| if (node->children == NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT, | |
| "Element %s is empty\n", node->name, NULL); | |
| } else { | |
| def->content = | |
| xmlRelaxNGParsePatterns(ctxt, node->children, 1); | |
| } | |
| } else if (IS_RELAXNG(node, "optional")) { | |
| def = xmlRelaxNGNewDefine(ctxt, node); | |
| if (def == NULL) | |
| return (NULL); | |
| def->type = XML_RELAXNG_OPTIONAL; | |
| if (node->children == NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT, | |
| "Element %s is empty\n", node->name, NULL); | |
| } else { | |
| def->content = | |
| xmlRelaxNGParsePatterns(ctxt, node->children, 1); | |
| } | |
| } else if (IS_RELAXNG(node, "choice")) { | |
| def = xmlRelaxNGNewDefine(ctxt, node); | |
| if (def == NULL) | |
| return (NULL); | |
| def->type = XML_RELAXNG_CHOICE; | |
| if (node->children == NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT, | |
| "Element %s is empty\n", node->name, NULL); | |
| } else { | |
| def->content = | |
| xmlRelaxNGParsePatterns(ctxt, node->children, 0); | |
| } | |
| } else if (IS_RELAXNG(node, "group")) { | |
| def = xmlRelaxNGNewDefine(ctxt, node); | |
| if (def == NULL) | |
| return (NULL); | |
| def->type = XML_RELAXNG_GROUP; | |
| if (node->children == NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT, | |
| "Element %s is empty\n", node->name, NULL); | |
| } else { | |
| def->content = | |
| xmlRelaxNGParsePatterns(ctxt, node->children, 0); | |
| } | |
| } else if (IS_RELAXNG(node, "ref")) { | |
| def = xmlRelaxNGNewDefine(ctxt, node); | |
| if (def == NULL) | |
| return (NULL); | |
| def->type = XML_RELAXNG_REF; | |
| def->name = xmlGetProp(node, BAD_CAST "name"); | |
| if (def->name == NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_REF_NO_NAME, "ref has no name\n", | |
| NULL, NULL); | |
| } else { | |
| xmlRelaxNGNormExtSpace(def->name); | |
| if (xmlValidateNCName(def->name, 0)) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_REF_NAME_INVALID, | |
| "ref name '%s' is not an NCName\n", def->name, | |
| NULL); | |
| } | |
| } | |
| if (node->children != NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_REF_NOT_EMPTY, "ref is not empty\n", | |
| NULL, NULL); | |
| } | |
| if (ctxt->grammar->refs == NULL) | |
| ctxt->grammar->refs = xmlHashCreate(10); | |
| if (ctxt->grammar->refs == NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_REF_CREATE_FAILED, | |
| "Could not create references hash\n", NULL, NULL); | |
| def = NULL; | |
| } else { | |
| int tmp; | |
| tmp = xmlHashAddEntry(ctxt->grammar->refs, def->name, def); | |
| if (tmp < 0) { | |
| xmlRelaxNGDefinePtr prev; | |
| prev = (xmlRelaxNGDefinePtr) | |
| xmlHashLookup(ctxt->grammar->refs, def->name); | |
| if (prev == NULL) { | |
| if (def->name != NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_REF_CREATE_FAILED, | |
| "Error refs definitions '%s'\n", | |
| def->name, NULL); | |
| } else { | |
| xmlRngPErr(ctxt, node, XML_RNGP_REF_CREATE_FAILED, | |
| "Error refs definitions\n", | |
| NULL, NULL); | |
| } | |
| def = NULL; | |
| } else { | |
| def->nextHash = prev->nextHash; | |
| prev->nextHash = def; | |
| } | |
| } | |
| } | |
| } else if (IS_RELAXNG(node, "data")) { | |
| def = xmlRelaxNGParseData(ctxt, node); | |
| } else if (IS_RELAXNG(node, "value")) { | |
| def = xmlRelaxNGParseValue(ctxt, node); | |
| } else if (IS_RELAXNG(node, "list")) { | |
| def = xmlRelaxNGNewDefine(ctxt, node); | |
| if (def == NULL) | |
| return (NULL); | |
| def->type = XML_RELAXNG_LIST; | |
| if (node->children == NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT, | |
| "Element %s is empty\n", node->name, NULL); | |
| } else { | |
| def->content = | |
| xmlRelaxNGParsePatterns(ctxt, node->children, 0); | |
| } | |
| } else if (IS_RELAXNG(node, "interleave")) { | |
| def = xmlRelaxNGParseInterleave(ctxt, node); | |
| } else if (IS_RELAXNG(node, "externalRef")) { | |
| def = xmlRelaxNGProcessExternalRef(ctxt, node); | |
| } else if (IS_RELAXNG(node, "notAllowed")) { | |
| def = xmlRelaxNGNewDefine(ctxt, node); | |
| if (def == NULL) | |
| return (NULL); | |
| def->type = XML_RELAXNG_NOT_ALLOWED; | |
| if (node->children != NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_NOTALLOWED_NOT_EMPTY, | |
| "xmlRelaxNGParse: notAllowed element is not empty\n", | |
| NULL, NULL); | |
| } | |
| } else if (IS_RELAXNG(node, "grammar")) { | |
| xmlRelaxNGGrammarPtr grammar, old; | |
| xmlRelaxNGGrammarPtr oldparent; | |
| #ifdef DEBUG_GRAMMAR | |
| xmlGenericError(xmlGenericErrorContext, | |
| "Found <grammar> pattern\n"); | |
| #endif | |
| oldparent = ctxt->parentgrammar; | |
| old = ctxt->grammar; | |
| ctxt->parentgrammar = old; | |
| grammar = xmlRelaxNGParseGrammar(ctxt, node->children); | |
| if (old != NULL) { | |
| ctxt->grammar = old; | |
| ctxt->parentgrammar = oldparent; | |
| #if 0 | |
| if (grammar != NULL) { | |
| grammar->next = old->next; | |
| old->next = grammar; | |
| } | |
| #endif | |
| } | |
| if (grammar != NULL) | |
| def = grammar->start; | |
| else | |
| def = NULL; | |
| } else if (IS_RELAXNG(node, "parentRef")) { | |
| if (ctxt->parentgrammar == NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_NO_PARENT, | |
| "Use of parentRef without a parent grammar\n", NULL, | |
| NULL); | |
| return (NULL); | |
| } | |
| def = xmlRelaxNGNewDefine(ctxt, node); | |
| if (def == NULL) | |
| return (NULL); | |
| def->type = XML_RELAXNG_PARENTREF; | |
| def->name = xmlGetProp(node, BAD_CAST "name"); | |
| if (def->name == NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_NO_NAME, | |
| "parentRef has no name\n", NULL, NULL); | |
| } else { | |
| xmlRelaxNGNormExtSpace(def->name); | |
| if (xmlValidateNCName(def->name, 0)) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_NAME_INVALID, | |
| "parentRef name '%s' is not an NCName\n", | |
| def->name, NULL); | |
| } | |
| } | |
| if (node->children != NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_NOT_EMPTY, | |
| "parentRef is not empty\n", NULL, NULL); | |
| } | |
| if (ctxt->parentgrammar->refs == NULL) | |
| ctxt->parentgrammar->refs = xmlHashCreate(10); | |
| if (ctxt->parentgrammar->refs == NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_CREATE_FAILED, | |
| "Could not create references hash\n", NULL, NULL); | |
| def = NULL; | |
| } else if (def->name != NULL) { | |
| int tmp; | |
| tmp = | |
| xmlHashAddEntry(ctxt->parentgrammar->refs, def->name, def); | |
| if (tmp < 0) { | |
| xmlRelaxNGDefinePtr prev; | |
| prev = (xmlRelaxNGDefinePtr) | |
| xmlHashLookup(ctxt->parentgrammar->refs, def->name); | |
| if (prev == NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_PARENTREF_CREATE_FAILED, | |
| "Internal error parentRef definitions '%s'\n", | |
| def->name, NULL); | |
| def = NULL; | |
| } else { | |
| def->nextHash = prev->nextHash; | |
| prev->nextHash = def; | |
| } | |
| } | |
| } | |
| } else if (IS_RELAXNG(node, "mixed")) { | |
| if (node->children == NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_EMPTY_CONSTRUCT, "Mixed is empty\n", | |
| NULL, NULL); | |
| def = NULL; | |
| } else { | |
| def = xmlRelaxNGParseInterleave(ctxt, node); | |
| if (def != NULL) { | |
| xmlRelaxNGDefinePtr tmp; | |
| if ((def->content != NULL) && (def->content->next != NULL)) { | |
| tmp = xmlRelaxNGNewDefine(ctxt, node); | |
| if (tmp != NULL) { | |
| tmp->type = XML_RELAXNG_GROUP; | |
| tmp->content = def->content; | |
| def->content = tmp; | |
| } | |
| } | |
| tmp = xmlRelaxNGNewDefine(ctxt, node); | |
| if (tmp == NULL) | |
| return (def); | |
| tmp->type = XML_RELAXNG_TEXT; | |
| tmp->next = def->content; | |
| def->content = tmp; | |
| } | |
| } | |
| } else { | |
| xmlRngPErr(ctxt, node, XML_RNGP_UNKNOWN_CONSTRUCT, | |
| "Unexpected node %s is not a pattern\n", node->name, | |
| NULL); | |
| def = NULL; | |
| } | |
| return (def); | |
| } | |
| /** | |
| * xmlRelaxNGParseAttribute: | |
| * @ctxt: a Relax-NG parser context | |
| * @node: the element node | |
| * | |
| * parse the content of a RelaxNG attribute node. | |
| * | |
| * Returns the definition pointer or NULL in case of error. | |
| */ | |
| static xmlRelaxNGDefinePtr | |
| xmlRelaxNGParseAttribute(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node) | |
| { | |
| xmlRelaxNGDefinePtr ret, cur; | |
| xmlNodePtr child; | |
| int old_flags; | |
| ret = xmlRelaxNGNewDefine(ctxt, node); | |
| if (ret == NULL) | |
| return (NULL); | |
| ret->type = XML_RELAXNG_ATTRIBUTE; | |
| ret->parent = ctxt->def; | |
| child = node->children; | |
| if (child == NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_ATTRIBUTE_EMPTY, | |
| "xmlRelaxNGParseattribute: attribute has no children\n", | |
| NULL, NULL); | |
| return (ret); | |
| } | |
| old_flags = ctxt->flags; | |
| ctxt->flags |= XML_RELAXNG_IN_ATTRIBUTE; | |
| cur = xmlRelaxNGParseNameClass(ctxt, child, ret); | |
| if (cur != NULL) | |
| child = child->next; | |
| if (child != NULL) { | |
| cur = xmlRelaxNGParsePattern(ctxt, child); | |
| if (cur != NULL) { | |
| switch (cur->type) { | |
| case XML_RELAXNG_EMPTY: | |
| case XML_RELAXNG_NOT_ALLOWED: | |
| case XML_RELAXNG_TEXT: | |
| case XML_RELAXNG_ELEMENT: | |
| case XML_RELAXNG_DATATYPE: | |
| case XML_RELAXNG_VALUE: | |
| case XML_RELAXNG_LIST: | |
| case XML_RELAXNG_REF: | |
| case XML_RELAXNG_PARENTREF: | |
| case XML_RELAXNG_EXTERNALREF: | |
| case XML_RELAXNG_DEF: | |
| case XML_RELAXNG_ONEORMORE: | |
| case XML_RELAXNG_ZEROORMORE: | |
| case XML_RELAXNG_OPTIONAL: | |
| case XML_RELAXNG_CHOICE: | |
| case XML_RELAXNG_GROUP: | |
| case XML_RELAXNG_INTERLEAVE: | |
| case XML_RELAXNG_ATTRIBUTE: | |
| ret->content = cur; | |
| cur->parent = ret; | |
| break; | |
| case XML_RELAXNG_START: | |
| case XML_RELAXNG_PARAM: | |
| case XML_RELAXNG_EXCEPT: | |
| xmlRngPErr(ctxt, node, XML_RNGP_ATTRIBUTE_CONTENT, | |
| "attribute has invalid content\n", NULL, | |
| NULL); | |
| break; | |
| case XML_RELAXNG_NOOP: | |
| xmlRngPErr(ctxt, node, XML_RNGP_ATTRIBUTE_NOOP, | |
| "RNG Internal error, noop found in attribute\n", | |
| NULL, NULL); | |
| break; | |
| } | |
| } | |
| child = child->next; | |
| } | |
| if (child != NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_ATTRIBUTE_CHILDREN, | |
| "attribute has multiple children\n", NULL, NULL); | |
| } | |
| ctxt->flags = old_flags; | |
| return (ret); | |
| } | |
| /** | |
| * xmlRelaxNGParseExceptNameClass: | |
| * @ctxt: a Relax-NG parser context | |
| * @node: the except node | |
| * @attr: 1 if within an attribute, 0 if within an element | |
| * | |
| * parse the content of a RelaxNG nameClass node. | |
| * | |
| * Returns the definition pointer or NULL in case of error. | |
| */ | |
| static xmlRelaxNGDefinePtr | |
| xmlRelaxNGParseExceptNameClass(xmlRelaxNGParserCtxtPtr ctxt, | |
| xmlNodePtr node, int attr) | |
| { | |
| xmlRelaxNGDefinePtr ret, cur, last = NULL; | |
| xmlNodePtr child; | |
| if (!IS_RELAXNG(node, "except")) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_EXCEPT_MISSING, | |
| "Expecting an except node\n", NULL, NULL); | |
| return (NULL); | |
| } | |
| if (node->next != NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_EXCEPT_MULTIPLE, | |
| "exceptNameClass allows only a single except node\n", | |
| NULL, NULL); | |
| } | |
| if (node->children == NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_EXCEPT_EMPTY, "except has no content\n", | |
| NULL, NULL); | |
| return (NULL); | |
| } | |
| ret = xmlRelaxNGNewDefine(ctxt, node); | |
| if (ret == NULL) | |
| return (NULL); | |
| ret->type = XML_RELAXNG_EXCEPT; | |
| child = node->children; | |
| while (child != NULL) { | |
| cur = xmlRelaxNGNewDefine(ctxt, child); | |
| if (cur == NULL) | |
| break; | |
| if (attr) | |
| cur->type = XML_RELAXNG_ATTRIBUTE; | |
| else | |
| cur->type = XML_RELAXNG_ELEMENT; | |
| if (xmlRelaxNGParseNameClass(ctxt, child, cur) != NULL) { | |
| if (last == NULL) { | |
| ret->content = cur; | |
| } else { | |
| last->next = cur; | |
| } | |
| last = cur; | |
| } | |
| child = child->next; | |
| } | |
| return (ret); | |
| } | |
| /** | |
| * xmlRelaxNGParseNameClass: | |
| * @ctxt: a Relax-NG parser context | |
| * @node: the nameClass node | |
| * @def: the current definition | |
| * | |
| * parse the content of a RelaxNG nameClass node. | |
| * | |
| * Returns the definition pointer or NULL in case of error. | |
| */ | |
| static xmlRelaxNGDefinePtr | |
| xmlRelaxNGParseNameClass(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node, | |
| xmlRelaxNGDefinePtr def) | |
| { | |
| xmlRelaxNGDefinePtr ret, tmp; | |
| xmlChar *val; | |
| ret = def; | |
| if ((IS_RELAXNG(node, "name")) || (IS_RELAXNG(node, "anyName")) || | |
| (IS_RELAXNG(node, "nsName"))) { | |
| if ((def->type != XML_RELAXNG_ELEMENT) && | |
| (def->type != XML_RELAXNG_ATTRIBUTE)) { | |
| ret = xmlRelaxNGNewDefine(ctxt, node); | |
| if (ret == NULL) | |
| return (NULL); | |
| ret->parent = def; | |
| if (ctxt->flags & XML_RELAXNG_IN_ATTRIBUTE) | |
| ret->type = XML_RELAXNG_ATTRIBUTE; | |
| else | |
| ret->type = XML_RELAXNG_ELEMENT; | |
| } | |
| } | |
| if (IS_RELAXNG(node, "name")) { | |
| val = xmlNodeGetContent(node); | |
| xmlRelaxNGNormExtSpace(val); | |
| if (xmlValidateNCName(val, 0)) { | |
| if (node->parent != NULL) | |
| xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_NAME, | |
| "Element %s name '%s' is not an NCName\n", | |
| node->parent->name, val); | |
| else | |
| xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_NAME, | |
| "name '%s' is not an NCName\n", | |
| val, NULL); | |
| } | |
| ret->name = val; | |
| val = xmlGetProp(node, BAD_CAST "ns"); | |
| ret->ns = val; | |
| if ((ctxt->flags & XML_RELAXNG_IN_ATTRIBUTE) && | |
| (val != NULL) && | |
| (xmlStrEqual(val, BAD_CAST "http://www.w3.org/2000/xmlns"))) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_XML_NS, | |
| "Attribute with namespace '%s' is not allowed\n", | |
| val, NULL); | |
| } | |
| if ((ctxt->flags & XML_RELAXNG_IN_ATTRIBUTE) && | |
| (val != NULL) && | |
| (val[0] == 0) && (xmlStrEqual(ret->name, BAD_CAST "xmlns"))) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_XMLNS_NAME, | |
| "Attribute with QName 'xmlns' is not allowed\n", | |
| val, NULL); | |
| } | |
| } else if (IS_RELAXNG(node, "anyName")) { | |
| ret->name = NULL; | |
| ret->ns = NULL; | |
| if (node->children != NULL) { | |
| ret->nameClass = | |
| xmlRelaxNGParseExceptNameClass(ctxt, node->children, | |
| (def->type == | |
| XML_RELAXNG_ATTRIBUTE)); | |
| } | |
| } else if (IS_RELAXNG(node, "nsName")) { | |
| ret->name = NULL; | |
| ret->ns = xmlGetProp(node, BAD_CAST "ns"); | |
| if (ret->ns == NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_NSNAME_NO_NS, | |
| "nsName has no ns attribute\n", NULL, NULL); | |
| } | |
| if ((ctxt->flags & XML_RELAXNG_IN_ATTRIBUTE) && | |
| (ret->ns != NULL) && | |
| (xmlStrEqual | |
| (ret->ns, BAD_CAST "http://www.w3.org/2000/xmlns"))) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_XML_NS, | |
| "Attribute with namespace '%s' is not allowed\n", | |
| ret->ns, NULL); | |
| } | |
| if (node->children != NULL) { | |
| ret->nameClass = | |
| xmlRelaxNGParseExceptNameClass(ctxt, node->children, | |
| (def->type == | |
| XML_RELAXNG_ATTRIBUTE)); | |
| } | |
| } else if (IS_RELAXNG(node, "choice")) { | |
| xmlNodePtr child; | |
| xmlRelaxNGDefinePtr last = NULL; | |
| ret = xmlRelaxNGNewDefine(ctxt, node); | |
| if (ret == NULL) | |
| return (NULL); | |
| ret->parent = def; | |
| ret->type = XML_RELAXNG_CHOICE; | |
| if (node->children == NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_CHOICE_EMPTY, | |
| "Element choice is empty\n", NULL, NULL); | |
| } else { | |
| child = node->children; | |
| while (child != NULL) { | |
| tmp = xmlRelaxNGParseNameClass(ctxt, child, ret); | |
| if (tmp != NULL) { | |
| if (last == NULL) { | |
| last = ret->nameClass = tmp; | |
| } else { | |
| last->next = tmp; | |
| last = tmp; | |
| } | |
| } | |
| child = child->next; | |
| } | |
| } | |
| } else { | |
| xmlRngPErr(ctxt, node, XML_RNGP_CHOICE_CONTENT, | |
| "expecting name, anyName, nsName or choice : got %s\n", | |
| (node == NULL ? (const xmlChar *) "nothing" : node->name), | |
| NULL); | |
| return (NULL); | |
| } | |
| if (ret != def) { | |
| if (def->nameClass == NULL) { | |
| def->nameClass = ret; | |
| } else { | |
| tmp = def->nameClass; | |
| while (tmp->next != NULL) { | |
| tmp = tmp->next; | |
| } | |
| tmp->next = ret; | |
| } | |
| } | |
| return (ret); | |
| } | |
| /** | |
| * xmlRelaxNGParseElement: | |
| * @ctxt: a Relax-NG parser context | |
| * @node: the element node | |
| * | |
| * parse the content of a RelaxNG element node. | |
| * | |
| * Returns the definition pointer or NULL in case of error. | |
| */ | |
| static xmlRelaxNGDefinePtr | |
| xmlRelaxNGParseElement(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node) | |
| { | |
| xmlRelaxNGDefinePtr ret, cur, last; | |
| xmlNodePtr child; | |
| const xmlChar *olddefine; | |
| ret = xmlRelaxNGNewDefine(ctxt, node); | |
| if (ret == NULL) | |
| return (NULL); | |
| ret->type = XML_RELAXNG_ELEMENT; | |
| ret->parent = ctxt->def; | |
| child = node->children; | |
| if (child == NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_EMPTY, | |
| "xmlRelaxNGParseElement: element has no children\n", | |
| NULL, NULL); | |
| return (ret); | |
| } | |
| cur = xmlRelaxNGParseNameClass(ctxt, child, ret); | |
| if (cur != NULL) | |
| child = child->next; | |
| if (child == NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_NO_CONTENT, | |
| "xmlRelaxNGParseElement: element has no content\n", | |
| NULL, NULL); | |
| return (ret); | |
| } | |
| olddefine = ctxt->define; | |
| ctxt->define = NULL; | |
| last = NULL; | |
| while (child != NULL) { | |
| cur = xmlRelaxNGParsePattern(ctxt, child); | |
| if (cur != NULL) { | |
| cur->parent = ret; | |
| switch (cur->type) { | |
| case XML_RELAXNG_EMPTY: | |
| case XML_RELAXNG_NOT_ALLOWED: | |
| case XML_RELAXNG_TEXT: | |
| case XML_RELAXNG_ELEMENT: | |
| case XML_RELAXNG_DATATYPE: | |
| case XML_RELAXNG_VALUE: | |
| case XML_RELAXNG_LIST: | |
| case XML_RELAXNG_REF: | |
| case XML_RELAXNG_PARENTREF: | |
| case XML_RELAXNG_EXTERNALREF: | |
| case XML_RELAXNG_DEF: | |
| case XML_RELAXNG_ZEROORMORE: | |
| case XML_RELAXNG_ONEORMORE: | |
| case XML_RELAXNG_OPTIONAL: | |
| case XML_RELAXNG_CHOICE: | |
| case XML_RELAXNG_GROUP: | |
| case XML_RELAXNG_INTERLEAVE: | |
| if (last == NULL) { | |
| ret->content = last = cur; | |
| } else { | |
| if ((last->type == XML_RELAXNG_ELEMENT) && | |
| (ret->content == last)) { | |
| ret->content = xmlRelaxNGNewDefine(ctxt, node); | |
| if (ret->content != NULL) { | |
| ret->content->type = XML_RELAXNG_GROUP; | |
| ret->content->content = last; | |
| } else { | |
| ret->content = last; | |
| } | |
| } | |
| last->next = cur; | |
| last = cur; | |
| } | |
| break; | |
| case XML_RELAXNG_ATTRIBUTE: | |
| cur->next = ret->attrs; | |
| ret->attrs = cur; | |
| break; | |
| case XML_RELAXNG_START: | |
| xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_CONTENT, | |
| "RNG Internal error, start found in element\n", | |
| NULL, NULL); | |
| break; | |
| case XML_RELAXNG_PARAM: | |
| xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_CONTENT, | |
| "RNG Internal error, param found in element\n", | |
| NULL, NULL); | |
| break; | |
| case XML_RELAXNG_EXCEPT: | |
| xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_CONTENT, | |
| "RNG Internal error, except found in element\n", | |
| NULL, NULL); | |
| break; | |
| case XML_RELAXNG_NOOP: | |
| xmlRngPErr(ctxt, node, XML_RNGP_ELEMENT_CONTENT, | |
| "RNG Internal error, noop found in element\n", | |
| NULL, NULL); | |
| break; | |
| } | |
| } | |
| child = child->next; | |
| } | |
| ctxt->define = olddefine; | |
| return (ret); | |
| } | |
| /** | |
| * xmlRelaxNGParsePatterns: | |
| * @ctxt: a Relax-NG parser context | |
| * @nodes: list of nodes | |
| * @group: use an implicit <group> for elements | |
| * | |
| * parse the content of a RelaxNG start node. | |
| * | |
| * Returns the definition pointer or NULL in case of error. | |
| */ | |
| static xmlRelaxNGDefinePtr | |
| xmlRelaxNGParsePatterns(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr nodes, | |
| int group) | |
| { | |
| xmlRelaxNGDefinePtr def = NULL, last = NULL, cur, parent; | |
| parent = ctxt->def; | |
| while (nodes != NULL) { | |
| if (IS_RELAXNG(nodes, "element")) { | |
| cur = xmlRelaxNGParseElement(ctxt, nodes); | |
| if (def == NULL) { | |
| def = last = cur; | |
| } else { | |
| if ((group == 1) && (def->type == XML_RELAXNG_ELEMENT) && | |
| (def == last)) { | |
| def = xmlRelaxNGNewDefine(ctxt, nodes); | |
| def->type = XML_RELAXNG_GROUP; | |
| def->content = last; | |
| } | |
| last->next = cur; | |
| last = cur; | |
| } | |
| cur->parent = parent; | |
| } else { | |
| cur = xmlRelaxNGParsePattern(ctxt, nodes); | |
| if (cur != NULL) { | |
| if (def == NULL) { | |
| def = last = cur; | |
| } else { | |
| last->next = cur; | |
| last = cur; | |
| } | |
| } | |
| } | |
| nodes = nodes->next; | |
| } | |
| return (def); | |
| } | |
| /** | |
| * xmlRelaxNGParseStart: | |
| * @ctxt: a Relax-NG parser context | |
| * @nodes: start children nodes | |
| * | |
| * parse the content of a RelaxNG start node. | |
| * | |
| * Returns 0 in case of success, -1 in case of error | |
| */ | |
| static int | |
| xmlRelaxNGParseStart(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr nodes) | |
| { | |
| int ret = 0; | |
| xmlRelaxNGDefinePtr def = NULL, last; | |
| if (nodes == NULL) { | |
| xmlRngPErr(ctxt, nodes, XML_RNGP_START_EMPTY, "start has no children\n", | |
| NULL, NULL); | |
| return (-1); | |
| } | |
| if (IS_RELAXNG(nodes, "empty")) { | |
| def = xmlRelaxNGNewDefine(ctxt, nodes); | |
| if (def == NULL) | |
| return (-1); | |
| def->type = XML_RELAXNG_EMPTY; | |
| if (nodes->children != NULL) { | |
| xmlRngPErr(ctxt, nodes, XML_RNGP_EMPTY_CONTENT, | |
| "element empty is not empty\n", NULL, NULL); | |
| } | |
| } else if (IS_RELAXNG(nodes, "notAllowed")) { | |
| def = xmlRelaxNGNewDefine(ctxt, nodes); | |
| if (def == NULL) | |
| return (-1); | |
| def->type = XML_RELAXNG_NOT_ALLOWED; | |
| if (nodes->children != NULL) { | |
| xmlRngPErr(ctxt, nodes, XML_RNGP_NOTALLOWED_NOT_EMPTY, | |
| "element notAllowed is not empty\n", NULL, NULL); | |
| } | |
| } else { | |
| def = xmlRelaxNGParsePatterns(ctxt, nodes, 1); | |
| } | |
| if (ctxt->grammar->start != NULL) { | |
| last = ctxt->grammar->start; | |
| while (last->next != NULL) | |
| last = last->next; | |
| last->next = def; | |
| } else { | |
| ctxt->grammar->start = def; | |
| } | |
| nodes = nodes->next; | |
| if (nodes != NULL) { | |
| xmlRngPErr(ctxt, nodes, XML_RNGP_START_CONTENT, | |
| "start more than one children\n", NULL, NULL); | |
| return (-1); | |
| } | |
| return (ret); | |
| } | |
| /** | |
| * xmlRelaxNGParseGrammarContent: | |
| * @ctxt: a Relax-NG parser context | |
| * @nodes: grammar children nodes | |
| * | |
| * parse the content of a RelaxNG grammar node. | |
| * | |
| * Returns 0 in case of success, -1 in case of error | |
| */ | |
| static int | |
| xmlRelaxNGParseGrammarContent(xmlRelaxNGParserCtxtPtr ctxt, | |
| xmlNodePtr nodes) | |
| { | |
| int ret = 0, tmp; | |
| if (nodes == NULL) { | |
| xmlRngPErr(ctxt, nodes, XML_RNGP_GRAMMAR_EMPTY, | |
| "grammar has no children\n", NULL, NULL); | |
| return (-1); | |
| } | |
| while (nodes != NULL) { | |
| if (IS_RELAXNG(nodes, "start")) { | |
| if (nodes->children == NULL) { | |
| xmlRngPErr(ctxt, nodes, XML_RNGP_START_EMPTY, | |
| "start has no children\n", NULL, NULL); | |
| } else { | |
| tmp = xmlRelaxNGParseStart(ctxt, nodes->children); | |
| if (tmp != 0) | |
| ret = -1; | |
| } | |
| } else if (IS_RELAXNG(nodes, "define")) { | |
| tmp = xmlRelaxNGParseDefine(ctxt, nodes); | |
| if (tmp != 0) | |
| ret = -1; | |
| } else if (IS_RELAXNG(nodes, "include")) { | |
| tmp = xmlRelaxNGParseInclude(ctxt, nodes); | |
| if (tmp != 0) | |
| ret = -1; | |
| } else { | |
| xmlRngPErr(ctxt, nodes, XML_RNGP_GRAMMAR_CONTENT, | |
| "grammar has unexpected child %s\n", nodes->name, | |
| NULL); | |
| ret = -1; | |
| } | |
| nodes = nodes->next; | |
| } | |
| return (ret); | |
| } | |
| /** | |
| * xmlRelaxNGCheckReference: | |
| * @ref: the ref | |
| * @ctxt: a Relax-NG parser context | |
| * @name: the name associated to the defines | |
| * | |
| * Applies the 4.17. combine attribute rule for all the define | |
| * element of a given grammar using the same name. | |
| */ | |
| static void | |
| xmlRelaxNGCheckReference(xmlRelaxNGDefinePtr ref, | |
| xmlRelaxNGParserCtxtPtr ctxt, | |
| const xmlChar * name) | |
| { | |
| xmlRelaxNGGrammarPtr grammar; | |
| xmlRelaxNGDefinePtr def, cur; | |
| /* | |
| * Those rules don't apply to imported ref from xmlRelaxNGParseImportRef | |
| */ | |
| if (ref->dflags & IS_EXTERNAL_REF) | |
| return; | |
| grammar = ctxt->grammar; | |
| if (grammar == NULL) { | |
| xmlRngPErr(ctxt, ref->node, XML_ERR_INTERNAL_ERROR, | |
| "Internal error: no grammar in CheckReference %s\n", | |
| name, NULL); | |
| return; | |
| } | |
| if (ref->content != NULL) { | |
| xmlRngPErr(ctxt, ref->node, XML_ERR_INTERNAL_ERROR, | |
| "Internal error: reference has content in CheckReference %s\n", | |
| name, NULL); | |
| return; | |
| } | |
| if (grammar->defs != NULL) { | |
| def = xmlHashLookup(grammar->defs, name); | |
| if (def != NULL) { | |
| cur = ref; | |
| while (cur != NULL) { | |
| cur->content = def; | |
| cur = cur->nextHash; | |
| } | |
| } else { | |
| xmlRngPErr(ctxt, ref->node, XML_RNGP_REF_NO_DEF, | |
| "Reference %s has no matching definition\n", name, | |
| NULL); | |
| } | |
| } else { | |
| xmlRngPErr(ctxt, ref->node, XML_RNGP_REF_NO_DEF, | |
| "Reference %s has no matching definition\n", name, | |
| NULL); | |
| } | |
| } | |
| /** | |
| * xmlRelaxNGCheckCombine: | |
| * @define: the define(s) list | |
| * @ctxt: a Relax-NG parser context | |
| * @name: the name associated to the defines | |
| * | |
| * Applies the 4.17. combine attribute rule for all the define | |
| * element of a given grammar using the same name. | |
| */ | |
| static void | |
| xmlRelaxNGCheckCombine(xmlRelaxNGDefinePtr define, | |
| xmlRelaxNGParserCtxtPtr ctxt, const xmlChar * name) | |
| { | |
| xmlChar *combine; | |
| int choiceOrInterleave = -1; | |
| int missing = 0; | |
| xmlRelaxNGDefinePtr cur, last, tmp, tmp2; | |
| if (define->nextHash == NULL) | |
| return; | |
| cur = define; | |
| while (cur != NULL) { | |
| combine = xmlGetProp(cur->node, BAD_CAST "combine"); | |
| if (combine != NULL) { | |
| if (xmlStrEqual(combine, BAD_CAST "choice")) { | |
| if (choiceOrInterleave == -1) | |
| choiceOrInterleave = 1; | |
| else if (choiceOrInterleave == 0) { | |
| xmlRngPErr(ctxt, define->node, XML_RNGP_DEF_CHOICE_AND_INTERLEAVE, | |
| "Defines for %s use both 'choice' and 'interleave'\n", | |
| name, NULL); | |
| } | |
| } else if (xmlStrEqual(combine, BAD_CAST "interleave")) { | |
| if (choiceOrInterleave == -1) | |
| choiceOrInterleave = 0; | |
| else if (choiceOrInterleave == 1) { | |
| xmlRngPErr(ctxt, define->node, XML_RNGP_DEF_CHOICE_AND_INTERLEAVE, | |
| "Defines for %s use both 'choice' and 'interleave'\n", | |
| name, NULL); | |
| } | |
| } else { | |
| xmlRngPErr(ctxt, define->node, XML_RNGP_UNKNOWN_COMBINE, | |
| "Defines for %s use unknown combine value '%s''\n", | |
| name, combine); | |
| } | |
| xmlFree(combine); | |
| } else { | |
| if (missing == 0) | |
| missing = 1; | |
| else { | |
| xmlRngPErr(ctxt, define->node, XML_RNGP_NEED_COMBINE, | |
| "Some defines for %s needs the combine attribute\n", | |
| name, NULL); | |
| } | |
| } | |
| cur = cur->nextHash; | |
| } | |
| #ifdef DEBUG | |
| xmlGenericError(xmlGenericErrorContext, | |
| "xmlRelaxNGCheckCombine(): merging %s defines: %d\n", | |
| name, choiceOrInterleave); | |
| #endif | |
| if (choiceOrInterleave == -1) | |
| choiceOrInterleave = 0; | |
| cur = xmlRelaxNGNewDefine(ctxt, define->node); | |
| if (cur == NULL) | |
| return; | |
| if (choiceOrInterleave == 0) | |
| cur->type = XML_RELAXNG_INTERLEAVE; | |
| else | |
| cur->type = XML_RELAXNG_CHOICE; | |
| tmp = define; | |
| last = NULL; | |
| while (tmp != NULL) { | |
| if (tmp->content != NULL) { | |
| if (tmp->content->next != NULL) { | |
| /* | |
| * we need first to create a wrapper. | |
| */ | |
| tmp2 = xmlRelaxNGNewDefine(ctxt, tmp->content->node); | |
| if (tmp2 == NULL) | |
| break; | |
| tmp2->type = XML_RELAXNG_GROUP; | |
| tmp2->content = tmp->content; | |
| } else { | |
| tmp2 = tmp->content; | |
| } | |
| if (last == NULL) { | |
| cur->content = tmp2; | |
| } else { | |
| last->next = tmp2; | |
| } | |
| last = tmp2; | |
| } | |
| tmp->content = cur; | |
| tmp = tmp->nextHash; | |
| } | |
| define->content = cur; | |
| if (choiceOrInterleave == 0) { | |
| if (ctxt->interleaves == NULL) | |
| ctxt->interleaves = xmlHashCreate(10); | |
| if (ctxt->interleaves == NULL) { | |
| xmlRngPErr(ctxt, define->node, XML_RNGP_INTERLEAVE_CREATE_FAILED, | |
| "Failed to create interleaves hash table\n", NULL, | |
| NULL); | |
| } else { | |
| char tmpname[32]; | |
| snprintf(tmpname, 32, "interleave%d", ctxt->nbInterleaves++); | |
| if (xmlHashAddEntry(ctxt->interleaves, BAD_CAST tmpname, cur) < | |
| 0) { | |
| xmlRngPErr(ctxt, define->node, XML_RNGP_INTERLEAVE_CREATE_FAILED, | |
| "Failed to add %s to hash table\n", | |
| (const xmlChar *) tmpname, NULL); | |
| } | |
| } | |
| } | |
| } | |
| /** | |
| * xmlRelaxNGCombineStart: | |
| * @ctxt: a Relax-NG parser context | |
| * @grammar: the grammar | |
| * | |
| * Applies the 4.17. combine rule for all the start | |
| * element of a given grammar. | |
| */ | |
| static void | |
| xmlRelaxNGCombineStart(xmlRelaxNGParserCtxtPtr ctxt, | |
| xmlRelaxNGGrammarPtr grammar) | |
| { | |
| xmlRelaxNGDefinePtr starts; | |
| xmlChar *combine; | |
| int choiceOrInterleave = -1; | |
| int missing = 0; | |
| xmlRelaxNGDefinePtr cur; | |
| starts = grammar->start; | |
| if ((starts == NULL) || (starts->next == NULL)) | |
| return; | |
| cur = starts; | |
| while (cur != NULL) { | |
| if ((cur->node == NULL) || (cur->node->parent == NULL) || | |
| (!xmlStrEqual(cur->node->parent->name, BAD_CAST "start"))) { | |
| combine = NULL; | |
| xmlRngPErr(ctxt, cur->node, XML_RNGP_START_MISSING, | |
| "Internal error: start element not found\n", NULL, | |
| NULL); | |
| } else { | |
| combine = xmlGetProp(cur->node->parent, BAD_CAST "combine"); | |
| } | |
| if (combine != NULL) { | |
| if (xmlStrEqual(combine, BAD_CAST "choice")) { | |
| if (choiceOrInterleave == -1) | |
| choiceOrInterleave = 1; | |
| else if (choiceOrInterleave == 0) { | |
| xmlRngPErr(ctxt, cur->node, XML_RNGP_START_CHOICE_AND_INTERLEAVE, | |
| "<start> use both 'choice' and 'interleave'\n", | |
| NULL, NULL); | |
| } | |
| } else if (xmlStrEqual(combine, BAD_CAST "interleave")) { | |
| if (choiceOrInterleave == -1) | |
| choiceOrInterleave = 0; | |
| else if (choiceOrInterleave == 1) { | |
| xmlRngPErr(ctxt, cur->node, XML_RNGP_START_CHOICE_AND_INTERLEAVE, | |
| "<start> use both 'choice' and 'interleave'\n", | |
| NULL, NULL); | |
| } | |
| } else { | |
| xmlRngPErr(ctxt, cur->node, XML_RNGP_UNKNOWN_COMBINE, | |
| "<start> uses unknown combine value '%s''\n", | |
| combine, NULL); | |
| } | |
| xmlFree(combine); | |
| } else { | |
| if (missing == 0) | |
| missing = 1; | |
| else { | |
| xmlRngPErr(ctxt, cur->node, XML_RNGP_NEED_COMBINE, | |
| "Some <start> element miss the combine attribute\n", | |
| NULL, NULL); | |
| } | |
| } | |
| cur = cur->next; | |
| } | |
| #ifdef DEBUG | |
| xmlGenericError(xmlGenericErrorContext, | |
| "xmlRelaxNGCombineStart(): merging <start>: %d\n", | |
| choiceOrInterleave); | |
| #endif | |
| if (choiceOrInterleave == -1) | |
| choiceOrInterleave = 0; | |
| cur = xmlRelaxNGNewDefine(ctxt, starts->node); | |
| if (cur == NULL) | |
| return; | |
| if (choiceOrInterleave == 0) | |
| cur->type = XML_RELAXNG_INTERLEAVE; | |
| else | |
| cur->type = XML_RELAXNG_CHOICE; | |
| cur->content = grammar->start; | |
| grammar->start = cur; | |
| if (choiceOrInterleave == 0) { | |
| if (ctxt->interleaves == NULL) | |
| ctxt->interleaves = xmlHashCreate(10); | |
| if (ctxt->interleaves == NULL) { | |
| xmlRngPErr(ctxt, cur->node, XML_RNGP_INTERLEAVE_CREATE_FAILED, | |
| "Failed to create interleaves hash table\n", NULL, | |
| NULL); | |
| } else { | |
| char tmpname[32]; | |
| snprintf(tmpname, 32, "interleave%d", ctxt->nbInterleaves++); | |
| if (xmlHashAddEntry(ctxt->interleaves, BAD_CAST tmpname, cur) < | |
| 0) { | |
| xmlRngPErr(ctxt, cur->node, XML_RNGP_INTERLEAVE_CREATE_FAILED, | |
| "Failed to add %s to hash table\n", | |
| (const xmlChar *) tmpname, NULL); | |
| } | |
| } | |
| } | |
| } | |
| /** | |
| * xmlRelaxNGCheckCycles: | |
| * @ctxt: a Relax-NG parser context | |
| * @nodes: grammar children nodes | |
| * @depth: the counter | |
| * | |
| * Check for cycles. | |
| * | |
| * Returns 0 if check passed, and -1 in case of error | |
| */ | |
| static int | |
| xmlRelaxNGCheckCycles(xmlRelaxNGParserCtxtPtr ctxt, | |
| xmlRelaxNGDefinePtr cur, int depth) | |
| { | |
| int ret = 0; | |
| while ((ret == 0) && (cur != NULL)) { | |
| if ((cur->type == XML_RELAXNG_REF) || | |
| (cur->type == XML_RELAXNG_PARENTREF)) { | |
| if (cur->depth == -1) { | |
| cur->depth = depth; | |
| ret = xmlRelaxNGCheckCycles(ctxt, cur->content, depth); | |
| cur->depth = -2; | |
| } else if (depth == cur->depth) { | |
| xmlRngPErr(ctxt, cur->node, XML_RNGP_REF_CYCLE, | |
| "Detected a cycle in %s references\n", | |
| cur->name, NULL); | |
| return (-1); | |
| } | |
| } else if (cur->type == XML_RELAXNG_ELEMENT) { | |
| ret = xmlRelaxNGCheckCycles(ctxt, cur->content, depth + 1); | |
| } else { | |
| ret = xmlRelaxNGCheckCycles(ctxt, cur->content, depth); | |
| } | |
| cur = cur->next; | |
| } | |
| return (ret); | |
| } | |
| /** | |
| * xmlRelaxNGTryUnlink: | |
| * @ctxt: a Relax-NG parser context | |
| * @cur: the definition to unlink | |
| * @parent: the parent definition | |
| * @prev: the previous sibling definition | |
| * | |
| * Try to unlink a definition. If not possble make it a NOOP | |
| * | |
| * Returns the new prev definition | |
| */ | |
| static xmlRelaxNGDefinePtr | |
| xmlRelaxNGTryUnlink(xmlRelaxNGParserCtxtPtr ctxt ATTRIBUTE_UNUSED, | |
| xmlRelaxNGDefinePtr cur, | |
| xmlRelaxNGDefinePtr parent, xmlRelaxNGDefinePtr prev) | |
| { | |
| if (prev != NULL) { | |
| prev->next = cur->next; | |
| } else { | |
| if (parent != NULL) { | |
| if (parent->content == cur) | |
| parent->content = cur->next; | |
| else if (parent->attrs == cur) | |
| parent->attrs = cur->next; | |
| else if (parent->nameClass == cur) | |
| parent->nameClass = cur->next; | |
| } else { | |
| cur->type = XML_RELAXNG_NOOP; | |
| prev = cur; | |
| } | |
| } | |
| return (prev); | |
| } | |
| /** | |
| * xmlRelaxNGSimplify: | |
| * @ctxt: a Relax-NG parser context | |
| * @nodes: grammar children nodes | |
| * | |
| * Check for simplification of empty and notAllowed | |
| */ | |
| static void | |
| xmlRelaxNGSimplify(xmlRelaxNGParserCtxtPtr ctxt, | |
| xmlRelaxNGDefinePtr cur, xmlRelaxNGDefinePtr parent) | |
| { | |
| xmlRelaxNGDefinePtr prev = NULL; | |
| while (cur != NULL) { | |
| if ((cur->type == XML_RELAXNG_REF) || | |
| (cur->type == XML_RELAXNG_PARENTREF)) { | |
| if (cur->depth != -3) { | |
| cur->depth = -3; | |
| xmlRelaxNGSimplify(ctxt, cur->content, cur); | |
| } | |
| } else if (cur->type == XML_RELAXNG_NOT_ALLOWED) { | |
| cur->parent = parent; | |
| if ((parent != NULL) && | |
| ((parent->type == XML_RELAXNG_ATTRIBUTE) || | |
| (parent->type == XML_RELAXNG_LIST) || | |
| (parent->type == XML_RELAXNG_GROUP) || | |
| (parent->type == XML_RELAXNG_INTERLEAVE) || | |
| (parent->type == XML_RELAXNG_ONEORMORE) || | |
| (parent->type == XML_RELAXNG_ZEROORMORE))) { | |
| parent->type = XML_RELAXNG_NOT_ALLOWED; | |
| break; | |
| } | |
| if ((parent != NULL) && (parent->type == XML_RELAXNG_CHOICE)) { | |
| prev = xmlRelaxNGTryUnlink(ctxt, cur, parent, prev); | |
| } else | |
| prev = cur; | |
| } else if (cur->type == XML_RELAXNG_EMPTY) { | |
| cur->parent = parent; | |
| if ((parent != NULL) && | |
| ((parent->type == XML_RELAXNG_ONEORMORE) || | |
| (parent->type == XML_RELAXNG_ZEROORMORE))) { | |
| parent->type = XML_RELAXNG_EMPTY; | |
| break; | |
| } | |
| if ((parent != NULL) && | |
| ((parent->type == XML_RELAXNG_GROUP) || | |
| (parent->type == XML_RELAXNG_INTERLEAVE))) { | |
| prev = xmlRelaxNGTryUnlink(ctxt, cur, parent, prev); | |
| } else | |
| prev = cur; | |
| } else { | |
| cur->parent = parent; | |
| if (cur->content != NULL) | |
| xmlRelaxNGSimplify(ctxt, cur->content, cur); | |
| if ((cur->type != XML_RELAXNG_VALUE) && (cur->attrs != NULL)) | |
| xmlRelaxNGSimplify(ctxt, cur->attrs, cur); | |
| if (cur->nameClass != NULL) | |
| xmlRelaxNGSimplify(ctxt, cur->nameClass, cur); | |
| /* | |
| * On Elements, try to move attribute only generating rules on | |
| * the attrs rules. | |
| */ | |
| if (cur->type == XML_RELAXNG_ELEMENT) { | |
| int attronly; | |
| xmlRelaxNGDefinePtr tmp, pre; | |
| while (cur->content != NULL) { | |
| attronly = | |
| xmlRelaxNGGenerateAttributes(ctxt, cur->content); | |
| if (attronly == 1) { | |
| /* | |
| * migrate cur->content to attrs | |
| */ | |
| tmp = cur->content; | |
| cur->content = tmp->next; | |
| tmp->next = cur->attrs; | |
| cur->attrs = tmp; | |
| } else { | |
| /* | |
| * cur->content can generate elements or text | |
| */ | |
| break; | |
| } | |
| } | |
| pre = cur->content; | |
| while ((pre != NULL) && (pre->next != NULL)) { | |
| tmp = pre->next; | |
| attronly = xmlRelaxNGGenerateAttributes(ctxt, tmp); | |
| if (attronly == 1) { | |
| /* | |
| * migrate tmp to attrs | |
| */ | |
| pre->next = tmp->next; | |
| tmp->next = cur->attrs; | |
| cur->attrs = tmp; | |
| } else { | |
| pre = tmp; | |
| } | |
| } | |
| } | |
| /* | |
| * This may result in a simplification | |
| */ | |
| if ((cur->type == XML_RELAXNG_GROUP) || | |
| (cur->type == XML_RELAXNG_INTERLEAVE)) { | |
| if (cur->content == NULL) | |
| cur->type = XML_RELAXNG_EMPTY; | |
| else if (cur->content->next == NULL) { | |
| if ((parent == NULL) && (prev == NULL)) { | |
| cur->type = XML_RELAXNG_NOOP; | |
| } else if (prev == NULL) { | |
| parent->content = cur->content; | |
| cur->content->next = cur->next; | |
| cur = cur->content; | |
| } else { | |
| cur->content->next = cur->next; | |
| prev->next = cur->content; | |
| cur = cur->content; | |
| } | |
| } | |
| } | |
| /* | |
| * the current node may have been transformed back | |
| */ | |
| if ((cur->type == XML_RELAXNG_EXCEPT) && | |
| (cur->content != NULL) && | |
| (cur->content->type == XML_RELAXNG_NOT_ALLOWED)) { | |
| prev = xmlRelaxNGTryUnlink(ctxt, cur, parent, prev); | |
| } else if (cur->type == XML_RELAXNG_NOT_ALLOWED) { | |
| if ((parent != NULL) && | |
| ((parent->type == XML_RELAXNG_ATTRIBUTE) || | |
| (parent->type == XML_RELAXNG_LIST) || | |
| (parent->type == XML_RELAXNG_GROUP) || | |
| (parent->type == XML_RELAXNG_INTERLEAVE) || | |
| (parent->type == XML_RELAXNG_ONEORMORE) || | |
| (parent->type == XML_RELAXNG_ZEROORMORE))) { | |
| parent->type = XML_RELAXNG_NOT_ALLOWED; | |
| break; | |
| } | |
| if ((parent != NULL) && | |
| (parent->type == XML_RELAXNG_CHOICE)) { | |
| prev = xmlRelaxNGTryUnlink(ctxt, cur, parent, prev); | |
| } else | |
| prev = cur; | |
| } else if (cur->type == XML_RELAXNG_EMPTY) { | |
| if ((parent != NULL) && | |
| ((parent->type == XML_RELAXNG_ONEORMORE) || | |
| (parent->type == XML_RELAXNG_ZEROORMORE))) { | |
| parent->type = XML_RELAXNG_EMPTY; | |
| break; | |
| } | |
| if ((parent != NULL) && | |
| ((parent->type == XML_RELAXNG_GROUP) || | |
| (parent->type == XML_RELAXNG_INTERLEAVE) || | |
| (parent->type == XML_RELAXNG_CHOICE))) { | |
| prev = xmlRelaxNGTryUnlink(ctxt, cur, parent, prev); | |
| } else | |
| prev = cur; | |
| } else { | |
| prev = cur; | |
| } | |
| } | |
| cur = cur->next; | |
| } | |
| } | |
| /** | |
| * xmlRelaxNGGroupContentType: | |
| * @ct1: the first content type | |
| * @ct2: the second content type | |
| * | |
| * Try to group 2 content types | |
| * | |
| * Returns the content type | |
| */ | |
| static xmlRelaxNGContentType | |
| xmlRelaxNGGroupContentType(xmlRelaxNGContentType ct1, | |
| xmlRelaxNGContentType ct2) | |
| { | |
| if ((ct1 == XML_RELAXNG_CONTENT_ERROR) || | |
| (ct2 == XML_RELAXNG_CONTENT_ERROR)) | |
| return (XML_RELAXNG_CONTENT_ERROR); | |
| if (ct1 == XML_RELAXNG_CONTENT_EMPTY) | |
| return (ct2); | |
| if (ct2 == XML_RELAXNG_CONTENT_EMPTY) | |
| return (ct1); | |
| if ((ct1 == XML_RELAXNG_CONTENT_COMPLEX) && | |
| (ct2 == XML_RELAXNG_CONTENT_COMPLEX)) | |
| return (XML_RELAXNG_CONTENT_COMPLEX); | |
| return (XML_RELAXNG_CONTENT_ERROR); | |
| } | |
| /** | |
| * xmlRelaxNGMaxContentType: | |
| * @ct1: the first content type | |
| * @ct2: the second content type | |
| * | |
| * Compute the max content-type | |
| * | |
| * Returns the content type | |
| */ | |
| static xmlRelaxNGContentType | |
| xmlRelaxNGMaxContentType(xmlRelaxNGContentType ct1, | |
| xmlRelaxNGContentType ct2) | |
| { | |
| if ((ct1 == XML_RELAXNG_CONTENT_ERROR) || | |
| (ct2 == XML_RELAXNG_CONTENT_ERROR)) | |
| return (XML_RELAXNG_CONTENT_ERROR); | |
| if ((ct1 == XML_RELAXNG_CONTENT_SIMPLE) || | |
| (ct2 == XML_RELAXNG_CONTENT_SIMPLE)) | |
| return (XML_RELAXNG_CONTENT_SIMPLE); | |
| if ((ct1 == XML_RELAXNG_CONTENT_COMPLEX) || | |
| (ct2 == XML_RELAXNG_CONTENT_COMPLEX)) | |
| return (XML_RELAXNG_CONTENT_COMPLEX); | |
| return (XML_RELAXNG_CONTENT_EMPTY); | |
| } | |
| /** | |
| * xmlRelaxNGCheckRules: | |
| * @ctxt: a Relax-NG parser context | |
| * @cur: the current definition | |
| * @flags: some accumulated flags | |
| * @ptype: the parent type | |
| * | |
| * Check for rules in section 7.1 and 7.2 | |
| * | |
| * Returns the content type of @cur | |
| */ | |
| static xmlRelaxNGContentType | |
| xmlRelaxNGCheckRules(xmlRelaxNGParserCtxtPtr ctxt, | |
| xmlRelaxNGDefinePtr cur, int flags, | |
| xmlRelaxNGType ptype) | |
| { | |
| int nflags; | |
| xmlRelaxNGContentType ret, tmp, val = XML_RELAXNG_CONTENT_EMPTY; | |
| while (cur != NULL) { | |
| ret = XML_RELAXNG_CONTENT_EMPTY; | |
| if ((cur->type == XML_RELAXNG_REF) || | |
| (cur->type == XML_RELAXNG_PARENTREF)) { | |
| /* | |
| * This should actually be caught by list//element(ref) at the | |
| * element boundaries, c.f. Bug #159968 local refs are dropped | |
| * in step 4.19. | |
| */ | |
| #if 0 | |
| if (flags & XML_RELAXNG_IN_LIST) { | |
| xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_REF, | |
| "Found forbidden pattern list//ref\n", NULL, | |
| NULL); | |
| } | |
| #endif | |
| if (flags & XML_RELAXNG_IN_DATAEXCEPT) { | |
| xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_REF, | |
| "Found forbidden pattern data/except//ref\n", | |
| NULL, NULL); | |
| } | |
| if (cur->content == NULL) { | |
| if (cur->type == XML_RELAXNG_PARENTREF) | |
| xmlRngPErr(ctxt, cur->node, XML_RNGP_REF_NO_DEF, | |
| "Internal found no define for parent refs\n", | |
| NULL, NULL); | |
| else | |
| xmlRngPErr(ctxt, cur->node, XML_RNGP_REF_NO_DEF, | |
| "Internal found no define for ref %s\n", | |
| (cur->name ? cur->name: BAD_CAST "null"), NULL); | |
| } | |
| if (cur->depth > -4) { | |
| cur->depth = -4; | |
| ret = xmlRelaxNGCheckRules(ctxt, cur->content, | |
| flags, cur->type); | |
| cur->depth = ret - 15; | |
| } else if (cur->depth == -4) { | |
| ret = XML_RELAXNG_CONTENT_COMPLEX; | |
| } else { | |
| ret = (xmlRelaxNGContentType) (cur->depth + 15); | |
| } | |
| } else if (cur->type == XML_RELAXNG_ELEMENT) { | |
| /* | |
| * The 7.3 Attribute derivation rule for groups is plugged there | |
| */ | |
| xmlRelaxNGCheckGroupAttrs(ctxt, cur); | |
| if (flags & XML_RELAXNG_IN_DATAEXCEPT) { | |
| xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_ELEM, | |
| "Found forbidden pattern data/except//element(ref)\n", | |
| NULL, NULL); | |
| } | |
| if (flags & XML_RELAXNG_IN_LIST) { | |
| xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_ELEM, | |
| "Found forbidden pattern list//element(ref)\n", | |
| NULL, NULL); | |
| } | |
| if (flags & XML_RELAXNG_IN_ATTRIBUTE) { | |
| xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ATTR_ELEM, | |
| "Found forbidden pattern attribute//element(ref)\n", | |
| NULL, NULL); | |
| } | |
| if (flags & XML_RELAXNG_IN_ATTRIBUTE) { | |
| xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ATTR_ELEM, | |
| "Found forbidden pattern attribute//element(ref)\n", | |
| NULL, NULL); | |
| } | |
| /* | |
| * reset since in the simple form elements are only child | |
| * of grammar/define | |
| */ | |
| nflags = 0; | |
| ret = | |
| xmlRelaxNGCheckRules(ctxt, cur->attrs, nflags, cur->type); | |
| if (ret != XML_RELAXNG_CONTENT_EMPTY) { | |
| xmlRngPErr(ctxt, cur->node, XML_RNGP_ELEM_CONTENT_EMPTY, | |
| "Element %s attributes have a content type error\n", | |
| cur->name, NULL); | |
| } | |
| ret = | |
| xmlRelaxNGCheckRules(ctxt, cur->content, nflags, | |
| cur->type); | |
| if (ret == XML_RELAXNG_CONTENT_ERROR) { | |
| xmlRngPErr(ctxt, cur->node, XML_RNGP_ELEM_CONTENT_ERROR, | |
| "Element %s has a content type error\n", | |
| cur->name, NULL); | |
| } else { | |
| ret = XML_RELAXNG_CONTENT_COMPLEX; | |
| } | |
| } else if (cur->type == XML_RELAXNG_ATTRIBUTE) { | |
| if (flags & XML_RELAXNG_IN_ATTRIBUTE) { | |
| xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ATTR_ATTR, | |
| "Found forbidden pattern attribute//attribute\n", | |
| NULL, NULL); | |
| } | |
| if (flags & XML_RELAXNG_IN_LIST) { | |
| xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_ATTR, | |
| "Found forbidden pattern list//attribute\n", | |
| NULL, NULL); | |
| } | |
| if (flags & XML_RELAXNG_IN_OOMGROUP) { | |
| xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ONEMORE_GROUP_ATTR, | |
| "Found forbidden pattern oneOrMore//group//attribute\n", | |
| NULL, NULL); | |
| } | |
| if (flags & XML_RELAXNG_IN_OOMINTERLEAVE) { | |
| xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_ONEMORE_INTERLEAVE_ATTR, | |
| "Found forbidden pattern oneOrMore//interleave//attribute\n", | |
| NULL, NULL); | |
| } | |
| if (flags & XML_RELAXNG_IN_DATAEXCEPT) { | |
| xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_ATTR, | |
| "Found forbidden pattern data/except//attribute\n", | |
| NULL, NULL); | |
| } | |
| if (flags & XML_RELAXNG_IN_START) { | |
| xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_ATTR, | |
| "Found forbidden pattern start//attribute\n", | |
| NULL, NULL); | |
| } | |
| if ((!(flags & XML_RELAXNG_IN_ONEORMORE)) | |
| && (cur->name == NULL)) { | |
| if (cur->ns == NULL) { | |
| xmlRngPErr(ctxt, cur->node, XML_RNGP_ANYNAME_ATTR_ANCESTOR, | |
| "Found anyName attribute without oneOrMore ancestor\n", | |
| NULL, NULL); | |
| } else { | |
| xmlRngPErr(ctxt, cur->node, XML_RNGP_NSNAME_ATTR_ANCESTOR, | |
| "Found nsName attribute without oneOrMore ancestor\n", | |
| NULL, NULL); | |
| } | |
| } | |
| nflags = flags | XML_RELAXNG_IN_ATTRIBUTE; | |
| xmlRelaxNGCheckRules(ctxt, cur->content, nflags, cur->type); | |
| ret = XML_RELAXNG_CONTENT_EMPTY; | |
| } else if ((cur->type == XML_RELAXNG_ONEORMORE) || | |
| (cur->type == XML_RELAXNG_ZEROORMORE)) { | |
| if (flags & XML_RELAXNG_IN_DATAEXCEPT) { | |
| xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_ONEMORE, | |
| "Found forbidden pattern data/except//oneOrMore\n", | |
| NULL, NULL); | |
| } | |
| if (flags & XML_RELAXNG_IN_START) { | |
| xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_ONEMORE, | |
| "Found forbidden pattern start//oneOrMore\n", | |
| NULL, NULL); | |
| } | |
| nflags = flags | XML_RELAXNG_IN_ONEORMORE; | |
| ret = | |
| xmlRelaxNGCheckRules(ctxt, cur->content, nflags, | |
| cur->type); | |
| ret = xmlRelaxNGGroupContentType(ret, ret); | |
| } else if (cur->type == XML_RELAXNG_LIST) { | |
| if (flags & XML_RELAXNG_IN_LIST) { | |
| xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_LIST, | |
| "Found forbidden pattern list//list\n", NULL, | |
| NULL); | |
| } | |
| if (flags & XML_RELAXNG_IN_DATAEXCEPT) { | |
| xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_LIST, | |
| "Found forbidden pattern data/except//list\n", | |
| NULL, NULL); | |
| } | |
| if (flags & XML_RELAXNG_IN_START) { | |
| xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_LIST, | |
| "Found forbidden pattern start//list\n", NULL, | |
| NULL); | |
| } | |
| nflags = flags | XML_RELAXNG_IN_LIST; | |
| ret = | |
| xmlRelaxNGCheckRules(ctxt, cur->content, nflags, | |
| cur->type); | |
| } else if (cur->type == XML_RELAXNG_GROUP) { | |
| if (flags & XML_RELAXNG_IN_DATAEXCEPT) { | |
| xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_GROUP, | |
| "Found forbidden pattern data/except//group\n", | |
| NULL, NULL); | |
| } | |
| if (flags & XML_RELAXNG_IN_START) { | |
| xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_GROUP, | |
| "Found forbidden pattern start//group\n", NULL, | |
| NULL); | |
| } | |
| if (flags & XML_RELAXNG_IN_ONEORMORE) | |
| nflags = flags | XML_RELAXNG_IN_OOMGROUP; | |
| else | |
| nflags = flags; | |
| ret = | |
| xmlRelaxNGCheckRules(ctxt, cur->content, nflags, | |
| cur->type); | |
| /* | |
| * The 7.3 Attribute derivation rule for groups is plugged there | |
| */ | |
| xmlRelaxNGCheckGroupAttrs(ctxt, cur); | |
| } else if (cur->type == XML_RELAXNG_INTERLEAVE) { | |
| if (flags & XML_RELAXNG_IN_LIST) { | |
| xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_INTERLEAVE, | |
| "Found forbidden pattern list//interleave\n", | |
| NULL, NULL); | |
| } | |
| if (flags & XML_RELAXNG_IN_DATAEXCEPT) { | |
| xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE, | |
| "Found forbidden pattern data/except//interleave\n", | |
| NULL, NULL); | |
| } | |
| if (flags & XML_RELAXNG_IN_START) { | |
| xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE, | |
| "Found forbidden pattern start//interleave\n", | |
| NULL, NULL); | |
| } | |
| if (flags & XML_RELAXNG_IN_ONEORMORE) | |
| nflags = flags | XML_RELAXNG_IN_OOMINTERLEAVE; | |
| else | |
| nflags = flags; | |
| ret = | |
| xmlRelaxNGCheckRules(ctxt, cur->content, nflags, | |
| cur->type); | |
| } else if (cur->type == XML_RELAXNG_EXCEPT) { | |
| if ((cur->parent != NULL) && | |
| (cur->parent->type == XML_RELAXNG_DATATYPE)) | |
| nflags = flags | XML_RELAXNG_IN_DATAEXCEPT; | |
| else | |
| nflags = flags; | |
| ret = | |
| xmlRelaxNGCheckRules(ctxt, cur->content, nflags, | |
| cur->type); | |
| } else if (cur->type == XML_RELAXNG_DATATYPE) { | |
| if (flags & XML_RELAXNG_IN_START) { | |
| xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_DATA, | |
| "Found forbidden pattern start//data\n", NULL, | |
| NULL); | |
| } | |
| xmlRelaxNGCheckRules(ctxt, cur->content, flags, cur->type); | |
| ret = XML_RELAXNG_CONTENT_SIMPLE; | |
| } else if (cur->type == XML_RELAXNG_VALUE) { | |
| if (flags & XML_RELAXNG_IN_START) { | |
| xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_VALUE, | |
| "Found forbidden pattern start//value\n", NULL, | |
| NULL); | |
| } | |
| xmlRelaxNGCheckRules(ctxt, cur->content, flags, cur->type); | |
| ret = XML_RELAXNG_CONTENT_SIMPLE; | |
| } else if (cur->type == XML_RELAXNG_TEXT) { | |
| if (flags & XML_RELAXNG_IN_LIST) { | |
| xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_TEXT, | |
| "Found forbidden pattern list//text\n", NULL, | |
| NULL); | |
| } | |
| if (flags & XML_RELAXNG_IN_DATAEXCEPT) { | |
| xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_TEXT, | |
| "Found forbidden pattern data/except//text\n", | |
| NULL, NULL); | |
| } | |
| if (flags & XML_RELAXNG_IN_START) { | |
| xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_TEXT, | |
| "Found forbidden pattern start//text\n", NULL, | |
| NULL); | |
| } | |
| ret = XML_RELAXNG_CONTENT_COMPLEX; | |
| } else if (cur->type == XML_RELAXNG_EMPTY) { | |
| if (flags & XML_RELAXNG_IN_DATAEXCEPT) { | |
| xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_DATA_EXCEPT_EMPTY, | |
| "Found forbidden pattern data/except//empty\n", | |
| NULL, NULL); | |
| } | |
| if (flags & XML_RELAXNG_IN_START) { | |
| xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_START_EMPTY, | |
| "Found forbidden pattern start//empty\n", NULL, | |
| NULL); | |
| } | |
| ret = XML_RELAXNG_CONTENT_EMPTY; | |
| } else if (cur->type == XML_RELAXNG_CHOICE) { | |
| xmlRelaxNGCheckChoiceDeterminism(ctxt, cur); | |
| ret = | |
| xmlRelaxNGCheckRules(ctxt, cur->content, flags, cur->type); | |
| } else { | |
| ret = | |
| xmlRelaxNGCheckRules(ctxt, cur->content, flags, cur->type); | |
| } | |
| cur = cur->next; | |
| if (ptype == XML_RELAXNG_GROUP) { | |
| val = xmlRelaxNGGroupContentType(val, ret); | |
| } else if (ptype == XML_RELAXNG_INTERLEAVE) { | |
| /* | |
| * TODO: scan complain that tmp is never used, seems on purpose | |
| * need double-checking | |
| */ | |
| tmp = xmlRelaxNGGroupContentType(val, ret); | |
| if (tmp != XML_RELAXNG_CONTENT_ERROR) | |
| tmp = xmlRelaxNGMaxContentType(val, ret); | |
| } else if (ptype == XML_RELAXNG_CHOICE) { | |
| val = xmlRelaxNGMaxContentType(val, ret); | |
| } else if (ptype == XML_RELAXNG_LIST) { | |
| val = XML_RELAXNG_CONTENT_SIMPLE; | |
| } else if (ptype == XML_RELAXNG_EXCEPT) { | |
| if (ret == XML_RELAXNG_CONTENT_ERROR) | |
| val = XML_RELAXNG_CONTENT_ERROR; | |
| else | |
| val = XML_RELAXNG_CONTENT_SIMPLE; | |
| } else { | |
| val = xmlRelaxNGGroupContentType(val, ret); | |
| } | |
| } | |
| return (val); | |
| } | |
| /** | |
| * xmlRelaxNGParseGrammar: | |
| * @ctxt: a Relax-NG parser context | |
| * @nodes: grammar children nodes | |
| * | |
| * parse a Relax-NG <grammar> node | |
| * | |
| * Returns the internal xmlRelaxNGGrammarPtr built or | |
| * NULL in case of error | |
| */ | |
| static xmlRelaxNGGrammarPtr | |
| xmlRelaxNGParseGrammar(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr nodes) | |
| { | |
| xmlRelaxNGGrammarPtr ret, tmp, old; | |
| #ifdef DEBUG_GRAMMAR | |
| xmlGenericError(xmlGenericErrorContext, "Parsing a new grammar\n"); | |
| #endif | |
| ret = xmlRelaxNGNewGrammar(ctxt); | |
| if (ret == NULL) | |
| return (NULL); | |
| /* | |
| * Link the new grammar in the tree | |
| */ | |
| ret->parent = ctxt->grammar; | |
| if (ctxt->grammar != NULL) { | |
| tmp = ctxt->grammar->children; | |
| if (tmp == NULL) { | |
| ctxt->grammar->children = ret; | |
| } else { | |
| while (tmp->next != NULL) | |
| tmp = tmp->next; | |
| tmp->next = ret; | |
| } | |
| } | |
| old = ctxt->grammar; | |
| ctxt->grammar = ret; | |
| xmlRelaxNGParseGrammarContent(ctxt, nodes); | |
| ctxt->grammar = ret; | |
| if (ctxt->grammar == NULL) { | |
| xmlRngPErr(ctxt, nodes, XML_RNGP_GRAMMAR_CONTENT, | |
| "Failed to parse <grammar> content\n", NULL, NULL); | |
| } else if (ctxt->grammar->start == NULL) { | |
| xmlRngPErr(ctxt, nodes, XML_RNGP_GRAMMAR_NO_START, | |
| "Element <grammar> has no <start>\n", NULL, NULL); | |
| } | |
| /* | |
| * Apply 4.17 merging rules to defines and starts | |
| */ | |
| xmlRelaxNGCombineStart(ctxt, ret); | |
| if (ret->defs != NULL) { | |
| xmlHashScan(ret->defs, (xmlHashScanner) xmlRelaxNGCheckCombine, | |
| ctxt); | |
| } | |
| /* | |
| * link together defines and refs in this grammar | |
| */ | |
| if (ret->refs != NULL) { | |
| xmlHashScan(ret->refs, (xmlHashScanner) xmlRelaxNGCheckReference, | |
| ctxt); | |
| } | |
| /* @@@@ */ | |
| ctxt->grammar = old; | |
| return (ret); | |
| } | |
| /** | |
| * xmlRelaxNGParseDocument: | |
| * @ctxt: a Relax-NG parser context | |
| * @node: the root node of the RelaxNG schema | |
| * | |
| * parse a Relax-NG definition resource and build an internal | |
| * xmlRelaxNG struture which can be used to validate instances. | |
| * | |
| * Returns the internal XML RelaxNG structure built or | |
| * NULL in case of error | |
| */ | |
| static xmlRelaxNGPtr | |
| xmlRelaxNGParseDocument(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node) | |
| { | |
| xmlRelaxNGPtr schema = NULL; | |
| const xmlChar *olddefine; | |
| xmlRelaxNGGrammarPtr old; | |
| if ((ctxt == NULL) || (node == NULL)) | |
| return (NULL); | |
| schema = xmlRelaxNGNewRelaxNG(ctxt); | |
| if (schema == NULL) | |
| return (NULL); | |
| olddefine = ctxt->define; | |
| ctxt->define = NULL; | |
| if (IS_RELAXNG(node, "grammar")) { | |
| schema->topgrammar = xmlRelaxNGParseGrammar(ctxt, node->children); | |
| if (schema->topgrammar == NULL) { | |
| xmlRelaxNGFree(schema); | |
| return (NULL); | |
| } | |
| } else { | |
| xmlRelaxNGGrammarPtr tmp, ret; | |
| schema->topgrammar = ret = xmlRelaxNGNewGrammar(ctxt); | |
| if (schema->topgrammar == NULL) { | |
| xmlRelaxNGFree(schema); | |
| return (NULL); | |
| } | |
| /* | |
| * Link the new grammar in the tree | |
| */ | |
| ret->parent = ctxt->grammar; | |
| if (ctxt->grammar != NULL) { | |
| tmp = ctxt->grammar->children; | |
| if (tmp == NULL) { | |
| ctxt->grammar->children = ret; | |
| } else { | |
| while (tmp->next != NULL) | |
| tmp = tmp->next; | |
| tmp->next = ret; | |
| } | |
| } | |
| old = ctxt->grammar; | |
| ctxt->grammar = ret; | |
| xmlRelaxNGParseStart(ctxt, node); | |
| if (old != NULL) | |
| ctxt->grammar = old; | |
| } | |
| ctxt->define = olddefine; | |
| if (schema->topgrammar->start != NULL) { | |
| xmlRelaxNGCheckCycles(ctxt, schema->topgrammar->start, 0); | |
| if ((ctxt->flags & XML_RELAXNG_IN_EXTERNALREF) == 0) { | |
| xmlRelaxNGSimplify(ctxt, schema->topgrammar->start, NULL); | |
| while ((schema->topgrammar->start != NULL) && | |
| (schema->topgrammar->start->type == XML_RELAXNG_NOOP) && | |
| (schema->topgrammar->start->next != NULL)) | |
| schema->topgrammar->start = | |
| schema->topgrammar->start->content; | |
| xmlRelaxNGCheckRules(ctxt, schema->topgrammar->start, | |
| XML_RELAXNG_IN_START, XML_RELAXNG_NOOP); | |
| } | |
| } | |
| #ifdef DEBUG | |
| if (schema == NULL) | |
| xmlGenericError(xmlGenericErrorContext, | |
| "xmlRelaxNGParseDocument() failed\n"); | |
| #endif | |
| return (schema); | |
| } | |
| /************************************************************************ | |
| * * | |
| * Reading RelaxNGs * | |
| * * | |
| ************************************************************************/ | |
| /** | |
| * xmlRelaxNGNewParserCtxt: | |
| * @URL: the location of the schema | |
| * | |
| * Create an XML RelaxNGs parse context for that file/resource expected | |
| * to contain an XML RelaxNGs file. | |
| * | |
| * Returns the parser context or NULL in case of error | |
| */ | |
| xmlRelaxNGParserCtxtPtr | |
| xmlRelaxNGNewParserCtxt(const char *URL) | |
| { | |
| xmlRelaxNGParserCtxtPtr ret; | |
| if (URL == NULL) | |
| return (NULL); | |
| ret = | |
| (xmlRelaxNGParserCtxtPtr) xmlMalloc(sizeof(xmlRelaxNGParserCtxt)); | |
| if (ret == NULL) { | |
| xmlRngPErrMemory(NULL, "building parser\n"); | |
| return (NULL); | |
| } | |
| memset(ret, 0, sizeof(xmlRelaxNGParserCtxt)); | |
| ret->URL = xmlStrdup((const xmlChar *) URL); | |
| ret->error = xmlGenericError; | |
| ret->userData = xmlGenericErrorContext; | |
| return (ret); | |
| } | |
| /** | |
| * xmlRelaxNGNewMemParserCtxt: | |
| * @buffer: a pointer to a char array containing the schemas | |
| * @size: the size of the array | |
| * | |
| * Create an XML RelaxNGs parse context for that memory buffer expected | |
| * to contain an XML RelaxNGs file. | |
| * | |
| * Returns the parser context or NULL in case of error | |
| */ | |
| xmlRelaxNGParserCtxtPtr | |
| xmlRelaxNGNewMemParserCtxt(const char *buffer, int size) | |
| { | |
| xmlRelaxNGParserCtxtPtr ret; | |
| if ((buffer == NULL) || (size <= 0)) | |
| return (NULL); | |
| ret = | |
| (xmlRelaxNGParserCtxtPtr) xmlMalloc(sizeof(xmlRelaxNGParserCtxt)); | |
| if (ret == NULL) { | |
| xmlRngPErrMemory(NULL, "building parser\n"); | |
| return (NULL); | |
| } | |
| memset(ret, 0, sizeof(xmlRelaxNGParserCtxt)); | |
| ret->buffer = buffer; | |
| ret->size = size; | |
| ret->error = xmlGenericError; | |
| ret->userData = xmlGenericErrorContext; | |
| return (ret); | |
| } | |
| /** | |
| * xmlRelaxNGNewDocParserCtxt: | |
| * @doc: a preparsed document tree | |
| * | |
| * Create an XML RelaxNGs parser context for that document. | |
| * Note: since the process of compiling a RelaxNG schemas modifies the | |
| * document, the @doc parameter is duplicated internally. | |
| * | |
| * Returns the parser context or NULL in case of error | |
| */ | |
| xmlRelaxNGParserCtxtPtr | |
| xmlRelaxNGNewDocParserCtxt(xmlDocPtr doc) | |
| { | |
| xmlRelaxNGParserCtxtPtr ret; | |
| xmlDocPtr copy; | |
| if (doc == NULL) | |
| return (NULL); | |
| copy = xmlCopyDoc(doc, 1); | |
| if (copy == NULL) | |
| return (NULL); | |
| ret = | |
| (xmlRelaxNGParserCtxtPtr) xmlMalloc(sizeof(xmlRelaxNGParserCtxt)); | |
| if (ret == NULL) { | |
| xmlRngPErrMemory(NULL, "building parser\n"); | |
| return (NULL); | |
| } | |
| memset(ret, 0, sizeof(xmlRelaxNGParserCtxt)); | |
| ret->document = copy; | |
| ret->freedoc = 1; | |
| ret->userData = xmlGenericErrorContext; | |
| return (ret); | |
| } | |
| /** | |
| * xmlRelaxNGFreeParserCtxt: | |
| * @ctxt: the schema parser context | |
| * | |
| * Free the resources associated to the schema parser context | |
| */ | |
| void | |
| xmlRelaxNGFreeParserCtxt(xmlRelaxNGParserCtxtPtr ctxt) | |
| { | |
| if (ctxt == NULL) | |
| return; | |
| if (ctxt->URL != NULL) | |
| xmlFree(ctxt->URL); | |
| if (ctxt->doc != NULL) | |
| xmlRelaxNGFreeDocument(ctxt->doc); | |
| if (ctxt->interleaves != NULL) | |
| xmlHashFree(ctxt->interleaves, NULL); | |
| if (ctxt->documents != NULL) | |
| xmlRelaxNGFreeDocumentList(ctxt->documents); | |
| if (ctxt->includes != NULL) | |
| xmlRelaxNGFreeIncludeList(ctxt->includes); | |
| if (ctxt->docTab != NULL) | |
| xmlFree(ctxt->docTab); | |
| if (ctxt->incTab != NULL) | |
| xmlFree(ctxt->incTab); | |
| if (ctxt->defTab != NULL) { | |
| int i; | |
| for (i = 0; i < ctxt->defNr; i++) | |
| xmlRelaxNGFreeDefine(ctxt->defTab[i]); | |
| xmlFree(ctxt->defTab); | |
| } | |
| if ((ctxt->document != NULL) && (ctxt->freedoc)) | |
| xmlFreeDoc(ctxt->document); | |
| xmlFree(ctxt); | |
| } | |
| /** | |
| * xmlRelaxNGNormExtSpace: | |
| * @value: a value | |
| * | |
| * Removes the leading and ending spaces of the value | |
| * The string is modified "in situ" | |
| */ | |
| static void | |
| xmlRelaxNGNormExtSpace(xmlChar * value) | |
| { | |
| xmlChar *start = value; | |
| xmlChar *cur = value; | |
| if (value == NULL) | |
| return; | |
| while (IS_BLANK_CH(*cur)) | |
| cur++; | |
| if (cur == start) { | |
| do { | |
| while ((*cur != 0) && (!IS_BLANK_CH(*cur))) | |
| cur++; | |
| if (*cur == 0) | |
| return; | |
| start = cur; | |
| while (IS_BLANK_CH(*cur)) | |
| cur++; | |
| if (*cur == 0) { | |
| *start = 0; | |
| return; | |
| } | |
| } while (1); | |
| } else { | |
| do { | |
| while ((*cur != 0) && (!IS_BLANK_CH(*cur))) | |
| *start++ = *cur++; | |
| if (*cur == 0) { | |
| *start = 0; | |
| return; | |
| } | |
| /* don't try to normalize the inner spaces */ | |
| while (IS_BLANK_CH(*cur)) | |
| cur++; | |
| if (*cur == 0) { | |
| *start = 0; | |
| return; | |
| } | |
| *start++ = *cur++; | |
| } while (1); | |
| } | |
| } | |
| /** | |
| * xmlRelaxNGCleanupAttributes: | |
| * @ctxt: a Relax-NG parser context | |
| * @node: a Relax-NG node | |
| * | |
| * Check all the attributes on the given node | |
| */ | |
| static void | |
| xmlRelaxNGCleanupAttributes(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node) | |
| { | |
| xmlAttrPtr cur, next; | |
| cur = node->properties; | |
| while (cur != NULL) { | |
| next = cur->next; | |
| if ((cur->ns == NULL) || | |
| (xmlStrEqual(cur->ns->href, xmlRelaxNGNs))) { | |
| if (xmlStrEqual(cur->name, BAD_CAST "name")) { | |
| if ((!xmlStrEqual(node->name, BAD_CAST "element")) && | |
| (!xmlStrEqual(node->name, BAD_CAST "attribute")) && | |
| (!xmlStrEqual(node->name, BAD_CAST "ref")) && | |
| (!xmlStrEqual(node->name, BAD_CAST "parentRef")) && | |
| (!xmlStrEqual(node->name, BAD_CAST "param")) && | |
| (!xmlStrEqual(node->name, BAD_CAST "define"))) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_FORBIDDEN_ATTRIBUTE, | |
| "Attribute %s is not allowed on %s\n", | |
| cur->name, node->name); | |
| } | |
| } else if (xmlStrEqual(cur->name, BAD_CAST "type")) { | |
| if ((!xmlStrEqual(node->name, BAD_CAST "value")) && | |
| (!xmlStrEqual(node->name, BAD_CAST "data"))) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_FORBIDDEN_ATTRIBUTE, | |
| "Attribute %s is not allowed on %s\n", | |
| cur->name, node->name); | |
| } | |
| } else if (xmlStrEqual(cur->name, BAD_CAST "href")) { | |
| if ((!xmlStrEqual(node->name, BAD_CAST "externalRef")) && | |
| (!xmlStrEqual(node->name, BAD_CAST "include"))) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_FORBIDDEN_ATTRIBUTE, | |
| "Attribute %s is not allowed on %s\n", | |
| cur->name, node->name); | |
| } | |
| } else if (xmlStrEqual(cur->name, BAD_CAST "combine")) { | |
| if ((!xmlStrEqual(node->name, BAD_CAST "start")) && | |
| (!xmlStrEqual(node->name, BAD_CAST "define"))) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_FORBIDDEN_ATTRIBUTE, | |
| "Attribute %s is not allowed on %s\n", | |
| cur->name, node->name); | |
| } | |
| } else if (xmlStrEqual(cur->name, BAD_CAST "datatypeLibrary")) { | |
| xmlChar *val; | |
| xmlURIPtr uri; | |
| val = xmlNodeListGetString(node->doc, cur->children, 1); | |
| if (val != NULL) { | |
| if (val[0] != 0) { | |
| uri = xmlParseURI((const char *) val); | |
| if (uri == NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_INVALID_URI, | |
| "Attribute %s contains invalid URI %s\n", | |
| cur->name, val); | |
| } else { | |
| if (uri->scheme == NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_URI_NOT_ABSOLUTE, | |
| "Attribute %s URI %s is not absolute\n", | |
| cur->name, val); | |
| } | |
| if (uri->fragment != NULL) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_URI_FRAGMENT, | |
| "Attribute %s URI %s has a fragment ID\n", | |
| cur->name, val); | |
| } | |
| xmlFreeURI(uri); | |
| } | |
| } | |
| xmlFree(val); | |
| } | |
| } else if (!xmlStrEqual(cur->name, BAD_CAST "ns")) { | |
| xmlRngPErr(ctxt, node, XML_RNGP_UNKNOWN_ATTRIBUTE, | |
| "Unknown attribute %s on %s\n", cur->name, | |
| node->name); | |
| } | |
| } | |
| cur = next; | |
| } | |
| } | |
| /** | |
| * xmlRelaxNGCleanupTree: | |
| * @ctxt: a Relax-NG parser context | |
| * @root: an xmlNodePtr subtree | |
| * | |
| * Cleanup the subtree from unwanted nodes for parsing, resolve | |
| * Include and externalRef lookups. | |
| */ | |
| static void | |
| xmlRelaxNGCleanupTree(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr root) | |
| { | |
| xmlNodePtr cur, delete; | |
| delete = NULL; | |
| cur = root; | |
| while (cur != NULL) { | |
| if (delete != NULL) { | |
| xmlUnlinkNode(delete); | |
| xmlFreeNode(delete); | |
| delete = NULL; | |
| } | |
| if (cur->type == XML_ELEMENT_NODE) { | |
| /* | |
| * Simplification 4.1. Annotations | |
| */ | |
| if ((cur->ns == NULL) || | |
| (!xmlStrEqual(cur->ns->href, xmlRelaxNGNs))) { | |
| if ((cur->parent != NULL) && | |
| (cur->parent->type == XML_ELEMENT_NODE) && | |
| ((xmlStrEqual(cur->parent->name, BAD_CAST "name")) || | |
| (xmlStrEqual(cur->parent->name, BAD_CAST "value")) || | |
| (xmlStrEqual(cur->parent->name, BAD_CAST "param")))) { | |
| xmlRngPErr(ctxt, cur, XML_RNGP_FOREIGN_ELEMENT, | |
| "element %s doesn't allow foreign elements\n", | |
| cur->parent->name, NULL); | |
| } | |
| delete = cur; | |
| goto skip_children; | |
| } else { | |
| xmlRelaxNGCleanupAttributes(ctxt, cur); | |
| if (xmlStrEqual(cur->name, BAD_CAST "externalRef")) { | |
| xmlChar *href, *ns, *base, *URL; | |
| xmlRelaxNGDocumentPtr docu; | |
| xmlNodePtr tmp; | |
| xmlURIPtr uri; | |
| ns = xmlGetProp(cur, BAD_CAST "ns"); | |
| if (ns == NULL) { | |
| tmp = cur->parent; | |
| while ((tmp != NULL) && | |
| (tmp->type == XML_ELEMENT_NODE)) { | |
| ns = xmlGetProp(tmp, BAD_CAST "ns"); | |
| if (ns != NULL) | |
| break; | |
| tmp = tmp->parent; | |
| } | |
| } | |
| href = xmlGetProp(cur, BAD_CAST "href"); | |
| if (href == NULL) { | |
| xmlRngPErr(ctxt, cur, XML_RNGP_MISSING_HREF, | |
| "xmlRelaxNGParse: externalRef has no href attribute\n", | |
| NULL, NULL); | |
| if (ns != NULL) | |
| xmlFree(ns); | |
| delete = cur; | |
| goto skip_children; | |
| } | |
| uri = xmlParseURI((const char *) href); | |
| if (uri == NULL) { | |
| xmlRngPErr(ctxt, cur, XML_RNGP_HREF_ERROR, | |
| "Incorrect URI for externalRef %s\n", | |
| href, NULL); | |
| if (ns != NULL) | |
| xmlFree(ns); | |
| if (href != NULL) | |
| xmlFree(href); | |
| delete = cur; | |
| goto skip_children; | |
| } | |
| if (uri->fragment != NULL) { | |
| xmlRngPErr(ctxt, cur, XML_RNGP_HREF_ERROR, | |
| "Fragment forbidden in URI for externalRef %s\n", | |
| href, NULL); | |
| if (ns != NULL) | |
| xmlFree(ns); | |
| xmlFreeURI(uri); | |
| if (href != NULL) | |
| xmlFree(href); | |
| delete = cur; | |
| goto skip_children; | |
| } | |
| xmlFreeURI(uri); | |
| base = xmlNodeGetBase(cur->doc, cur); | |
| URL = xmlBuildURI(href, base); | |
| if (URL == NULL) { | |
| xmlRngPErr(ctxt, cur, XML_RNGP_HREF_ERROR, | |
| "Failed to compute URL for externalRef %s\n", | |
| href, NULL); | |
| if (ns != NULL) | |
| xmlFree(ns); | |
| if (href != NULL) | |
| xmlFree(href); | |
| if (base != NULL) | |
| xmlFree(base); | |
| delete = cur; | |
| goto skip_children; | |
| } | |
| if (href != NULL) | |
| xmlFree(href); | |
| if (base != NULL) | |
| xmlFree(base); | |
| docu = xmlRelaxNGLoadExternalRef(ctxt, URL, ns); | |
| if (docu == NULL) { | |
| xmlRngPErr(ctxt, cur, XML_RNGP_EXTERNAL_REF_FAILURE, | |
| "Failed to load externalRef %s\n", URL, | |
| NULL); | |
| if (ns != NULL) | |
| xmlFree(ns); | |
| xmlFree(URL); | |
| delete = cur; | |
| goto skip_children; | |
| } | |
| if (ns != NULL) | |
| xmlFree(ns); | |
| xmlFree(URL); | |
| cur->psvi = docu; | |
| } else if (xmlStrEqual(cur->name, BAD_CAST "include")) { | |
| xmlChar *href, *ns, *base, *URL; | |
| xmlRelaxNGIncludePtr incl; | |
| xmlNodePtr tmp; | |
| href = xmlGetProp(cur, BAD_CAST "href"); | |
| if (href == NULL) { | |
| xmlRngPErr(ctxt, cur, XML_RNGP_MISSING_HREF, | |
| "xmlRelaxNGParse: include has no href attribute\n", | |
| NULL, NULL); | |
| delete = cur; | |
| goto skip_children; | |
| } | |
| base = xmlNodeGetBase(cur->doc, cur); | |
| URL = xmlBuildURI(href, base); | |
| if (URL == NULL) { | |
| xmlRngPErr(ctxt, cur, XML_RNGP_HREF_ERROR, | |
| "Failed to compute URL for include %s\n", | |
| href, NULL); | |
| if (href != NULL) | |
| xmlFree(href); | |
| if (base != NULL) | |
| xmlFree(base); | |
| delete = cur; | |
| goto skip_children; | |
| } | |
| if (href != NULL) | |
| xmlFree(href); | |
| if (base != NULL) | |
| xmlFree(base); | |
| ns = xmlGetProp(cur, BAD_CAST "ns"); | |
| if (ns == NULL) { | |
| tmp = cur->parent; | |
| while ((tmp != NULL) && | |
| (tmp->type == XML_ELEMENT_NODE)) { | |
| ns = xmlGetProp(tmp, BAD_CAST "ns"); | |
| if (ns != NULL) | |
| break; | |
| tmp = tmp->parent; | |
| } | |
| } | |
| incl = xmlRelaxNGLoadInclude(ctxt, URL, cur, ns); | |
| if (ns != NULL) | |
| xmlFree(ns); | |
| if (incl == NULL) { | |
| xmlRngPErr(ctxt, cur, XML_RNGP_INCLUDE_FAILURE, | |
| "Failed to load include %s\n", URL, | |
| NULL); | |
| xmlFree(URL); | |
| delete = cur; | |
| goto skip_children; | |
| } | |
| xmlFree(URL); | |
| cur->psvi = incl; | |
| } else if ((xmlStrEqual(cur->name, BAD_CAST "element")) || | |
| (xmlStrEqual(cur->name, BAD_CAST "attribute"))) | |
| { | |
| xmlChar *name, *ns; | |
| xmlNodePtr text = NULL; | |
| /* | |
| * Simplification 4.8. name attribute of element | |
| * and attribute elements | |
| */ | |
| name = xmlGetProp(cur, BAD_CAST "name"); | |
| if (name != NULL) { | |
| if (cur->children == NULL) { | |
| text = | |
| xmlNewChild(cur, cur->ns, BAD_CAST "name", | |
| name); | |
| } else { | |
| xmlNodePtr node; | |
| node = xmlNewDocNode(cur->doc, cur->ns, | |
| BAD_CAST "name", NULL); | |
| if (node != NULL) { | |
| xmlAddPrevSibling(cur->children, node); | |
| text = xmlNewText(name); | |
| xmlAddChild(node, text); | |
| text = node; | |
| } | |
| } | |
| if (text == NULL) { | |
| xmlRngPErr(ctxt, cur, XML_RNGP_CREATE_FAILURE, | |
| "Failed to create a name %s element\n", | |
| name, NULL); | |
| } | |
| xmlUnsetProp(cur, BAD_CAST "name"); | |
| xmlFree(name); | |
| ns = xmlGetProp(cur, BAD_CAST "ns"); | |
| if (ns != NULL) { | |
| if (text != NULL) { | |
| xmlSetProp(text, BAD_CAST "ns", ns); | |
| /* xmlUnsetProp(cur, BAD_CAST "ns"); */ | |
| } | |
| xmlFree(ns); | |
| } else if (xmlStrEqual(cur->name, | |
| BAD_CAST "attribute")) { | |
| xmlSetProp(text, BAD_CAST "ns", BAD_CAST ""); | |
| } | |
| } | |
| } else if ((xmlStrEqual(cur->name, BAD_CAST "name")) || | |
| (xmlStrEqual(cur->name, BAD_CAST "nsName")) || | |
| (xmlStrEqual(cur->name, BAD_CAST "value"))) { | |
| /* | |
| * Simplification 4.8. name attribute of element | |
| * and attribute elements | |
| */ | |
| if (xmlHasProp(cur, BAD_CAST "ns") == NULL) { | |
| xmlNodePtr node; | |
| xmlChar *ns = NULL; | |
| node = cur->parent; | |
| while ((node != NULL) && | |
| (node->type == XML_ELEMENT_NODE)) { | |
| ns = xmlGetProp(node, BAD_CAST "ns"); | |
| if (ns != NULL) { | |
| break; | |
| } | |
| node = node->parent; | |
| } | |
| if (ns == NULL) { | |
| xmlSetProp(cur, BAD_CAST "ns", BAD_CAST ""); | |
| } else { | |
| xmlSetProp(cur, BAD_CAST "ns", ns); | |
| xmlFree(ns); | |
| } | |
| } | |
| if (xmlStrEqual(cur->name, BAD_CAST "name")) { | |
| xmlChar *name, *local, *prefix; | |
| /* | |
| * Simplification: 4.10. QNames | |
| */ | |
| name = xmlNodeGetContent(cur); | |
| if (name != NULL) { | |
| local = xmlSplitQName2(name, &prefix); | |
| if (local != NULL) { | |
| xmlNsPtr ns; | |
| ns = xmlSearchNs(cur->doc, cur, prefix); | |
| if (ns == NULL) { | |
| xmlRngPErr(ctxt, cur, | |
| XML_RNGP_PREFIX_UNDEFINED, | |
| "xmlRelaxNGParse: no namespace for prefix %s\n", | |
| prefix, NULL); | |
| } else { | |
| xmlSetProp(cur, BAD_CAST "ns", | |
| ns->href); | |
| xmlNodeSetContent(cur, local); | |
| } | |
| xmlFree(local); | |
| xmlFree(prefix); | |
| } | |
| xmlFree(name); | |
| } | |
| } | |
| /* | |
| * 4.16 | |
| */ | |
| if (xmlStrEqual(cur->name, BAD_CAST "nsName")) { | |
| if (ctxt->flags & XML_RELAXNG_IN_NSEXCEPT) { | |
| xmlRngPErr(ctxt, cur, | |
| XML_RNGP_PAT_NSNAME_EXCEPT_NSNAME, | |
| "Found nsName/except//nsName forbidden construct\n", | |
| NULL, NULL); | |
| } | |
| } | |
| } else if ((xmlStrEqual(cur->name, BAD_CAST "except")) && | |
| (cur != root)) { | |
| int oldflags = ctxt->flags; | |
| /* | |
| * 4.16 | |
| */ | |
| if ((cur->parent != NULL) && | |
| (xmlStrEqual | |
| (cur->parent->name, BAD_CAST "anyName"))) { | |
| ctxt->flags |= XML_RELAXNG_IN_ANYEXCEPT; | |
| xmlRelaxNGCleanupTree(ctxt, cur); | |
| ctxt->flags = oldflags; | |
| goto skip_children; | |
| } else if ((cur->parent != NULL) && | |
| (xmlStrEqual | |
| (cur->parent->name, BAD_CAST "nsName"))) { | |
| ctxt->flags |= XML_RELAXNG_IN_NSEXCEPT; | |
| xmlRelaxNGCleanupTree(ctxt, cur); | |
| ctxt->flags = oldflags; | |
| goto skip_children; | |
| } | |
| } else if (xmlStrEqual(cur->name, BAD_CAST "anyName")) { | |
| /* | |
| * 4.16 | |
| */ | |
| if (ctxt->flags & XML_RELAXNG_IN_ANYEXCEPT) { | |
| xmlRngPErr(ctxt, cur, | |
| XML_RNGP_PAT_ANYNAME_EXCEPT_ANYNAME, | |
| "Found anyName/except//anyName forbidden construct\n", | |
| NULL, NULL); | |
| } else if (ctxt->flags & XML_RELAXNG_IN_NSEXCEPT) { | |
| xmlRngPErr(ctxt, cur, | |
| XML_RNGP_PAT_NSNAME_EXCEPT_ANYNAME, | |
| "Found nsName/except//anyName forbidden construct\n", | |
| NULL, NULL); | |
| } | |
| } | |
| /* | |
| * This is not an else since "include" is transformed | |
| * into a div | |
| */ | |
| if (xmlStrEqual(cur->name, BAD_CAST "div")) { | |
| xmlChar *ns; | |
| xmlNodePtr child, ins, tmp; | |
| /* | |
| * implements rule 4.11 | |
| */ | |
| ns = xmlGetProp(cur, BAD_CAST "ns"); | |
| child = cur->children; | |
| ins = cur; | |
| while (child != NULL) { | |
| if (ns != NULL) { | |
| if (!xmlHasProp(child, BAD_CAST "ns")) { | |
| xmlSetProp(child, BAD_CAST "ns", ns); | |
| } | |
| } | |
| tmp = child->next; | |
| xmlUnlinkNode(child); | |
| ins = xmlAddNextSibling(ins, child); | |
| child = tmp; | |
| } | |
| if (ns != NULL) | |
| xmlFree(ns); | |
| /* | |
| * Since we are about to delete cur, if its nsDef is non-NULL we | |
| * need to preserve it (it contains the ns definitions for the | |
| * children we just moved). We'll just stick it on to the end | |
| * of cur->parent's list, since it's never going to be re-serialized | |
| * (bug 143738). | |
| */ | |
| if ((cur->nsDef != NULL) && (cur->parent != NULL)) { | |
| xmlNsPtr parDef = (xmlNsPtr)&cur->parent->nsDef; | |
| while (parDef->next != NULL) | |
| parDef = parDef->next; | |
| parDef->next = cur->nsDef; | |
| cur->nsDef = NULL; | |
| } | |
| delete = cur; | |
| goto skip_children; | |
| } | |
| } | |
| } | |
| /* | |
| * Simplification 4.2 whitespaces | |
| */ | |
| else if ((cur->type == XML_TEXT_NODE) || | |
| (cur->type == XML_CDATA_SECTION_NODE)) { | |
| if (IS_BLANK_NODE(cur)) { | |
| if ((cur->parent != NULL) && | |
| (cur->parent->type == XML_ELEMENT_NODE)) { | |
| if ((!xmlStrEqual(cur->parent->name, BAD_CAST "value")) | |
| && | |
| (!xmlStrEqual | |
| (cur->parent->name, BAD_CAST "param"))) | |
| delete = cur; | |
| } else { | |
| delete = cur; | |
| goto skip_children; | |
| } | |
| } | |
| } else { | |
| delete = cur; | |
| goto skip_children; | |
| } | |
| /* | |
| * Skip to next node | |
| */ | |
| if (cur->children != NULL) { | |
| if ((cur->children->type != XML_ENTITY_DECL) && | |
| (cur->children->type != XML_ENTITY_REF_NODE) && | |
| (cur->children->type != XML_ENTITY_NODE)) { | |
| cur = cur->children; | |
| continue; | |
| } | |
| } | |
| skip_children: | |
| if (cur->next != NULL) { | |
| cur = cur->next; | |
| continue; | |
| } | |
| do { | |
| cur = cur->parent; | |
| if (cur == NULL) | |
| break; | |
| if (cur == root) { | |
| cur = NULL; | |
| break; | |
| } | |
| if (cur->next != NULL) { | |
| cur = cur->next; | |
| break; | |
| } | |
| } while (cur != NULL); | |
| } | |
| if (delete != NULL) { | |
| xmlUnlinkNode(delete); | |
| xmlFreeNode(delete); | |
| delete = NULL; | |
| } | |
| } | |
| /** | |
| * xmlRelaxNGCleanupDoc: | |
| * @ctxt: a Relax-NG parser context | |
| * @doc: an xmldocPtr document pointer | |
| * | |
| * Cleanup the document from unwanted nodes for parsing, resolve | |
| * Include and externalRef lookups. | |
| * | |
| * Returns the cleaned up document or NULL in case of error | |
| */ | |
| static xmlDocPtr | |
| xmlRelaxNGCleanupDoc(xmlRelaxNGParserCtxtPtr ctxt, xmlDocPtr doc) | |
| { | |
| xmlNodePtr root; | |
| /* | |
| * Extract the root | |
| */ | |
| root = xmlDocGetRootElement(doc); | |
| if (root == NULL) { | |
| xmlRngPErr(ctxt, (xmlNodePtr) doc, XML_RNGP_EMPTY, "xmlRelaxNGParse: %s is empty\n", | |
| ctxt->URL, NULL); | |
| return (NULL); | |
| } | |
| xmlRelaxNGCleanupTree(ctxt, root); | |
| return (doc); | |
| } | |
| /** | |
| * xmlRelaxNGParse: | |
| * @ctxt: a Relax-NG parser context | |
| * | |
| * parse a schema definition resource and build an internal | |
| * XML Shema struture which can be used to validate instances. | |
| * | |
| * Returns the internal XML RelaxNG structure built from the resource or | |
| * NULL in case of error | |
| */ | |
| xmlRelaxNGPtr | |
| xmlRelaxNGParse(xmlRelaxNGParserCtxtPtr ctxt) | |
| { | |
| xmlRelaxNGPtr ret = NULL; | |
| xmlDocPtr doc; | |
| xmlNodePtr root; | |
| xmlRelaxNGInitTypes(); | |
| if (ctxt == NULL) | |
| return (NULL); | |
| /* | |
| * First step is to parse the input document into an DOM/Infoset | |
| */ | |
| if (ctxt->URL != NULL) { | |
| doc = xmlReadFile((const char *) ctxt->URL,NULL,0); | |
| if (doc == NULL) { | |
| xmlRngPErr(ctxt, NULL, XML_RNGP_PARSE_ERROR, | |
| "xmlRelaxNGParse: could not load %s\n", ctxt->URL, | |
| NULL); | |
| return (NULL); | |
| } | |
| } else if (ctxt->buffer != NULL) { | |
| doc = xmlReadMemory(ctxt->buffer, ctxt->size,NULL,NULL,0); | |
| if (doc == NULL) { | |
| xmlRngPErr(ctxt, NULL, XML_RNGP_PARSE_ERROR, | |
| "xmlRelaxNGParse: could not parse schemas\n", NULL, | |
| NULL); | |
| return (NULL); | |
| } | |
| doc->URL = xmlStrdup(BAD_CAST "in_memory_buffer"); | |
| ctxt->URL = xmlStrdup(BAD_CAST "in_memory_buffer"); | |
| } else if (ctxt->document != NULL) { | |
| doc = ctxt->document; | |
| } else { | |
| xmlRngPErr(ctxt, NULL, XML_RNGP_EMPTY, | |
| "xmlRelaxNGParse: nothing to parse\n", NULL, NULL); | |
| return (NULL); | |
| } | |
| ctxt->document = doc; | |
| /* | |
| * Some preprocessing of the document content | |
| */ | |
| doc = xmlRelaxNGCleanupDoc(ctxt, doc); | |
| if (doc == NULL) { | |
| xmlFreeDoc(ctxt->document); | |
| ctxt->document = NULL; | |
| return (NULL); | |
| } | |
| /* | |
| * Then do the parsing for good | |
| */ | |
| root = xmlDocGetRootElement(doc); | |
| if (root == NULL) { | |
| xmlRngPErr(ctxt, (xmlNodePtr) doc, | |
| XML_RNGP_EMPTY, "xmlRelaxNGParse: %s is empty\n", | |
| (ctxt->URL ? ctxt->URL : BAD_CAST "schemas"), NULL); | |
| xmlFreeDoc(ctxt->document); | |
| ctxt->document = NULL; | |
| return (NULL); | |
| } | |
| ret = xmlRelaxNGParseDocument(ctxt, root); | |
| if (ret == NULL) { | |
| xmlFreeDoc(ctxt->document); | |
| ctxt->document = NULL; | |
| return (NULL); | |
| } | |
| /* | |
| * Check the ref/defines links | |
| */ | |
| /* | |
| * try to preprocess interleaves | |
| */ | |
| if (ctxt->interleaves != NULL) { | |
| xmlHashScan(ctxt->interleaves, | |
| (xmlHashScanner) xmlRelaxNGComputeInterleaves, ctxt); | |
| } | |
| /* | |
| * if there was a parsing error return NULL | |
| */ | |
| if (ctxt->nbErrors > 0) { | |
| xmlRelaxNGFree(ret); | |
| ctxt->document = NULL; | |
| xmlFreeDoc(doc); | |
| return (NULL); | |
| } | |
| /* | |
| * try to compile (parts of) the schemas | |
| */ | |
| if ((ret->topgrammar != NULL) && (ret->topgrammar->start != NULL)) { | |
| if (ret->topgrammar->start->type != XML_RELAXNG_START) { | |
| xmlRelaxNGDefinePtr def; | |
| def = xmlRelaxNGNewDefine(ctxt, NULL); | |
| if (def != NULL) { | |
| def->type = XML_RELAXNG_START; | |
| def->content = ret->topgrammar->start; | |
| ret->topgrammar->start = def; | |
| } | |
| } | |
| xmlRelaxNGTryCompile(ctxt, ret->topgrammar->start); | |
| } | |
| /* | |
| * Transfer the pointer for cleanup at the schema level. | |
| */ | |
| ret->doc = doc; | |
| ctxt->document = NULL; | |
| ret->documents = ctxt->documents; | |
| ctxt->documents = NULL; | |
| ret->includes = ctxt->includes; | |
| ctxt->includes = NULL; | |
| ret->defNr = ctxt->defNr; | |
| ret->defTab = ctxt->defTab; | |
| ctxt->defTab = NULL; | |
| if (ctxt->idref == 1) | |
| ret->idref = 1; | |
| return (ret); | |
| } | |
| /** | |
| * xmlRelaxNGSetParserErrors: | |
| * @ctxt: a Relax-NG validation context | |
| * @err: the error callback | |
| * @warn: the warning callback | |
| * @ctx: contextual data for the callbacks | |
| * | |
| * Set the callback functions used to handle errors for a validation context | |
| */ | |
| void | |
| xmlRelaxNGSetParserErrors(xmlRelaxNGParserCtxtPtr ctxt, | |
| xmlRelaxNGValidityErrorFunc err, | |
| xmlRelaxNGValidityWarningFunc warn, void *ctx) | |
| { | |
| if (ctxt == NULL) | |
| return; | |
| ctxt->error = err; | |
| ctxt->warning = warn; | |
| ctxt->serror = NULL; | |
| ctxt->userData = ctx; | |
| } | |
| /** | |
| * xmlRelaxNGGetParserErrors: | |
| * @ctxt: a Relax-NG validation context | |
| * @err: the error callback result | |
| * @warn: the warning callback result | |
| * @ctx: contextual data for the callbacks result | |
| * | |
| * Get the callback information used to handle errors for a validation context | |
| * | |
| * Returns -1 in case of failure, 0 otherwise. | |
| */ | |
| int | |
| xmlRelaxNGGetParserErrors(xmlRelaxNGParserCtxtPtr ctxt, | |
| xmlRelaxNGValidityErrorFunc * err, | |
| xmlRelaxNGValidityWarningFunc * warn, void **ctx) | |
| { | |
| if (ctxt == NULL) | |
| return (-1); | |
| if (err != NULL) | |
| *err = ctxt->error; | |
| if (warn != NULL) | |
| *warn = ctxt->warning; | |
| if (ctx != NULL) | |
| *ctx = ctxt->userData; | |
| return (0); | |
| } | |
| /** | |
| * xmlRelaxNGSetParserStructuredErrors: | |
| * @ctxt: a Relax-NG parser context | |
| * @serror: the error callback | |
| * @ctx: contextual data for the callbacks | |
| * | |
| * Set the callback functions used to handle errors for a parsing context | |
| */ | |
| void | |
| xmlRelaxNGSetParserStructuredErrors(xmlRelaxNGParserCtxtPtr ctxt, | |
| xmlStructuredErrorFunc serror, | |
| void *ctx) | |
| { | |
| if (ctxt == NULL) | |
| return; | |
| ctxt->serror = serror; | |
| ctxt->error = NULL; | |
| ctxt->warning = NULL; | |
| ctxt->userData = ctx; | |
| } | |
| #ifdef LIBXML_OUTPUT_ENABLED | |
| /************************************************************************ | |
| * * | |
| * Dump back a compiled form * | |
| * * | |
| ************************************************************************/ | |
| static void xmlRelaxNGDumpDefine(FILE * output, | |
| xmlRelaxNGDefinePtr define); | |
| /** | |
| * xmlRelaxNGDumpDefines: | |
| * @output: the file output | |
| * @defines: a list of define structures | |
| * | |
| * Dump a RelaxNG structure back | |
| */ | |
| static void | |
| xmlRelaxNGDumpDefines(FILE * output, xmlRelaxNGDefinePtr defines) | |
| { | |
| while (defines != NULL) { | |
| xmlRelaxNGDumpDefine(output, defines); | |
| defines = defines->next; | |
| } | |
| } | |
| /** | |
| * xmlRelaxNGDumpDefine: | |
| * @output: the file output | |
| * @define: a define structure | |
| * | |
| * Dump a RelaxNG structure back | |
| */ | |
| static void | |
| xmlRelaxNGDumpDefine(FILE * output, xmlRelaxNGDefinePtr define) | |
| { | |
| if (define == NULL) | |
| return; | |
| switch (define->type) { | |
| case XML_RELAXNG_EMPTY: | |
| fprintf(output, "<empty/>\n"); | |
| break; | |
| case XML_RELAXNG_NOT_ALLOWED: | |
| fprintf(output, "<notAllowed/>\n"); | |
| break; | |
| case XML_RELAXNG_TEXT: | |
| fprintf(output, "<text/>\n"); | |
| break; | |
| case XML_RELAXNG_ELEMENT: | |
| fprintf(output, "<element>\n"); | |
| if (define->name != NULL) { | |
| fprintf(output, "<name"); | |
| if (define->ns != NULL) | |
| fprintf(output, " ns=\"%s\"", define->ns); | |
| fprintf(output, ">%s</name>\n", define->name); | |
| } | |
| xmlRelaxNGDumpDefines(output, define->attrs); | |
| xmlRelaxNGDumpDefines(output, define->content); | |
| fprintf(output, "</element>\n"); | |
| break; | |
| case XML_RELAXNG_LIST: | |
| fprintf(output, "<list>\n"); | |
| xmlRelaxNGDumpDefines(output, define->content); | |
| fprintf(output, "</list>\n"); | |
| break; | |
| case XML_RELAXNG_ONEORMORE: | |
| fprintf(output, "<oneOrMore>\n"); | |
| xmlRelaxNGDumpDefines(output, define->content); | |
| fprintf(output, "</oneOrMore>\n"); | |
| break; | |
| case XML_RELAXNG_ZEROORMORE: | |
| fprintf(output, "<zeroOrMore>\n"); | |
| xmlRelaxNGDumpDefines(output, define->content); | |
| fprintf(output, "</zeroOrMore>\n"); | |
| break; | |
| case XML_RELAXNG_CHOICE: | |
| fprintf(output, "<choice>\n"); | |
| xmlRelaxNGDumpDefines(output, define->content); | |
| fprintf(output, "</choice>\n"); | |
| break; | |
| case XML_RELAXNG_GROUP: | |
| fprintf(output, "<group>\n"); | |
| xmlRelaxNGDumpDefines(output, define->content); | |
| fprintf(output, "</group>\n"); | |
| break; | |
| case XML_RELAXNG_INTERLEAVE: | |
| fprintf(output, "<interleave>\n"); | |
| xmlRelaxNGDumpDefines(output, define->content); | |
| fprintf(output, "</interleave>\n"); | |
| break; | |
| case XML_RELAXNG_OPTIONAL: | |
| fprintf(output, "<optional>\n"); | |
| xmlRelaxNGDumpDefines(output, define->content); | |
| fprintf(output, "</optional>\n"); | |
| break; | |
| case XML_RELAXNG_ATTRIBUTE: | |
| fprintf(output, "<attribute>\n"); | |
| xmlRelaxNGDumpDefines(output, define->content); | |
| fprintf(output, "</attribute>\n"); | |
| break; | |
| case XML_RELAXNG_DEF: | |
| fprintf(output, "<define"); | |
| if (define->name != NULL) | |
| fprintf(output, " name=\"%s\"", define->name); | |
| fprintf(output, ">\n"); | |
| xmlRelaxNGDumpDefines(output, define->content); | |
| fprintf(output, "</define>\n"); | |
| break; | |
| case XML_RELAXNG_REF: | |
| fprintf(output, "<ref"); | |
| if (define->name != NULL) | |
| fprintf(output, " name=\"%s\"", define->name); | |
| fprintf(output, ">\n"); | |
| xmlRelaxNGDumpDefines(output, define->content); | |
| fprintf(output, "</ref>\n"); | |
| break; | |
| case XML_RELAXNG_PARENTREF: | |
| fprintf(output, "<parentRef"); | |
| if (define->name != NULL) | |
| fprintf(output, " name=\"%s\"", define->name); | |
| fprintf(output, ">\n"); | |
| xmlRelaxNGDumpDefines(output, define->content); | |
| fprintf(output, "</parentRef>\n"); | |
| break; | |
| case XML_RELAXNG_EXTERNALREF: | |
| fprintf(output, "<externalRef>"); | |
| xmlRelaxNGDumpDefines(output, define->content); | |
| fprintf(output, "</externalRef>\n"); | |
| break; | |
| case XML_RELAXNG_DATATYPE: | |
| case XML_RELAXNG_VALUE: | |
| TODO break; | |
| case XML_RELAXNG_START: | |
| case XML_RELAXNG_EXCEPT: | |
| case XML_RELAXNG_PARAM: | |
| TODO break; | |
| case XML_RELAXNG_NOOP: | |
| xmlRelaxNGDumpDefines(output, define->content); | |
| break; | |
| } | |
| } | |
| /** | |
| * xmlRelaxNGDumpGrammar: | |
| * @output: the file output | |
| * @grammar: a grammar structure | |
| * @top: is this a top grammar | |
| * | |
| * Dump a RelaxNG structure back | |
| */ | |
| static void | |
| xmlRelaxNGDumpGrammar(FILE * output, xmlRelaxNGGrammarPtr grammar, int top) | |
| { | |
| if (grammar == NULL) | |
| return; | |
| fprintf(output, "<grammar"); | |
| if (top) | |
| fprintf(output, " xmlns=\"http://relaxng.org/ns/structure/1.0\""); | |
| switch (grammar->combine) { | |
| case XML_RELAXNG_COMBINE_UNDEFINED: | |
| break; | |
| case XML_RELAXNG_COMBINE_CHOICE: | |
| fprintf(output, " combine=\"choice\""); | |
| break; | |
| case XML_RELAXNG_COMBINE_INTERLEAVE: | |
| fprintf(output, " combine=\"interleave\""); | |
| break; | |
| default: | |
| fprintf(output, " <!-- invalid combine value -->"); | |
| } | |
| fprintf(output, ">\n"); | |
| if (grammar->start == NULL) { | |
| fprintf(output, " <!-- grammar had no start -->"); | |
| } else { | |
| fprintf(output, "<start>\n"); | |
| xmlRelaxNGDumpDefine(output, grammar->start); | |
| fprintf(output, "</start>\n"); | |
| } | |
| /* TODO ? Dump the defines ? */ | |
| fprintf(output, "</grammar>\n"); | |
| } | |
| /** | |
| * xmlRelaxNGDump: | |
| * @output: the file output | |
| * @schema: a schema structure | |
| * | |
| * Dump a RelaxNG structure back | |
| */ | |
| void | |
| xmlRelaxNGDump(FILE * output, xmlRelaxNGPtr schema) | |
| { | |
| if (output == NULL) | |
| return; | |
| if (schema == NULL) { | |
| fprintf(output, "RelaxNG empty or failed to compile\n"); | |
| return; | |
| } | |
| fprintf(output, "RelaxNG: "); | |
| if (schema->doc == NULL) { | |
| fprintf(output, "no document\n"); | |
| } else if (schema->doc->URL != NULL) { | |
| fprintf(output, "%s\n", schema->doc->URL); | |
| } else { | |
| fprintf(output, "\n"); | |
| } | |
| if (schema->topgrammar == NULL) { | |
| fprintf(output, "RelaxNG has no top grammar\n"); | |
| return; | |
| } | |
| xmlRelaxNGDumpGrammar(output, schema->topgrammar, 1); | |
| } | |
| /** | |
| * xmlRelaxNGDumpTree: | |
| * @output: the file output | |
| * @schema: a schema structure | |
| * | |
| * Dump the transformed RelaxNG tree. | |
| */ | |
| void | |
| xmlRelaxNGDumpTree(FILE * output, xmlRelaxNGPtr schema) | |
| { | |
| if (output == NULL) | |
| return; | |
| if (schema == NULL) { | |
| fprintf(output, "RelaxNG empty or failed to compile\n"); | |
| return; | |
| } | |
| if (schema->doc == NULL) { | |
| fprintf(output, "no document\n"); | |
| } else { | |
| xmlDocDump(output, schema->doc); | |
| } | |
| } | |
| #endif /* LIBXML_OUTPUT_ENABLED */ | |
| /************************************************************************ | |
| * * | |
| * Validation of compiled content * | |
| * * | |
| ************************************************************************/ | |
| static int xmlRelaxNGValidateDefinition(xmlRelaxNGValidCtxtPtr ctxt, | |
| xmlRelaxNGDefinePtr define); | |
| /** | |
| * xmlRelaxNGValidateCompiledCallback: | |
| * @exec: the regular expression instance | |
| * @token: the token which matched | |
| * @transdata: callback data, the define for the subelement if available | |
| @ @inputdata: callback data, the Relax NG validation context | |
| * | |
| * Handle the callback and if needed validate the element children. | |
| */ | |
| static void | |
| xmlRelaxNGValidateCompiledCallback(xmlRegExecCtxtPtr exec ATTRIBUTE_UNUSED, | |
| const xmlChar * token, | |
| void *transdata, void *inputdata) | |
| { | |
| xmlRelaxNGValidCtxtPtr ctxt = (xmlRelaxNGValidCtxtPtr) inputdata; | |
| xmlRelaxNGDefinePtr define = (xmlRelaxNGDefinePtr) transdata; | |
| int ret; | |
| #ifdef DEBUG_COMPILE | |
| xmlGenericError(xmlGenericErrorContext, | |
| "Compiled callback for: '%s'\n", token); | |
| #endif | |
| if (ctxt == NULL) { | |
| fprintf(stderr, "callback on %s missing context\n", token); | |
| return; | |
| } | |
| if (define == NULL) { | |
| if (token[0] == '#') | |
| return; | |
| fprintf(stderr, "callback on %s missing define\n", token); | |
| if ((ctxt != NULL) && (ctxt->errNo == XML_RELAXNG_OK)) | |
| ctxt->errNo = XML_RELAXNG_ERR_INTERNAL; | |
| return; | |
| } | |
| if ((ctxt == NULL) || (define == NULL)) { | |
| fprintf(stderr, "callback on %s missing info\n", token); | |
| if ((ctxt != NULL) && (ctxt->errNo == XML_RELAXNG_OK)) | |
| ctxt->errNo = XML_RELAXNG_ERR_INTERNAL; | |
| return; | |
| } else if (define->type != XML_RELAXNG_ELEMENT) { | |
| fprintf(stderr, "callback on %s define is not element\n", token); | |
| if (ctxt->errNo == XML_RELAXNG_OK) | |
| ctxt->errNo = XML_RELAXNG_ERR_INTERNAL; | |
| return; | |
| } | |
| ret = xmlRelaxNGValidateDefinition(ctxt, define); | |
| if (ret != 0) | |
| ctxt->perr = ret; | |
| } | |
| /** | |
| * xmlRelaxNGValidateCompiledContent: | |
| * @ctxt: the RelaxNG validation context | |
| * @regexp: the regular expression as compiled | |
| * @content: list of children to test against the regexp | |
| * | |
| * Validate the content model of an element or start using the regexp | |
| * | |
| * Returns 0 in case of success, -1 in case of error. | |
| */ | |
| static int | |
| xmlRelaxNGValidateCompiledContent(xmlRelaxNGValidCtxtPtr ctxt, | |
| xmlRegexpPtr regexp, xmlNodePtr content) | |
| { | |
| xmlRegExecCtxtPtr exec; | |
| xmlNodePtr cur; | |
| int ret = 0; | |
| int oldperr; | |
| if ((ctxt == NULL) || (regexp == NULL)) | |
| return (-1); | |
| oldperr = ctxt->perr; | |
| exec = xmlRegNewExecCtxt(regexp, | |
| xmlRelaxNGValidateCompiledCallback, ctxt); | |
| ctxt->perr = 0; | |
| cur = content; | |
| while (cur != NULL) { | |
| ctxt->state->seq = cur; | |
| switch (cur->type) { | |
| case XML_TEXT_NODE: | |
| case XML_CDATA_SECTION_NODE: | |
| if (xmlIsBlankNode(cur)) | |
| break; | |
| ret = xmlRegExecPushString(exec, BAD_CAST "#text", ctxt); | |
| if (ret < 0) { | |
| VALID_ERR2(XML_RELAXNG_ERR_TEXTWRONG, | |
| cur->parent->name); | |
| } | |
| break; | |
| case XML_ELEMENT_NODE: | |
| if (cur->ns != NULL) { | |
| ret = xmlRegExecPushString2(exec, cur->name, | |
| cur->ns->href, ctxt); | |
| } else { | |
| ret = xmlRegExecPushString(exec, cur->name, ctxt); | |
| } | |
| if (ret < 0) { | |
| VALID_ERR2(XML_RELAXNG_ERR_ELEMWRONG, cur->name); | |
| } | |
| break; | |
| default: | |
| break; | |
| } | |
| if (ret < 0) | |
| break; | |
| /* | |
| * Switch to next element | |
| */ | |
| cur = cur->next; | |
| } | |
| ret = xmlRegExecPushString(exec, NULL, NULL); | |
| if (ret == 1) { | |
| ret = 0; | |
| ctxt->state->seq = NULL; | |
| } else if (ret == 0) { | |
| /* | |
| * TODO: get some of the names needed to exit the current state of exec | |
| */ | |
| VALID_ERR2(XML_RELAXNG_ERR_NOELEM, BAD_CAST ""); | |
| ret = -1; | |
| if ((ctxt->flags & FLAGS_IGNORABLE) == 0) | |
| xmlRelaxNGDumpValidError(ctxt); | |
| } else { | |
| ret = -1; | |
| } | |
| xmlRegFreeExecCtxt(exec); | |
| /* | |
| * There might be content model errors outside of the pure | |
| * regexp validation, e.g. for attribute values. | |
| */ | |
| if ((ret == 0) && (ctxt->perr != 0)) { | |
| ret = ctxt->perr; | |
| } | |
| ctxt->perr = oldperr; | |
| return (ret); | |
| } | |
| /************************************************************************ | |
| * * | |
| * Progressive validation of when possible * | |
| * * | |
| ************************************************************************/ | |
| static int xmlRelaxNGValidateAttributeList(xmlRelaxNGValidCtxtPtr ctxt, | |
| xmlRelaxNGDefinePtr defines); | |
| static int xmlRelaxNGValidateElementEnd(xmlRelaxNGValidCtxtPtr ctxt, | |
| int dolog); | |
| static void xmlRelaxNGLogBestError(xmlRelaxNGValidCtxtPtr ctxt); | |
| /** | |
| * xmlRelaxNGElemPush: | |
| * @ctxt: the validation context | |
| * @exec: the regexp runtime for the new content model | |
| * | |
| * Push a new regexp for the current node content model on the stack | |
| * | |
| * Returns 0 in case of success and -1 in case of error. | |
| */ | |
| static int | |
| xmlRelaxNGElemPush(xmlRelaxNGValidCtxtPtr ctxt, xmlRegExecCtxtPtr exec) | |
| { | |
| if (ctxt->elemTab == NULL) { | |
| ctxt->elemMax = 10; | |
| ctxt->elemTab = (xmlRegExecCtxtPtr *) xmlMalloc(ctxt->elemMax * | |
| sizeof | |
| (xmlRegExecCtxtPtr)); | |
| if (ctxt->elemTab == NULL) { | |
| xmlRngVErrMemory(ctxt, "validating\n"); | |
| return (-1); | |
| } | |
| } | |
| if (ctxt->elemNr >= ctxt->elemMax) { | |
| ctxt->elemMax *= 2; | |
| ctxt->elemTab = (xmlRegExecCtxtPtr *) xmlRealloc(ctxt->elemTab, | |
| ctxt->elemMax * | |
| sizeof | |
| (xmlRegExecCtxtPtr)); | |
| if (ctxt->elemTab == NULL) { | |
| xmlRngVErrMemory(ctxt, "validating\n"); | |
| return (-1); | |
| } | |
| } | |
| ctxt->elemTab[ctxt->elemNr++] = exec; | |
| ctxt->elem = exec; | |
| return (0); | |
| } | |
| /** | |
| * xmlRelaxNGElemPop: | |
| * @ctxt: the validation context | |
| * | |
| * Pop the regexp of the current node content model from the stack | |
| * | |
| * Returns the exec or NULL if empty | |
| */ | |
| static xmlRegExecCtxtPtr | |
| xmlRelaxNGElemPop(xmlRelaxNGValidCtxtPtr ctxt) | |
| { | |
| xmlRegExecCtxtPtr ret; | |
| if (ctxt->elemNr <= 0) | |
| return (NULL); | |
| ctxt->elemNr--; | |
| ret = ctxt->elemTab[ctxt->elemNr]; | |
| ctxt->elemTab[ctxt->elemNr] = NULL; | |
| if (ctxt->elemNr > 0) | |
| ctxt->elem = ctxt->elemTab[ctxt->elemNr - 1]; | |
| else | |
| ctxt->elem = NULL; | |
| return (ret); | |
| } | |
| /** | |
| * xmlRelaxNGValidateProgressiveCallback: | |
| * @exec: the regular expression instance | |
| * @token: the token which matched | |
| * @transdata: callback data, the define for the subelement if available | |
| @ @inputdata: callback data, the Relax NG validation context | |
| * | |
| * Handle the callback and if needed validate the element children. | |
| * some of the in/out informations are passed via the context in @inputdata. | |
| */ | |
| static void | |
| xmlRelaxNGValidateProgressiveCallback(xmlRegExecCtxtPtr exec | |
| ATTRIBUTE_UNUSED, | |
| const xmlChar * token, | |
| void *transdata, void *inputdata) | |
| { | |
| xmlRelaxNGValidCtxtPtr ctxt = (xmlRelaxNGValidCtxtPtr) inputdata; | |
| xmlRelaxNGDefinePtr define = (xmlRelaxNGDefinePtr) transdata; | |
| xmlRelaxNGValidStatePtr state, oldstate; | |
| xmlNodePtr node; | |
| int ret = 0, oldflags; | |
| #ifdef DEBUG_PROGRESSIVE | |
| xmlGenericError(xmlGenericErrorContext, | |
| "Progressive callback for: '%s'\n", token); | |
| #endif | |
| if (ctxt == NULL) { | |
| fprintf(stderr, "callback on %s missing context\n", token); | |
| return; | |
| } | |
| node = ctxt->pnode; | |
| ctxt->pstate = 1; | |
| if (define == NULL) { | |
| if (token[0] == '#') | |
| return; | |
| fprintf(stderr, "callback on %s missing define\n", token); | |
| if ((ctxt != NULL) && (ctxt->errNo == XML_RELAXNG_OK)) | |
| ctxt->errNo = XML_RELAXNG_ERR_INTERNAL; | |
| ctxt->pstate = -1; | |
| return; | |
| } | |
| if ((ctxt == NULL) || (define == NULL)) { | |
| fprintf(stderr, "callback on %s missing info\n", token); | |
| if ((ctxt != NULL) && (ctxt->errNo == XML_RELAXNG_OK)) | |
| ctxt->errNo = XML_RELAXNG_ERR_INTERNAL; | |
| ctxt->pstate = -1; | |
| return; | |
| } else if (define->type != XML_RELAXNG_ELEMENT) { | |
| fprintf(stderr, "callback on %s define is not element\n", token); | |
| if (ctxt->errNo == XML_RELAXNG_OK) | |
| ctxt->errNo = XML_RELAXNG_ERR_INTERNAL; | |
| ctxt->pstate = -1; | |
| return; | |
| } | |
| if (node->type != XML_ELEMENT_NODE) { | |
| VALID_ERR(XML_RELAXNG_ERR_NOTELEM); | |
| if ((ctxt->flags & FLAGS_IGNORABLE) == 0) | |
| xmlRelaxNGDumpValidError(ctxt); | |
| ctxt->pstate = -1; | |
| return; | |
| } | |
| if (define->contModel == NULL) { | |
| /* | |
| * this node cannot be validated in a streamable fashion | |
| */ | |
| #ifdef DEBUG_PROGRESSIVE | |
| xmlGenericError(xmlGenericErrorContext, | |
| "Element '%s' validation is not streamable\n", | |
| token); | |
| #endif | |
| ctxt->pstate = 0; | |
| ctxt->pdef = define; | |
| return; | |
| } | |
| exec = xmlRegNewExecCtxt(define->contModel, | |
| xmlRelaxNGValidateProgressiveCallback, ctxt); | |
| if (exec == NULL) { | |
| ctxt->pstate = -1; | |
| return; | |
| } | |
| xmlRelaxNGElemPush(ctxt, exec); | |
| /* | |
| * Validate the attributes part of the content. | |
| */ | |
| state = xmlRelaxNGNewValidState(ctxt, node); | |
| if (state == NULL) { | |
| ctxt->pstate = -1; | |
| return; | |
| } | |
| oldstate = ctxt->state; | |
| ctxt->state = state; | |
| if (define->attrs != NULL) { | |
| ret = xmlRelaxNGValidateAttributeList(ctxt, define->attrs); | |
| if (ret != 0) { | |
| ctxt->pstate = -1; | |
| VALID_ERR2(XML_RELAXNG_ERR_ATTRVALID, node->name); | |
| } | |
| } | |
| if (ctxt->state != NULL) { | |
| ctxt->state->seq = NULL; | |
| ret = xmlRelaxNGValidateElementEnd(ctxt, 1); | |
| if (ret != 0) { | |
| ctxt->pstate = -1; | |
| } | |
| xmlRelaxNGFreeValidState(ctxt, ctxt->state); | |
| } else if (ctxt->states != NULL) { | |
| int tmp = -1, i; | |
| oldflags = ctxt->flags; | |
| for (i = 0; i < ctxt->states->nbState; i++) { | |
| state = ctxt->states->tabState[i]; | |
| ctxt->state = state; | |
| ctxt->state->seq = NULL; | |
| if (xmlRelaxNGValidateElementEnd(ctxt, 0) == 0) { | |
| tmp = 0; | |
| break; | |
| } | |
| } | |
| if (tmp != 0) { | |
| /* | |
| * validation error, log the message for the "best" one | |
| */ | |
| ctxt->flags |= FLAGS_IGNORABLE; | |
| xmlRelaxNGLogBestError(ctxt); | |
| } | |
| for (i = 0; i < ctxt->states->nbState; i++) { | |
| xmlRelaxNGFreeValidState(ctxt, ctxt->states->tabState[i]); | |
| } | |
| xmlRelaxNGFreeStates(ctxt, ctxt->states); | |
| ctxt->states = NULL; | |
| if ((ret == 0) && (tmp == -1)) | |
| ctxt->pstate = -1; | |
| ctxt->flags = oldflags; | |
| } | |
| if (ctxt->pstate == -1) { | |
| if ((ctxt->flags & FLAGS_IGNORABLE) == 0) { | |
| xmlRelaxNGDumpValidError(ctxt); | |
| } | |
| } | |
| ctxt->state = oldstate; | |
| } | |
| /** | |
| * xmlRelaxNGValidatePushElement: | |
| * @ctxt: the validation context | |
| * @doc: a document instance | |
| * @elem: an element instance | |
| * | |
| * Push a new element start on the RelaxNG validation stack. | |
| * | |
| * returns 1 if no validation problem was found or 0 if validating the | |
| * element requires a full node, and -1 in case of error. | |
| */ | |
| int | |
| xmlRelaxNGValidatePushElement(xmlRelaxNGValidCtxtPtr ctxt, | |
| xmlDocPtr doc ATTRIBUTE_UNUSED, | |
| xmlNodePtr elem) | |
| { | |
| int ret = 1; | |
| if ((ctxt == NULL) || (elem == NULL)) | |
| return (-1); | |
| #ifdef DEBUG_PROGRESSIVE | |
| xmlGenericError(xmlGenericErrorContext, "PushElem %s\n", elem->name); | |
| #endif | |
| if (ctxt->elem == 0) { | |
| xmlRelaxNGPtr schema; | |
| xmlRelaxNGGrammarPtr grammar; | |
| xmlRegExecCtxtPtr exec; | |
| xmlRelaxNGDefinePtr define; | |
| schema = ctxt->schema; | |
| if (schema == NULL) { | |
| VALID_ERR(XML_RELAXNG_ERR_NOGRAMMAR); | |
| return (-1); | |
| } | |
| grammar = schema->topgrammar; | |
| if ((grammar == NULL) || (grammar->start == NULL)) { | |
| VALID_ERR(XML_RELAXNG_ERR_NOGRAMMAR); | |
| return (-1); | |
| } | |
| define = grammar->start; | |
| if (define->contModel == NULL) { | |
| ctxt->pdef = define; | |
| return (0); | |
| } | |
| exec = xmlRegNewExecCtxt(define->contModel, | |
| xmlRelaxNGValidateProgressiveCallback, | |
| ctxt); | |
| if (exec == NULL) { | |
| return (-1); | |
| } | |
| xmlRelaxNGElemPush(ctxt, exec); | |
| } | |
| ctxt->pnode = elem; | |
| ctxt->pstate = 0; | |
| if (elem->ns != NULL) { | |
| ret = | |
| xmlRegExecPushString2(ctxt->elem, elem->name, elem->ns->href, | |
| ctxt); | |
| } else { | |
| ret = xmlRegExecPushString(ctxt->elem, elem->name, ctxt); | |
| } | |
| if (ret < 0) { | |
| VALID_ERR2(XML_RELAXNG_ERR_ELEMWRONG, elem->name); | |
| } else { | |
| if (ctxt->pstate == 0) | |
| ret = 0; | |
| else if (ctxt->pstate < 0) | |
| ret = -1; | |
| else | |
| ret = 1; | |
| } | |
| #ifdef DEBUG_PROGRESSIVE | |
| if (ret < 0) | |
| xmlGenericError(xmlGenericErrorContext, "PushElem %s failed\n", | |
| elem->name); | |
| #endif | |
| return (ret); | |
| } | |
| /** | |
| * xmlRelaxNGValidatePushCData: | |
| * @ctxt: the RelaxNG validation context | |
| * @data: some character data read | |
| * @len: the length of the data | |
| * | |
| * check the CData parsed for validation in the current stack | |
| * | |
| * returns 1 if no validation problem was found or -1 otherwise | |
| */ | |
| int | |
| xmlRelaxNGValidatePushCData(xmlRelaxNGValidCtxtPtr ctxt, | |
| const xmlChar * data, int len ATTRIBUTE_UNUSED) | |
| { | |
| int ret = 1; | |
| if ((ctxt == NULL) || (ctxt->elem == NULL) || (data == NULL)) | |
| return (-1); | |
| #ifdef DEBUG_PROGRESSIVE | |
| xmlGenericError(xmlGenericErrorContext, "CDATA %s %d\n", data, len); | |
| #endif | |
| while (*data != 0) { | |
| if (!IS_BLANK_CH(*data)) | |
| break; | |
| data++; | |
| } | |
| if (*data == 0) | |
| return (1); | |
| ret = xmlRegExecPushString(ctxt->elem, BAD_CAST "#text", ctxt); | |
| if (ret < 0) { | |
| VALID_ERR2(XML_RELAXNG_ERR_TEXTWRONG, BAD_CAST " TODO "); | |
| #ifdef DEBUG_PROGRESSIVE | |
| xmlGenericError(xmlGenericErrorContext, "CDATA failed\n"); | |
| #endif | |
| return (-1); | |
| } | |
| return (1); | |
| } | |
| /** | |
| * xmlRelaxNGValidatePopElement: | |
| * @ctxt: the RelaxNG validation context | |
| * @doc: a document instance | |
| * @elem: an element instance | |
| * | |
| * Pop the element end from the RelaxNG validation stack. | |
| * | |
| * returns 1 if no validation problem was found or 0 otherwise | |
| */ | |
| int | |
| xmlRelaxNGValidatePopElement(xmlRelaxNGValidCtxtPtr ctxt, | |
| xmlDocPtr doc ATTRIBUTE_UNUSED, | |
| xmlNodePtr elem) | |
| { | |
| int ret; | |
| xmlRegExecCtxtPtr exec; | |
| if ((ctxt == NULL) || (ctxt->elem == NULL) || (elem == NULL)) | |
| return (-1); | |
| #ifdef DEBUG_PROGRESSIVE | |
| xmlGenericError(xmlGenericErrorContext, "PopElem %s\n", elem->name); | |
| #endif | |
| /* | |
| * verify that we reached a terminal state of the content model. | |
| */ | |
| exec = xmlRelaxNGElemPop(ctxt); | |
| ret = xmlRegExecPushString(exec, NULL, NULL); | |
| if (ret == 0) { | |
| /* | |
| * TODO: get some of the names needed to exit the current state of exec | |
| */ | |
| VALID_ERR2(XML_RELAXNG_ERR_NOELEM, BAD_CAST ""); | |
| ret = -1; | |
| } else if (ret < 0) { | |
| ret = -1; | |
| } else { | |
| ret = 1; | |
| } | |
| xmlRegFreeExecCtxt(exec); | |
| #ifdef DEBUG_PROGRESSIVE | |
| if (ret < 0) | |
| xmlGenericError(xmlGenericErrorContext, "PopElem %s failed\n", | |
| elem->name); | |
| #endif | |
| return (ret); | |
| } | |
| /** | |
| * xmlRelaxNGValidateFullElement: | |
| * @ctxt: the validation context | |
| * @doc: a document instance | |
| * @elem: an element instance | |
| * | |
| * Validate a full subtree when xmlRelaxNGValidatePushElement() returned | |
| * 0 and the content of the node has been expanded. | |
| * | |
| * returns 1 if no validation problem was found or -1 in case of error. | |
| */ | |
| int | |
| xmlRelaxNGValidateFullElement(xmlRelaxNGValidCtxtPtr ctxt, | |
| xmlDocPtr doc ATTRIBUTE_UNUSED, | |
| xmlNodePtr elem) | |
| { | |
| int ret; | |
| xmlRelaxNGValidStatePtr state; | |
| if ((ctxt == NULL) || (ctxt->pdef == NULL) || (elem == NULL)) | |
| return (-1); | |
| #ifdef DEBUG_PROGRESSIVE | |
| xmlGenericError(xmlGenericErrorContext, "FullElem %s\n", elem->name); | |
| #endif | |
| state = xmlRelaxNGNewValidState(ctxt, elem->parent); | |
| if (state == NULL) { | |
| return (-1); | |
| } | |
| state->seq = elem; | |
| ctxt->state = state; | |
| ctxt->errNo = XML_RELAXNG_OK; | |
| ret = xmlRelaxNGValidateDefinition(ctxt, ctxt->pdef); | |
| if ((ret != 0) || (ctxt->errNo != XML_RELAXNG_OK)) | |
| ret = -1; | |
| else | |
| ret = 1; | |
| xmlRelaxNGFreeValidState(ctxt, ctxt->state); | |
| ctxt->state = NULL; | |
| #ifdef DEBUG_PROGRESSIVE | |
| if (ret < 0) | |
| xmlGenericError(xmlGenericErrorContext, "FullElem %s failed\n", | |
| elem->name); | |
| #endif | |
| return (ret); | |
| } | |
| /************************************************************************ | |
| * * | |
| * Generic interpreted validation implementation * | |
| * * | |
| ************************************************************************/ | |
| static int xmlRelaxNGValidateValue(xmlRelaxNGValidCtxtPtr ctxt, | |
| xmlRelaxNGDefinePtr define); | |
| /** | |
| * xmlRelaxNGSkipIgnored: | |
| * @ctxt: a schema validation context | |
| * @node: the top node. | |
| * | |
| * Skip ignorable nodes in that context | |
| * | |
| * Returns the new sibling or NULL in case of error. | |
| */ | |
| static xmlNodePtr | |
| xmlRelaxNGSkipIgnored(xmlRelaxNGValidCtxtPtr ctxt ATTRIBUTE_UNUSED, | |
| xmlNodePtr node) | |
| { | |
| /* | |
| * TODO complete and handle entities | |
| */ | |
| while ((node != NULL) && | |
| ((node->type == XML_COMMENT_NODE) || | |
| (node->type == XML_PI_NODE) || | |
| (node->type == XML_XINCLUDE_START) || | |
| (node->type == XML_XINCLUDE_END) || | |
| (((node->type == XML_TEXT_NODE) || | |
| (node->type == XML_CDATA_SECTION_NODE)) && | |
| ((ctxt->flags & FLAGS_MIXED_CONTENT) || | |
| (IS_BLANK_NODE(node)))))) { | |
| node = node->next; | |
| } | |
| return (node); | |
| } | |
| /** | |
| * xmlRelaxNGNormalize: | |
| * @ctxt: a schema validation context | |
| * @str: the string to normalize | |
| * | |
| * Implements the normalizeWhiteSpace( s ) function from | |
| * section 6.2.9 of the spec | |
| * | |
| * Returns the new string or NULL in case of error. | |
| */ | |
| static xmlChar * | |
| xmlRelaxNGNormalize(xmlRelaxNGValidCtxtPtr ctxt, const xmlChar * str) | |
| { | |
| xmlChar *ret, *p; | |
| const xmlChar *tmp; | |
| int len; | |
| if (str == NULL) | |
| return (NULL); | |
| tmp = str; | |
| while (*tmp != 0) | |
| tmp++; | |
| len = tmp - str; | |
| ret = (xmlChar *) xmlMallocAtomic((len + 1) * sizeof(xmlChar)); | |
| if (ret == NULL) { | |
| xmlRngVErrMemory(ctxt, "validating\n"); | |
| return (NULL); | |
| } | |
| p = ret; | |
| while (IS_BLANK_CH(*str)) | |
| str++; | |
| while (*str != 0) { | |
| if (IS_BLANK_CH(*str)) { | |
| while (IS_BLANK_CH(*str)) | |
| str++; | |
| if (*str == 0) | |
| break; | |
| *p++ = ' '; | |
| } else | |
| *p++ = *str++; | |
| } | |
| *p = 0; | |
| return (ret); | |
| } | |
| /** | |
| * xmlRelaxNGValidateDatatype: | |
| * @ctxt: a Relax-NG validation context | |
| * @value: the string value | |
| * @type: the datatype definition | |
| * @node: the node | |
| * | |
| * Validate the given value against the dataype | |
| * | |
| * Returns 0 if the validation succeeded or an error code. | |
| */ | |
| static int | |
| xmlRelaxNGValidateDatatype(xmlRelaxNGValidCtxtPtr ctxt, | |
| const xmlChar * value, | |
| xmlRelaxNGDefinePtr define, xmlNodePtr node) | |
| { | |
| int ret, tmp; | |
| xmlRelaxNGTypeLibraryPtr lib; | |
| void *result = NULL; | |
| xmlRelaxNGDefinePtr cur; | |
| if ((define == NULL) || (define->data == NULL)) { | |
| return (-1); | |
| } | |
| lib = (xmlRelaxNGTypeLibraryPtr) define->data; | |
| if (lib->check != NULL) { | |
| if ((define->attrs != NULL) && | |
| (define->attrs->type == XML_RELAXNG_PARAM)) { | |
| ret = | |
| lib->check(lib->data, define->name, value, &result, node); | |
| } else { | |
| ret = lib->check(lib->data, define->name, value, NULL, node); | |
| } | |
| } else | |
| ret = -1; | |
| if (ret < 0) { | |
| VALID_ERR2(XML_RELAXNG_ERR_TYPE, define->name); | |
| if ((result != NULL) && (lib != NULL) && (lib->freef != NULL)) | |
| lib->freef(lib->data, result); | |
| return (-1); | |
| } else if (ret == 1) { | |
| ret = 0; | |
| } else if (ret == 2) { | |
| VALID_ERR2P(XML_RELAXNG_ERR_DUPID, value); | |
| } else { | |
| VALID_ERR3P(XML_RELAXNG_ERR_TYPEVAL, define->name, value); | |
| ret = -1; | |
| } | |
| cur = define->attrs; | |
| while ((ret == 0) && (cur != NULL) && (cur->type == XML_RELAXNG_PARAM)) { | |
| if (lib->facet != NULL) { | |
| tmp = lib->facet(lib->data, define->name, cur->name, | |
| cur->value, value, result); | |
| if (tmp != 0) | |
| ret = -1; | |
| } | |
| cur = cur->next; | |
| } | |
| if ((ret == 0) && (define->content != NULL)) { | |
| const xmlChar *oldvalue, *oldendvalue; | |
| oldvalue = ctxt->state->value; | |
| oldendvalue = ctxt->state->endvalue; | |
| ctxt->state->value = (xmlChar *) value; | |
| ctxt->state->endvalue = NULL; | |
| ret = xmlRelaxNGValidateValue(ctxt, define->content); | |
| ctxt->state->value = (xmlChar *) oldvalue; | |
| ctxt->state->endvalue = (xmlChar *) oldendvalue; | |
| } | |
| if ((result != NULL) && (lib != NULL) && (lib->freef != NULL)) | |
| lib->freef(lib->data, result); | |
| return (ret); | |
| } | |
| /** | |
| * xmlRelaxNGNextValue: | |
| * @ctxt: a Relax-NG validation context | |
| * | |
| * Skip to the next value when validating within a list | |
| * | |
| * Returns 0 if the operation succeeded or an error code. | |
| */ | |
| static int | |
| xmlRelaxNGNextValue(xmlRelaxNGValidCtxtPtr ctxt) | |
| { | |
| xmlChar *cur; | |
| cur = ctxt->state->value; | |
| if ((cur == NULL) || (ctxt->state->endvalue == NULL)) { | |
| ctxt->state->value = NULL; | |
| ctxt->state->endvalue = NULL; | |
| return (0); | |
| } | |
| while (*cur != 0) | |
| cur++; | |
| while ((cur != ctxt->state->endvalue) && (*cur == 0)) | |
| cur++; | |
| if (cur == ctxt->state->endvalue) | |
| ctxt->state->value = NULL; | |
| else | |
| ctxt->state->value = cur; | |
| return (0); | |
| } | |
| /** | |
| * xmlRelaxNGValidateValueList: | |
| * @ctxt: a Relax-NG validation context | |
| * @defines: the list of definitions to verify | |
| * | |
| * Validate the given set of definitions for the current value | |
| * | |
| * Returns 0 if the validation succeeded or an error code. | |
| */ | |
| static int | |
| xmlRelaxNGValidateValueList(xmlRelaxNGValidCtxtPtr ctxt, | |
| xmlRelaxNGDefinePtr defines) | |
| { | |
| int ret = 0; | |
| while (defines != NULL) { | |
| ret = xmlRelaxNGValidateValue(ctxt, defines); | |
| if (ret != 0) | |
| break; | |
| defines = defines->next; | |
| } | |
| return (ret); | |
| } | |
| /** | |
| * xmlRelaxNGValidateValue: | |
| * @ctxt: a Relax-NG validation context | |
| * @define: the definition to verify | |
| * | |
| * Validate the given definition for the current value | |
| * | |
| * Returns 0 if the validation succeeded or an error code. | |
| */ | |
| static int | |
| xmlRelaxNGValidateValue(xmlRelaxNGValidCtxtPtr ctxt, | |
| xmlRelaxNGDefinePtr define) | |
| { | |
| int ret = 0, oldflags; | |
| xmlChar *value; | |
| value = ctxt->state->value; | |
| switch (define->type) { | |
| case XML_RELAXNG_EMPTY:{ | |
| if ((value != NULL) && (value[0] != 0)) { | |
| int idx = 0; | |
| while (IS_BLANK_CH(value[idx])) | |
| idx++; | |
| if (value[idx] != 0) | |
| ret = -1; | |
| } | |
| break; | |
| } | |
| case XML_RELAXNG_TEXT: | |
| break; | |
| case XML_RELAXNG_VALUE:{ | |
| if (!xmlStrEqual(value, define->value)) { | |
| if (define->name != NULL) { | |
| xmlRelaxNGTypeLibraryPtr lib; | |
| lib = (xmlRelaxNGTypeLibraryPtr) define->data; | |
| if ((lib != NULL) && (lib->comp != NULL)) { | |
| ret = lib->comp(lib->data, define->name, | |
| define->value, define->node, | |
| (void *) define->attrs, | |
| value, ctxt->state->node); | |
| } else | |
| ret = -1; | |
| if (ret < 0) { | |
| VALID_ERR2(XML_RELAXNG_ERR_TYPECMP, | |
| define->name); | |
| return (-1); | |
| } else if (ret == 1) { | |
| ret = 0; | |
| } else { | |
| ret = -1; | |
| } | |
| } else { | |
| xmlChar *nval, *nvalue; | |
| /* | |
| * TODO: trivial optimizations are possible by | |
| * computing at compile-time | |
| */ | |
| nval = xmlRelaxNGNormalize(ctxt, define->value); | |
| nvalue = xmlRelaxNGNormalize(ctxt, value); | |
| if ((nval == NULL) || (nvalue == NULL) || | |
| (!xmlStrEqual(nval, nvalue))) | |
| ret = -1; | |
| if (nval != NULL) | |
| xmlFree(nval); | |
| if (nvalue != NULL) | |
| xmlFree(nvalue); | |
| } | |
| } | |
| if (ret == 0) | |
| xmlRelaxNGNextValue(ctxt); | |
| break; | |
| } | |
| case XML_RELAXNG_DATATYPE:{ | |
| ret = xmlRelaxNGValidateDatatype(ctxt, value, define, | |
| ctxt->state->seq); | |
| if (ret == 0) | |
| xmlRelaxNGNextValue(ctxt); | |
| break; | |
| } | |
| case XML_RELAXNG_CHOICE:{ | |
| xmlRelaxNGDefinePtr list = define->content; | |
| xmlChar *oldvalue; | |
| oldflags = ctxt->flags; | |
| ctxt->flags |= FLAGS_IGNORABLE; | |
| oldvalue = ctxt->state->value; | |
| while (list != NULL) { | |
| ret = xmlRelaxNGValidateValue(ctxt, list); | |
| if (ret == 0) { | |
| break; | |
| } | |
| ctxt->state->value = oldvalue; | |
| list = list->next; | |
| } | |
| ctxt->flags = oldflags; | |
| if (ret != 0) { | |
| if ((ctxt->flags & FLAGS_IGNORABLE) == 0) | |
| xmlRelaxNGDumpValidError(ctxt); | |
| } else { | |
| if (ctxt->errNr > 0) | |
| xmlRelaxNGPopErrors(ctxt, 0); | |
| } | |
| break; | |
| } | |
| case XML_RELAXNG_LIST:{ | |
| xmlRelaxNGDefinePtr list = define->content; | |
| xmlChar *oldvalue, *oldend, *val, *cur; | |
| #ifdef DEBUG_LIST | |
| int nb_values = 0; | |
| #endif | |
| oldvalue = ctxt->state->value; | |
| oldend = ctxt->state->endvalue; | |
| val = xmlStrdup(oldvalue); | |
| if (val == NULL) { | |
| val = xmlStrdup(BAD_CAST ""); | |
| } | |
| if (val == NULL) { | |
| VALID_ERR(XML_RELAXNG_ERR_NOSTATE); | |
| return (-1); | |
| } | |
| cur = val; | |
| while (*cur != 0) { | |
| if (IS_BLANK_CH(*cur)) { | |
| *cur = 0; | |
| cur++; | |
| #ifdef DEBUG_LIST | |
| nb_values++; | |
| #endif | |
| while (IS_BLANK_CH(*cur)) | |
| *cur++ = 0; | |
| } else | |
| cur++; | |
| } | |
| #ifdef DEBUG_LIST | |
| xmlGenericError(xmlGenericErrorContext, | |
| "list value: '%s' found %d items\n", | |
| oldvalue, nb_values); | |
| nb_values = 0; | |
| #endif | |
| ctxt->state->endvalue = cur; | |
| cur = val; | |
| while ((*cur == 0) && (cur != ctxt->state->endvalue)) | |
| cur++; | |
| ctxt->state->value = cur; | |
| while (list != NULL) { | |
| if (ctxt->state->value == ctxt->state->endvalue) | |
| ctxt->state->value = NULL; | |
| ret = xmlRelaxNGValidateValue(ctxt, list); | |
| if (ret != 0) { | |
| #ifdef DEBUG_LIST | |
| xmlGenericError(xmlGenericErrorContext, | |
| "Failed to validate value: '%s' with %d rule\n", | |
| ctxt->state->value, nb_values); | |
| #endif | |
| break; | |
| } | |
| #ifdef DEBUG_LIST | |
| nb_values++; | |
| #endif | |
| list = list->next; | |
| } | |
| if ((ret == 0) && (ctxt->state->value != NULL) && | |
| (ctxt->state->value != ctxt->state->endvalue)) { | |
| VALID_ERR2(XML_RELAXNG_ERR_LISTEXTRA, | |
| ctxt->state->value); | |
| ret = -1; | |
| } | |
| xmlFree(val); | |
| ctxt->state->value = oldvalue; | |
| ctxt->state->endvalue = oldend; | |
| break; | |
| } | |
| case XML_RELAXNG_ONEORMORE: | |
| ret = xmlRelaxNGValidateValueList(ctxt, define->content); | |
| if (ret != 0) { | |
| break; | |
| } | |
| /* no break on purpose */ | |
| case XML_RELAXNG_ZEROORMORE:{ | |
| xmlChar *cur, *temp; | |
| if ((ctxt->state->value == NULL) || | |
| (*ctxt->state->value == 0)) { | |
| ret = 0; | |
| break; | |
| } | |
| oldflags = ctxt->flags; | |
| ctxt->flags |= FLAGS_IGNORABLE; | |
| cur = ctxt->state->value; | |
| temp = NULL; | |
| while ((cur != NULL) && (cur != ctxt->state->endvalue) && | |
| (temp != cur)) { | |
| temp = cur; | |
| ret = | |
| xmlRelaxNGValidateValueList(ctxt, define->content); | |
| if (ret != 0) { | |
| ctxt->state->value = temp; | |
| ret = 0; | |
| break; | |
| } | |
| cur = ctxt->state->value; | |
| } | |
| ctxt->flags = oldflags; | |
| if (ctxt->errNr > 0) | |
| xmlRelaxNGPopErrors(ctxt, 0); | |
| break; | |
| } | |
| case XML_RELAXNG_OPTIONAL:{ | |
| xmlChar *temp; | |
| if ((ctxt->state->value == NULL) || | |
| (*ctxt->state->value == 0)) { | |
| ret = 0; | |
| break; | |
| } | |
| oldflags = ctxt->flags; | |
| ctxt->flags |= FLAGS_IGNORABLE; | |
| temp = ctxt->state->value; | |
| ret = xmlRelaxNGValidateValue(ctxt, define->content); | |
| ctxt->flags = oldflags; | |
| if (ret != 0) { | |
| ctxt->state->value = temp; | |
| if (ctxt->errNr > 0) | |
| xmlRelaxNGPopErrors(ctxt, 0); | |
| ret = 0; | |
| break; | |
| } | |
| if (ctxt->errNr > 0) | |
| xmlRelaxNGPopErrors(ctxt, 0); | |
| break; | |
| } | |
| case XML_RELAXNG_EXCEPT:{ | |
| xmlRelaxNGDefinePtr list; | |
| list = define->content; | |
| while (list != NULL) { | |
| ret = xmlRelaxNGValidateValue(ctxt, list); | |
| if (ret == 0) { | |
| ret = -1; | |
| break; | |
| } else | |
| ret = 0; | |
| list = list->next; | |
| } | |
| break; | |
| } | |
| case XML_RELAXNG_DEF: | |
| case XML_RELAXNG_GROUP:{ | |
| xmlRelaxNGDefinePtr list; | |
| list = define->content; | |
| while (list != NULL) { | |
| ret = xmlRelaxNGValidateValue(ctxt, list); | |
| if (ret != 0) { | |
| ret = -1; | |
| break; | |
| } else | |
| ret = 0; | |
| list = list->next; | |
| } | |
| break; | |
| } | |
| case XML_RELAXNG_REF: | |
| case XML_RELAXNG_PARENTREF: | |
| if (define->content == NULL) { | |
| VALID_ERR(XML_RELAXNG_ERR_NODEFINE); | |
| ret = -1; | |
| } else { | |
| ret = xmlRelaxNGValidateValue(ctxt, define->content); | |
| } | |
| break; | |
| default: | |
| TODO ret = -1; | |
| } | |
| return (ret); | |
| } | |
| /** | |
| * xmlRelaxNGValidateValueContent: | |
| * @ctxt: a Relax-NG validation context | |
| * @defines: the list of definitions to verify | |
| * | |
| * Validate the given definitions for the current value | |
| * | |
| * Returns 0 if the validation succeeded or an error code. | |
| */ | |
| static int | |
| xmlRelaxNGValidateValueContent(xmlRelaxNGValidCtxtPtr ctxt, | |
| xmlRelaxNGDefinePtr defines) | |
| { | |
| int ret = 0; | |
| while (defines != NULL) { | |
| ret = xmlRelaxNGValidateValue(ctxt, defines); | |
| if (ret != 0) | |
| break; | |
| defines = defines->next; | |
| } | |
| return (ret); | |
| } | |
| /** | |
| * xmlRelaxNGAttributeMatch: | |
| * @ctxt: a Relax-NG validation context | |
| * @define: the definition to check | |
| * @prop: the attribute | |
| * | |
| * Check if the attribute matches the definition nameClass | |
| * | |
| * Returns 1 if the attribute matches, 0 if no, or -1 in case of error | |
| */ | |
| static int | |
| xmlRelaxNGAttributeMatch(xmlRelaxNGValidCtxtPtr ctxt, | |
| xmlRelaxNGDefinePtr define, xmlAttrPtr prop) | |
| { | |
| int ret; | |
| if (define->name != NULL) { | |
| if (!xmlStrEqual(define->name, prop->name)) | |
| return (0); | |
| } | |
| if (define->ns != NULL) { | |
| if (define->ns[0] == 0) { | |
| if (prop->ns != NULL) | |
| return (0); | |
| } else { | |
| if ((prop->ns == NULL) || | |
| (!xmlStrEqual(define->ns, prop->ns->href))) | |
| return (0); | |
| } | |
| } | |
| if (define->nameClass == NULL) | |
| return (1); | |
| define = define->nameClass; | |
| if (define->type == XML_RELAXNG_EXCEPT) { | |
| xmlRelaxNGDefinePtr list; | |
| list = define->content; | |
| while (list != NULL) { | |
| ret = xmlRelaxNGAttributeMatch(ctxt, list, prop); | |
| if (ret == 1) | |
| return (0); | |
| if (ret < 0) | |
| return (ret); | |
| list = list->next; | |
| } | |
| } else if (define->type == XML_RELAXNG_CHOICE) { | |
| xmlRelaxNGDefinePtr list; | |
| list = define->nameClass; | |
| while (list != NULL) { | |
| ret = xmlRelaxNGAttributeMatch(ctxt, list, prop); | |
| if (ret == 1) | |
| return (1); | |
| if (ret < 0) | |
| return (ret); | |
| list = list->next; | |
| } | |
| return (0); | |
| } else { | |
| TODO} | |
| return (1); | |
| } | |
| /** | |
| * xmlRelaxNGValidateAttribute: | |
| * @ctxt: a Relax-NG validation context | |
| * @define: the definition to verify | |
| * | |
| * Validate the given attribute definition for that node | |
| * | |
| * Returns 0 if the validation succeeded or an error code. | |
| */ | |
| static int | |
| xmlRelaxNGValidateAttribute(xmlRelaxNGValidCtxtPtr ctxt, | |
| xmlRelaxNGDefinePtr define) | |
| { | |
| int ret = 0, i; | |
| xmlChar *value, *oldvalue; | |
| xmlAttrPtr prop = NULL, tmp; | |
| xmlNodePtr oldseq; | |
| if (ctxt->state->nbAttrLeft <= 0) | |
| return (-1); | |
| if (define->name != NULL) { | |
| for (i = 0; i < ctxt->state->nbAttrs; i++) { | |
| tmp = ctxt->state->attrs[i]; | |
| if ((tmp != NULL) && (xmlStrEqual(define->name, tmp->name))) { | |
| if ((((define->ns == NULL) || (define->ns[0] == 0)) && | |
| (tmp->ns == NULL)) || | |
| ((tmp->ns != NULL) && | |
| (xmlStrEqual(define->ns, tmp->ns->href)))) { | |
| prop = tmp; | |
| break; | |
| } | |
| } | |
| } | |
| if (prop != NULL) { | |
| value = xmlNodeListGetString(prop->doc, prop->children, 1); | |
| oldvalue = ctxt->state->value; | |
| oldseq = ctxt->state->seq; | |
| ctxt->state->seq = (xmlNodePtr) prop; | |
| ctxt->state->value = value; | |
| ctxt->state->endvalue = NULL; | |
| ret = xmlRelaxNGValidateValueContent(ctxt, define->content); | |
| if (ctxt->state->value != NULL) | |
| value = ctxt->state->value; | |
| if (value != NULL) | |
| xmlFree(value); | |
| ctxt->state->value = oldvalue; | |
| ctxt->state->seq = oldseq; | |
| if (ret == 0) { | |
| /* | |
| * flag the attribute as processed | |
| */ | |
| ctxt->state->attrs[i] = NULL; | |
| ctxt->state->nbAttrLeft--; | |
| } | |
| } else { | |
| ret = -1; | |
| } | |
| #ifdef DEBUG | |
| xmlGenericError(xmlGenericErrorContext, | |
| "xmlRelaxNGValidateAttribute(%s): %d\n", | |
| define->name, ret); | |
| #endif | |
| } else { | |
| for (i = 0; i < ctxt->state->nbAttrs; i++) { | |
| tmp = ctxt->state->attrs[i]; | |
| if ((tmp != NULL) && | |
| (xmlRelaxNGAttributeMatch(ctxt, define, tmp) == 1)) { | |
| prop = tmp; | |
| break; | |
| } | |
| } | |
| if (prop != NULL) { | |
| value = xmlNodeListGetString(prop->doc, prop->children, 1); | |
| oldvalue = ctxt->state->value; | |
| oldseq = ctxt->state->seq; | |
| ctxt->state->seq = (xmlNodePtr) prop; | |
| ctxt->state->value = value; | |
| ret = xmlRelaxNGValidateValueContent(ctxt, define->content); | |
| if (ctxt->state->value != NULL) | |
| value = ctxt->state->value; | |
| if (value != NULL) | |
| xmlFree(value); | |
| ctxt->state->value = oldvalue; | |
| ctxt->state->seq = oldseq; | |
| if (ret == 0) { | |
| /* | |
| * flag the attribute as processed | |
| */ | |
| ctxt->state->attrs[i] = NULL; | |
| ctxt->state->nbAttrLeft--; | |
| } | |
| } else { | |
| ret = -1; | |
| } | |
| #ifdef DEBUG | |
| if (define->ns != NULL) { | |
| xmlGenericError(xmlGenericErrorContext, | |
| "xmlRelaxNGValidateAttribute(nsName ns = %s): %d\n", | |
| define->ns, ret); | |
| } else { | |
| xmlGenericError(xmlGenericErrorContext, | |
| "xmlRelaxNGValidateAttribute(anyName): %d\n", | |
| ret); | |
| } | |
| #endif | |
| } | |
| return (ret); | |
| } | |
| /** | |
| * xmlRelaxNGValidateAttributeList: | |
| * @ctxt: a Relax-NG validation context | |
| * @define: the list of definition to verify | |
| * | |
| * Validate the given node against the list of attribute definitions | |
| * | |
| * Returns 0 if the validation succeeded or an error code. | |
| */ | |
| static int | |
| xmlRelaxNGValidateAttributeList(xmlRelaxNGValidCtxtPtr ctxt, | |
| xmlRelaxNGDefinePtr defines) | |
| { | |
| int ret = 0, res; | |
| int needmore = 0; | |
| xmlRelaxNGDefinePtr cur; | |
| cur = defines; | |
| while (cur != NULL) { | |
| if (cur->type == XML_RELAXNG_ATTRIBUTE) { | |
| if (xmlRelaxNGValidateAttribute(ctxt, cur) != 0) | |
| ret = -1; | |
| } else | |
| needmore = 1; | |
| cur = cur->next; | |
| } | |
| if (!needmore) | |
| return (ret); | |
| cur = defines; | |
| while (cur != NULL) { | |
| if (cur->type != XML_RELAXNG_ATTRIBUTE) { | |
| if ((ctxt->state != NULL) || (ctxt->states != NULL)) { | |
| res = xmlRelaxNGValidateDefinition(ctxt, cur); | |
| if (res < 0) | |
| ret = -1; | |
| } else { | |
| VALID_ERR(XML_RELAXNG_ERR_NOSTATE); | |
| return (-1); | |
| } | |
| if (res == -1) /* continues on -2 */ | |
| break; | |
| } | |
| cur = cur->next; | |
| } | |
| return (ret); | |
| } | |
| /** | |
| * xmlRelaxNGNodeMatchesList: | |
| * @node: the node | |
| * @list: a NULL terminated array of definitions | |
| * | |
| * Check if a node can be matched by one of the definitions | |
| * | |
| * Returns 1 if matches 0 otherwise | |
| */ | |
| static int | |
| xmlRelaxNGNodeMatchesList(xmlNodePtr node, xmlRelaxNGDefinePtr * list) | |
| { | |
| xmlRelaxNGDefinePtr cur; | |
| int i = 0, tmp; | |
| if ((node == NULL) || (list == NULL)) | |
| return (0); | |
| cur = list[i++]; | |
| while (cur != NULL) { | |
| if ((node->type == XML_ELEMENT_NODE) && | |
| (cur->type == XML_RELAXNG_ELEMENT)) { | |
| tmp = xmlRelaxNGElementMatch(NULL, cur, node); | |
| if (tmp == 1) | |
| return (1); | |
| } else if (((node->type == XML_TEXT_NODE) || | |
| (node->type == XML_CDATA_SECTION_NODE)) && | |
| (cur->type == XML_RELAXNG_TEXT)) { | |
| return (1); | |
| } | |
| cur = list[i++]; | |
| } | |
| return (0); | |
| } | |
| /** | |
| * xmlRelaxNGValidateInterleave: | |
| * @ctxt: a Relax-NG validation context | |
| * @define: the definition to verify | |
| * | |
| * Validate an interleave definition for a node. | |
| * | |
| * Returns 0 if the validation succeeded or an error code. | |
| */ | |
| static int | |
| xmlRelaxNGValidateInterleave(xmlRelaxNGValidCtxtPtr ctxt, | |
| xmlRelaxNGDefinePtr define) | |
| { | |
| int ret = 0, i, nbgroups; | |
| int errNr = ctxt->errNr; | |
| int oldflags; | |
| xmlRelaxNGValidStatePtr oldstate; | |
| xmlRelaxNGPartitionPtr partitions; | |
| xmlRelaxNGInterleaveGroupPtr group = NULL; | |
| xmlNodePtr cur, start, last = NULL, lastchg = NULL, lastelem; | |
| xmlNodePtr *list = NULL, *lasts = NULL; | |
| if (define->data != NULL) { | |
| partitions = (xmlRelaxNGPartitionPtr) define->data; | |
| nbgroups = partitions->nbgroups; | |
| } else { | |
| VALID_ERR(XML_RELAXNG_ERR_INTERNODATA); | |
| return (-1); | |
| } | |
| /* | |
| * Optimizations for MIXED | |
| */ | |
| oldflags = ctxt->flags; | |
| if (define->dflags & IS_MIXED) { | |
| ctxt->flags |= FLAGS_MIXED_CONTENT; | |
| if (nbgroups == 2) { | |
| /* | |
| * this is a pure <mixed> case | |
| */ | |
| if (ctxt->state != NULL) | |
| ctxt->state->seq = xmlRelaxNGSkipIgnored(ctxt, | |
| ctxt->state->seq); | |
| if (partitions->groups[0]->rule->type == XML_RELAXNG_TEXT) | |
| ret = xmlRelaxNGValidateDefinition(ctxt, | |
| partitions->groups[1]-> | |
| rule); | |
| else | |
| ret = xmlRelaxNGValidateDefinition(ctxt, | |
| partitions->groups[0]-> | |
| rule); | |
| if (ret == 0) { | |
| if (ctxt->state != NULL) | |
| ctxt->state->seq = xmlRelaxNGSkipIgnored(ctxt, | |
| ctxt->state-> | |
| seq); | |
| } | |
| ctxt->flags = oldflags; | |
| return (ret); | |
| } | |
| } | |
| /* | |
| * Build arrays to store the first and last node of the chain | |
| * pertaining to each group | |
| */ | |
| list = (xmlNodePtr *) xmlMalloc(nbgroups * sizeof(xmlNodePtr)); | |
| if (list == NULL) { | |
| xmlRngVErrMemory(ctxt, "validating\n"); | |
| return (-1); | |
| } | |
| memset(list, 0, nbgroups * sizeof(xmlNodePtr)); | |
| lasts = (xmlNodePtr *) xmlMalloc(nbgroups * sizeof(xmlNodePtr)); | |
| if (lasts == NULL) { | |
| xmlRngVErrMemory(ctxt, "validating\n"); | |
| return (-1); | |
| } | |
| memset(lasts, 0, nbgroups * sizeof(xmlNodePtr)); | |
| /* | |
| * Walk the sequence of children finding the right group and | |
| * sorting them in sequences. | |
| */ | |
| cur = ctxt->state->seq; | |
| cur = xmlRelaxNGSkipIgnored(ctxt, cur); | |
| start = cur; | |
| while (cur != NULL) { | |
| ctxt->state->seq = cur; | |
| if ((partitions->triage != NULL) && | |
| (partitions->flags & IS_DETERMINIST)) { | |
| void *tmp = NULL; | |
| if ((cur->type == XML_TEXT_NODE) || | |
| (cur->type == XML_CDATA_SECTION_NODE)) { | |
| tmp = xmlHashLookup2(partitions->triage, BAD_CAST "#text", | |
| NULL); | |
| } else if (cur->type == XML_ELEMENT_NODE) { | |
| if (cur->ns != NULL) { | |
| tmp = xmlHashLookup2(partitions->triage, cur->name, | |
| cur->ns->href); | |
| if (tmp == NULL) | |
| tmp = xmlHashLookup2(partitions->triage, | |
| BAD_CAST "#any", | |
| cur->ns->href); | |
| } else | |
| tmp = | |
| xmlHashLookup2(partitions->triage, cur->name, | |
| NULL); | |
| if (tmp == NULL) | |
| tmp = | |
| xmlHashLookup2(partitions->triage, BAD_CAST "#any", | |
| NULL); | |
| } | |
| if (tmp == NULL) { | |
| i = nbgroups; | |
| } else { | |
| i = ((long) tmp) - 1; | |
| if (partitions->flags & IS_NEEDCHECK) { | |
| group = partitions->groups[i]; | |
| if (!xmlRelaxNGNodeMatchesList(cur, group->defs)) | |
| i = nbgroups; | |
| } | |
| } | |
| } else { | |
| for (i = 0; i < nbgroups; i++) { | |
| group = partitions->groups[i]; | |
| if (group == NULL) | |
| continue; | |
| if (xmlRelaxNGNodeMatchesList(cur, group->defs)) | |
| break; | |
| } | |
| } | |
| /* | |
| * We break as soon as an element not matched is found | |
| */ | |
| if (i >= nbgroups) { | |
| break; | |
| } | |
| if (lasts[i] != NULL) { | |
| lasts[i]->next = cur; | |
| lasts[i] = cur; | |
| } else { | |
| list[i] = cur; | |
| lasts[i] = cur; | |
| } | |
| if (cur->next != NULL) | |
| lastchg = cur->next; | |
| else | |
| lastchg = cur; | |
| cur = xmlRelaxNGSkipIgnored(ctxt, cur->next); | |
| } | |
| if (ret != 0) { | |
| VALID_ERR(XML_RELAXNG_ERR_INTERSEQ); | |
| ret = -1; | |
| goto done; | |
| } | |
| lastelem = cur; | |
| oldstate = ctxt->state; | |
| for (i = 0; i < nbgroups; i++) { | |
| ctxt->state = xmlRelaxNGCopyValidState(ctxt, oldstate); | |
| if (ctxt->state == NULL) { | |
| ret = -1; | |
| break; | |
| } | |
| group = partitions->groups[i]; | |
| if (lasts[i] != NULL) { | |
| last = lasts[i]->next; | |
| lasts[i]->next = NULL; | |
| } | |
| ctxt->state->seq = list[i]; | |
| ret = xmlRelaxNGValidateDefinition(ctxt, group->rule); | |
| if (ret != 0) | |
| break; | |
| if (ctxt->state != NULL) { | |
| cur = ctxt->state->seq; | |
| cur = xmlRelaxNGSkipIgnored(ctxt, cur); | |
| xmlRelaxNGFreeValidState(ctxt, oldstate); | |
| oldstate = ctxt->state; | |
| ctxt->state = NULL; | |
| if (cur != NULL) { | |
| VALID_ERR2(XML_RELAXNG_ERR_INTEREXTRA, cur->name); | |
| ret = -1; | |
| ctxt->state = oldstate; | |
| goto done; | |
| } | |
| } else if (ctxt->states != NULL) { | |
| int j; | |
| int found = 0; | |
| int best = -1; | |
| int lowattr = -1; | |
| /* | |
| * PBM: what happen if there is attributes checks in the interleaves | |
| */ | |
| for (j = 0; j < ctxt->states->nbState; j++) { | |
| cur = ctxt->states->tabState[j]->seq; | |
| cur = xmlRelaxNGSkipIgnored(ctxt, cur); | |
| if (cur == NULL) { | |
| if (found == 0) { | |
| lowattr = ctxt->states->tabState[j]->nbAttrLeft; | |
| best = j; | |
| } | |
| found = 1; | |
| if (ctxt->states->tabState[j]->nbAttrLeft <= lowattr) { | |
| /* try to keep the latest one to mach old heuristic */ | |
| lowattr = ctxt->states->tabState[j]->nbAttrLeft; | |
| best = j; | |
| } | |
| if (lowattr == 0) | |
| break; | |
| } else if (found == 0) { | |
| if (lowattr == -1) { | |
| lowattr = ctxt->states->tabState[j]->nbAttrLeft; | |
| best = j; | |
| } else | |
| if (ctxt->states->tabState[j]->nbAttrLeft <= lowattr) { | |
| /* try to keep the latest one to mach old heuristic */ | |
| lowattr = ctxt->states->tabState[j]->nbAttrLeft; | |
| best = j; | |
| } | |
| } | |
| } | |
| /* | |
| * BIG PBM: here we pick only one restarting point :-( | |
| */ | |
| if (ctxt->states->nbState > 0) { | |
| xmlRelaxNGFreeValidState(ctxt, oldstate); | |
| if (best != -1) { | |
| oldstate = ctxt->states->tabState[best]; | |
| ctxt->states->tabState[best] = NULL; | |
| } else { | |
| oldstate = | |
| ctxt->states->tabState[ctxt->states->nbState - 1]; | |
| ctxt->states->tabState[ctxt->states->nbState - 1] = NULL; | |
| ctxt->states->nbState--; | |
| } | |
| } | |
| for (j = 0; j < ctxt->states->nbState ; j++) { | |
| xmlRelaxNGFreeValidState(ctxt, ctxt->states->tabState[j]); | |
| } | |
| xmlRelaxNGFreeStates(ctxt, ctxt->states); | |
| ctxt->states = NULL; | |
| if (found == 0) { | |
| if (cur == NULL) { | |
| VALID_ERR2(XML_RELAXNG_ERR_INTEREXTRA, | |
| (const xmlChar *) "noname"); | |
| } else { | |
| VALID_ERR2(XML_RELAXNG_ERR_INTEREXTRA, cur->name); | |
| } | |
| ret = -1; | |
| ctxt->state = oldstate; | |
| goto done; | |
| } | |
| } else { | |
| ret = -1; | |
| break; | |
| } | |
| if (lasts[i] != NULL) { | |
| lasts[i]->next = last; | |
| } | |
| } | |
| if (ctxt->state != NULL) | |
| xmlRelaxNGFreeValidState(ctxt, ctxt->state); | |
| ctxt->state = oldstate; | |
| ctxt->state->seq = lastelem; | |
| if (ret != 0) { | |
| VALID_ERR(XML_RELAXNG_ERR_INTERSEQ); | |
| ret = -1; | |
| goto done; | |
| } | |
| done: | |
| ctxt->flags = oldflags; | |
| /* | |
| * builds the next links chain from the prev one | |
| */ | |
| cur = lastchg; | |
| while (cur != NULL) { | |
| if ((cur == start) || (cur->prev == NULL)) | |
| break; | |
| cur->prev->next = cur; | |
| cur = cur->prev; | |
| } | |
| if (ret == 0) { | |
| if (ctxt->errNr > errNr) | |
| xmlRelaxNGPopErrors(ctxt, errNr); | |
| } | |
| xmlFree(list); | |
| xmlFree(lasts); | |
| return (ret); | |
| } | |
| /** | |
| * xmlRelaxNGValidateDefinitionList: | |
| * @ctxt: a Relax-NG validation context | |
| * @define: the list of definition to verify | |
| * | |
| * Validate the given node content against the (list) of definitions | |
| * | |
| * Returns 0 if the validation succeeded or an error code. | |
| */ | |
| static int | |
| xmlRelaxNGValidateDefinitionList(xmlRelaxNGValidCtxtPtr ctxt, | |
| xmlRelaxNGDefinePtr defines) | |
| { | |
| int ret = 0, res; | |
| if (defines == NULL) { | |
| VALID_ERR2(XML_RELAXNG_ERR_INTERNAL, | |
| BAD_CAST "NULL definition list"); | |
| return (-1); | |
| } | |
| while (defines != NULL) { | |
| if ((ctxt->state != NULL) || (ctxt->states != NULL)) { | |
| res = xmlRelaxNGValidateDefinition(ctxt, defines); | |
| if (res < 0) | |
| ret = -1; | |
| } else { | |
| VALID_ERR(XML_RELAXNG_ERR_NOSTATE); | |
| return (-1); | |
| } | |
| if (res == -1) /* continues on -2 */ | |
| break; | |
| defines = defines->next; | |
| } | |
| return (ret); | |
| } | |
| /** | |
| * xmlRelaxNGElementMatch: | |
| * @ctxt: a Relax-NG validation context | |
| * @define: the definition to check | |
| * @elem: the element | |
| * | |
| * Check if the element matches the definition nameClass | |
| * | |
| * Returns 1 if the element matches, 0 if no, or -1 in case of error | |
| */ | |
| static int | |
| xmlRelaxNGElementMatch(xmlRelaxNGValidCtxtPtr ctxt, | |
| xmlRelaxNGDefinePtr define, xmlNodePtr elem) | |
| { | |
| int ret = 0, oldflags = 0; | |
| if (define->name != NULL) { | |
| if (!xmlStrEqual(elem->name, define->name)) { | |
| VALID_ERR3(XML_RELAXNG_ERR_ELEMNAME, define->name, elem->name); | |
| return (0); | |
| } | |
| } | |
| if ((define->ns != NULL) && (define->ns[0] != 0)) { | |
| if (elem->ns == NULL) { | |
| VALID_ERR2(XML_RELAXNG_ERR_ELEMNONS, elem->name); | |
| return (0); | |
| } else if (!xmlStrEqual(elem->ns->href, define->ns)) { | |
| VALID_ERR3(XML_RELAXNG_ERR_ELEMWRONGNS, | |
| elem->name, define->ns); | |
| return (0); | |
| } | |
| } else if ((elem->ns != NULL) && (define->ns != NULL) && | |
| (define->name == NULL)) { | |
| VALID_ERR2(XML_RELAXNG_ERR_ELEMEXTRANS, elem->name); | |
| return (0); | |
| } else if ((elem->ns != NULL) && (define->name != NULL)) { | |
| VALID_ERR2(XML_RELAXNG_ERR_ELEMEXTRANS, define->name); | |
| return (0); | |
| } | |
| if (define->nameClass == NULL) | |
| return (1); | |
| define = define->nameClass; | |
| if (define->type == XML_RELAXNG_EXCEPT) { | |
| xmlRelaxNGDefinePtr list; | |
| if (ctxt != NULL) { | |
| oldflags = ctxt->flags; | |
| ctxt->flags |= FLAGS_IGNORABLE; | |
| } | |
| list = define->content; | |
| while (list != NULL) { | |
| ret = xmlRelaxNGElementMatch(ctxt, list, elem); | |
| if (ret == 1) { | |
| if (ctxt != NULL) | |
| ctxt->flags = oldflags; | |
| return (0); | |
| } | |
| if (ret < 0) { | |
| if (ctxt != NULL) | |
| ctxt->flags = oldflags; | |
| return (ret); | |
| } | |
| list = list->next; | |
| } | |
| ret = 1; | |
| if (ctxt != NULL) { | |
| ctxt->flags = oldflags; | |
| } | |
| } else if (define->type == XML_RELAXNG_CHOICE) { | |
| xmlRelaxNGDefinePtr list; | |
| if (ctxt != NULL) { | |
| oldflags = ctxt->flags; | |
| ctxt->flags |= FLAGS_IGNORABLE; | |
| } | |
| list = define->nameClass; | |
| while (list != NULL) { | |
| ret = xmlRelaxNGElementMatch(ctxt, list, elem); | |
| if (ret == 1) { | |
| if (ctxt != NULL) | |
| ctxt->flags = oldflags; | |
| return (1); | |
| } | |
| if (ret < 0) { | |
| if (ctxt != NULL) | |
| ctxt->flags = oldflags; | |
| return (ret); | |
| } | |
| list = list->next; | |
| } | |
| if (ctxt != NULL) { | |
| if (ret != 0) { | |
| if ((ctxt->flags & FLAGS_IGNORABLE) == 0) | |
| xmlRelaxNGDumpValidError(ctxt); | |
| } else { | |
| if (ctxt->errNr > 0) | |
| xmlRelaxNGPopErrors(ctxt, 0); | |
| } | |
| } | |
| ret = 0; | |
| if (ctxt != NULL) { | |
| ctxt->flags = oldflags; | |
| } | |
| } else { | |
| TODO ret = -1; | |
| } | |
| return (ret); | |
| } | |
| /** | |
| * xmlRelaxNGBestState: | |
| * @ctxt: a Relax-NG validation context | |
| * | |
| * Find the "best" state in the ctxt->states list of states to report | |
| * errors about. I.e. a state with no element left in the child list | |
| * or the one with the less attributes left. | |
| * This is called only if a falidation error was detected | |
| * | |
| * Returns the index of the "best" state or -1 in case of error | |
| */ | |
| static int | |
| xmlRelaxNGBestState(xmlRelaxNGValidCtxtPtr ctxt) | |
| { | |
| xmlRelaxNGValidStatePtr state; | |
| int i, tmp; | |
| int best = -1; | |
| int value = 1000000; | |
| if ((ctxt == NULL) || (ctxt->states == NULL) || | |
| (ctxt->states->nbState <= 0)) | |
| return (-1); | |
| for (i = 0; i < ctxt->states->nbState; i++) { | |
| state = ctxt->states->tabState[i]; | |
| if (state == NULL) | |
| continue; | |
| if (state->seq != NULL) { | |
| if ((best == -1) || (value > 100000)) { | |
| value = 100000; | |
| best = i; | |
| } | |
| } else { | |
| tmp = state->nbAttrLeft; | |
| if ((best == -1) || (value > tmp)) { | |
| value = tmp; | |
| best = i; | |
| } | |
| } | |
| } | |
| return (best); | |
| } | |
| /** | |
| * xmlRelaxNGLogBestError: | |
| * @ctxt: a Relax-NG validation context | |
| * | |
| * Find the "best" state in the ctxt->states list of states to report | |
| * errors about and log it. | |
| */ | |
| static void | |
| xmlRelaxNGLogBestError(xmlRelaxNGValidCtxtPtr ctxt) | |
| { | |
| int best; | |
| if ((ctxt == NULL) || (ctxt->states == NULL) || | |
| (ctxt->states->nbState <= 0)) | |
| return; | |
| best = xmlRelaxNGBestState(ctxt); | |
| if ((best >= 0) && (best < ctxt->states->nbState)) { | |
| ctxt->state = ctxt->states->tabState[best]; | |
| xmlRelaxNGValidateElementEnd(ctxt, 1); | |
| } | |
| } | |
| /** | |
| * xmlRelaxNGValidateElementEnd: | |
| * @ctxt: a Relax-NG validation context | |
| * @dolog: indicate that error logging should be done | |
| * | |
| * Validate the end of the element, implements check that | |
| * there is nothing left not consumed in the element content | |
| * or in the attribute list. | |
| * | |
| * Returns 0 if the validation succeeded or an error code. | |
| */ | |
| static int | |
| xmlRelaxNGValidateElementEnd(xmlRelaxNGValidCtxtPtr ctxt, int dolog) | |
| { | |
| int i; | |
| xmlRelaxNGValidStatePtr state; | |
| state = ctxt->state; | |
| if (state->seq != NULL) { | |
| state->seq = xmlRelaxNGSkipIgnored(ctxt, state->seq); | |
| if (state->seq != NULL) { | |
| if (dolog) { | |
| VALID_ERR3(XML_RELAXNG_ERR_EXTRACONTENT, | |
| state->node->name, state->seq->name); | |
| } | |
| return (-1); | |
| } | |
| } | |
| for (i = 0; i < state->nbAttrs; i++) { | |
| if (state->attrs[i] != NULL) { | |
| if (dolog) { | |
| VALID_ERR3(XML_RELAXNG_ERR_INVALIDATTR, | |
| state->attrs[i]->name, state->node->name); | |
| } | |
| return (-1 - i); | |
| } | |
| } | |
| return (0); | |
| } | |
| /** | |
| * xmlRelaxNGValidateState: | |
| * @ctxt: a Relax-NG validation context | |
| * @define: the definition to verify | |
| * | |
| * Validate the current state against the definition | |
| * | |
| * Returns 0 if the validation succeeded or an error code. | |
| */ | |
| static int | |
| xmlRelaxNGValidateState(xmlRelaxNGValidCtxtPtr ctxt, | |
| xmlRelaxNGDefinePtr define) | |
| { | |
| xmlNodePtr node; | |
| int ret = 0, i, tmp, oldflags, errNr; | |
| xmlRelaxNGValidStatePtr oldstate = NULL, state; | |
| if (define == NULL) { | |
| VALID_ERR(XML_RELAXNG_ERR_NODEFINE); | |
| return (-1); | |
| } | |
| if (ctxt->state != NULL) { | |
| node = ctxt->state->seq; | |
| } else { | |
| node = NULL; | |
| } | |
| #ifdef DEBUG | |
| for (i = 0; i < ctxt->depth; i++) | |
| xmlGenericError(xmlGenericErrorContext, " "); | |
| xmlGenericError(xmlGenericErrorContext, | |
| "Start validating %s ", xmlRelaxNGDefName(define)); | |
| if (define->name != NULL) | |
| xmlGenericError(xmlGenericErrorContext, "%s ", define->name); | |
| if ((node != NULL) && (node->name != NULL)) | |
| xmlGenericError(xmlGenericErrorContext, "on %s\n", node->name); | |
| else | |
| xmlGenericError(xmlGenericErrorContext, "\n"); | |
| #endif | |
| ctxt->depth++; | |
| switch (define->type) { | |
| case XML_RELAXNG_EMPTY: | |
| xmlRelaxNGSkipIgnored(ctxt, node); | |
| ret = 0; | |
| break; | |
| case XML_RELAXNG_NOT_ALLOWED: | |
| ret = -1; | |
| break; | |
| case XML_RELAXNG_TEXT: | |
| while ((node != NULL) && | |
| ((node->type == XML_TEXT_NODE) || | |
| (node->type == XML_COMMENT_NODE) || | |
| (node->type == XML_PI_NODE) || | |
| (node->type == XML_CDATA_SECTION_NODE))) | |
| node = node->next; | |
| ctxt->state->seq = node; | |
| break; | |
| case XML_RELAXNG_ELEMENT: | |
| errNr = ctxt->errNr; | |
| node = xmlRelaxNGSkipIgnored(ctxt, node); | |
| if (node == NULL) { | |
| VALID_ERR2(XML_RELAXNG_ERR_NOELEM, define->name); | |
| ret = -1; | |
| if ((ctxt->flags & FLAGS_IGNORABLE) == 0) | |
| xmlRelaxNGDumpValidError(ctxt); | |
| break; | |
| } | |
| if (node->type != XML_ELEMENT_NODE) { | |
| VALID_ERR(XML_RELAXNG_ERR_NOTELEM); | |
| ret = -1; | |
| if ((ctxt->flags & FLAGS_IGNORABLE) == 0) | |
| xmlRelaxNGDumpValidError(ctxt); | |
| break; | |
| } | |
| /* | |
| * This node was already validated successfully against | |
| * this definition. | |
| */ | |
| if (node->psvi == define) { | |
| ctxt->state->seq = xmlRelaxNGSkipIgnored(ctxt, node->next); | |
| if (ctxt->errNr > errNr) | |
| xmlRelaxNGPopErrors(ctxt, errNr); | |
| if (ctxt->errNr != 0) { | |
| while ((ctxt->err != NULL) && | |
| (((ctxt->err->err == XML_RELAXNG_ERR_ELEMNAME) | |
| && (xmlStrEqual(ctxt->err->arg2, node->name))) | |
| || | |
| ((ctxt->err->err == | |
| XML_RELAXNG_ERR_ELEMEXTRANS) | |
| && (xmlStrEqual(ctxt->err->arg1, node->name))) | |
| || (ctxt->err->err == XML_RELAXNG_ERR_NOELEM) | |
| || (ctxt->err->err == | |
| XML_RELAXNG_ERR_NOTELEM))) | |
| xmlRelaxNGValidErrorPop(ctxt); | |
| } | |
| break; | |
| } | |
| ret = xmlRelaxNGElementMatch(ctxt, define, node); | |
| if (ret <= 0) { | |
| ret = -1; | |
| if ((ctxt->flags & FLAGS_IGNORABLE) == 0) | |
| xmlRelaxNGDumpValidError(ctxt); | |
| break; | |
| } | |
| ret = 0; | |
| if (ctxt->errNr != 0) { | |
| if (ctxt->errNr > errNr) | |
| xmlRelaxNGPopErrors(ctxt, errNr); | |
| while ((ctxt->err != NULL) && | |
| (((ctxt->err->err == XML_RELAXNG_ERR_ELEMNAME) && | |
| (xmlStrEqual(ctxt->err->arg2, node->name))) || | |
| ((ctxt->err->err == XML_RELAXNG_ERR_ELEMEXTRANS) && | |
| (xmlStrEqual(ctxt->err->arg1, node->name))) || | |
| (ctxt->err->err == XML_RELAXNG_ERR_NOELEM) || | |
| (ctxt->err->err == XML_RELAXNG_ERR_NOTELEM))) | |
| xmlRelaxNGValidErrorPop(ctxt); | |
| } | |
| errNr = ctxt->errNr; | |
| oldflags = ctxt->flags; | |
| if (ctxt->flags & FLAGS_MIXED_CONTENT) { | |
| ctxt->flags -= FLAGS_MIXED_CONTENT; | |
| } | |
| state = xmlRelaxNGNewValidState(ctxt, node); | |
| if (state == NULL) { | |
| ret = -1; | |
| if ((ctxt->flags & FLAGS_IGNORABLE) == 0) | |
| xmlRelaxNGDumpValidError(ctxt); | |
| break; | |
| } | |
| oldstate = ctxt->state; | |
| ctxt->state = state; | |
| if (define->attrs != NULL) { | |
| tmp = xmlRelaxNGValidateAttributeList(ctxt, define->attrs); | |
| if (tmp != 0) { | |
| ret = -1; | |
| VALID_ERR2(XML_RELAXNG_ERR_ATTRVALID, node->name); | |
| } | |
| } | |
| if (define->contModel != NULL) { | |
| xmlRelaxNGValidStatePtr nstate, tmpstate = ctxt->state; | |
| xmlRelaxNGStatesPtr tmpstates = ctxt->states; | |
| xmlNodePtr nseq; | |
| nstate = xmlRelaxNGNewValidState(ctxt, node); | |
| ctxt->state = nstate; | |
| ctxt->states = NULL; | |
| tmp = xmlRelaxNGValidateCompiledContent(ctxt, | |
| define->contModel, | |
| ctxt->state->seq); | |
| nseq = ctxt->state->seq; | |
| ctxt->state = tmpstate; | |
| ctxt->states = tmpstates; | |
| xmlRelaxNGFreeValidState(ctxt, nstate); | |
| #ifdef DEBUG_COMPILE | |
| xmlGenericError(xmlGenericErrorContext, | |
| "Validating content of '%s' : %d\n", | |
| define->name, tmp); | |
| #endif | |
| if (tmp != 0) | |
| ret = -1; | |
| if (ctxt->states != NULL) { | |
| tmp = -1; | |
| for (i = 0; i < ctxt->states->nbState; i++) { | |
| state = ctxt->states->tabState[i]; | |
| ctxt->state = state; | |
| ctxt->state->seq = nseq; | |
| if (xmlRelaxNGValidateElementEnd(ctxt, 0) == 0) { | |
| tmp = 0; | |
| break; | |
| } | |
| } | |
| if (tmp != 0) { | |
| /* | |
| * validation error, log the message for the "best" one | |
| */ | |
| ctxt->flags |= FLAGS_IGNORABLE; | |
| xmlRelaxNGLogBestError(ctxt); | |
| } | |
| for (i = 0; i < ctxt->states->nbState; i++) { | |
| xmlRelaxNGFreeValidState(ctxt, | |
| ctxt->states-> | |
| tabState[i]); | |
| } | |
| xmlRelaxNGFreeStates(ctxt, ctxt->states); | |
| ctxt->flags = oldflags; | |
| ctxt->states = NULL; | |
| if ((ret == 0) && (tmp == -1)) | |
| ret = -1; | |
| } else { | |
| state = ctxt->state; | |
| if (ctxt->state != NULL) | |
| ctxt->state->seq = nseq; | |
| if (ret == 0) | |
| ret = xmlRelaxNGValidateElementEnd(ctxt, 1); | |
| xmlRelaxNGFreeValidState(ctxt, state); | |
| } | |
| } else { | |
| if (define->content != NULL) { | |
| tmp = xmlRelaxNGValidateDefinitionList(ctxt, | |
| define-> | |
| content); | |
| if (tmp != 0) { | |
| ret = -1; | |
| if (ctxt->state == NULL) { | |
| ctxt->state = oldstate; | |
| VALID_ERR2(XML_RELAXNG_ERR_CONTENTVALID, | |
| node->name); | |
| ctxt->state = NULL; | |
| } else { | |
| VALID_ERR2(XML_RELAXNG_ERR_CONTENTVALID, | |
| node->name); | |
| } | |
| } | |
| } | |
| if (ctxt->states != NULL) { | |
| tmp = -1; | |
| for (i = 0; i < ctxt->states->nbState; i++) { | |
| state = ctxt->states->tabState[i]; | |
| ctxt->state = state; | |
| if (xmlRelaxNGValidateElementEnd(ctxt, 0) == 0) { | |
| tmp = 0; | |
| break; | |
| } | |
| } | |
| if (tmp != 0) { | |
| /* | |
| * validation error, log the message for the "best" one | |
| */ | |
| ctxt->flags |= FLAGS_IGNORABLE; | |
| xmlRelaxNGLogBestError(ctxt); | |
| } | |
| for (i = 0; i < ctxt->states->nbState; i++) { | |
| xmlRelaxNGFreeValidState(ctxt, | |
| ctxt->states->tabState[i]); | |
| ctxt->states->tabState[i] = NULL; | |
| } | |
| xmlRelaxNGFreeStates(ctxt, ctxt->states); | |
| ctxt->flags = oldflags; | |
| ctxt->states = NULL; | |
| if ((ret == 0) && (tmp == -1)) | |
| ret = -1; | |
| } else { | |
| state = ctxt->state; | |
| if (ret == 0) | |
| ret = xmlRelaxNGValidateElementEnd(ctxt, 1); | |
| xmlRelaxNGFreeValidState(ctxt, state); | |
| } | |
| } | |
| if (ret == 0) { | |
| node->psvi = define; | |
| } | |
| ctxt->flags = oldflags; | |
| ctxt->state = oldstate; | |
| if (oldstate != NULL) | |
| oldstate->seq = xmlRelaxNGSkipIgnored(ctxt, node->next); | |
| if (ret != 0) { | |
| if ((ctxt->flags & FLAGS_IGNORABLE) == 0) { | |
| xmlRelaxNGDumpValidError(ctxt); | |
| ret = 0; | |
| #if 0 | |
| } else { | |
| ret = -2; | |
| #endif | |
| } | |
| } else { | |
| if (ctxt->errNr > errNr) | |
| xmlRelaxNGPopErrors(ctxt, errNr); | |
| } | |
| #ifdef DEBUG | |
| xmlGenericError(xmlGenericErrorContext, | |
| "xmlRelaxNGValidateDefinition(): validated %s : %d", | |
| node->name, ret); | |
| if (oldstate == NULL) | |
| xmlGenericError(xmlGenericErrorContext, ": no state\n"); | |
| else if (oldstate->seq == NULL) | |
| xmlGenericError(xmlGenericErrorContext, ": done\n"); | |
| else if (oldstate->seq->type == XML_ELEMENT_NODE) | |
| xmlGenericError(xmlGenericErrorContext, ": next elem %s\n", | |
| oldstate->seq->name); | |
| else | |
| xmlGenericError(xmlGenericErrorContext, ": next %s %d\n", | |
| oldstate->seq->name, oldstate->seq->type); | |
| #endif | |
| break; | |
| case XML_RELAXNG_OPTIONAL:{ | |
| errNr = ctxt->errNr; | |
| oldflags = ctxt->flags; | |
| ctxt->flags |= FLAGS_IGNORABLE; | |
| oldstate = xmlRelaxNGCopyValidState(ctxt, ctxt->state); | |
| ret = | |
| xmlRelaxNGValidateDefinitionList(ctxt, | |
| define->content); | |
| if (ret != 0) { | |
| if (ctxt->state != NULL) | |
| xmlRelaxNGFreeValidState(ctxt, ctxt->state); | |
| ctxt->state = oldstate; | |
| ctxt->flags = oldflags; | |
| ret = 0; | |
| if (ctxt->errNr > errNr) | |
| xmlRelaxNGPopErrors(ctxt, errNr); | |
| break; | |
| } | |
| if (ctxt->states != NULL) { | |
| xmlRelaxNGAddStates(ctxt, ctxt->states, oldstate); | |
| } else { | |
| ctxt->states = xmlRelaxNGNewStates(ctxt, 1); | |
| if (ctxt->states == NULL) { | |
| xmlRelaxNGFreeValidState(ctxt, oldstate); | |
| ctxt->flags = oldflags; | |
| ret = -1; | |
| if (ctxt->errNr > errNr) | |
| xmlRelaxNGPopErrors(ctxt, errNr); | |
| break; | |
| } | |
| xmlRelaxNGAddStates(ctxt, ctxt->states, oldstate); | |
| xmlRelaxNGAddStates(ctxt, ctxt->states, ctxt->state); | |
| ctxt->state = NULL; | |
| } | |
| ctxt->flags = oldflags; | |
| ret = 0; | |
| if (ctxt->errNr > errNr) | |
| xmlRelaxNGPopErrors(ctxt, errNr); | |
| break; | |
| } | |
| case XML_RELAXNG_ONEORMORE: | |
| errNr = ctxt->errNr; | |
| ret = xmlRelaxNGValidateDefinitionList(ctxt, define->content); | |
| if (ret != 0) { | |
| break; | |
| } | |
| if (ctxt->errNr > errNr) | |
| xmlRelaxNGPopErrors(ctxt, errNr); | |
| /* no break on purpose */ | |
| case XML_RELAXNG_ZEROORMORE:{ | |
| int progress; | |
| xmlRelaxNGStatesPtr states = NULL, res = NULL; | |
| int base, j; | |
| errNr = ctxt->errNr; | |
| res = xmlRelaxNGNewStates(ctxt, 1); | |
| if (res == NULL) { | |
| ret = -1; | |
| break; | |
| } | |
| /* | |
| * All the input states are also exit states | |
| */ | |
| if (ctxt->state != NULL) { | |
| xmlRelaxNGAddStates(ctxt, res, | |
| xmlRelaxNGCopyValidState(ctxt, | |
| ctxt-> | |
| state)); | |
| } else { | |
| for (j = 0; j < ctxt->states->nbState; j++) { | |
| xmlRelaxNGAddStates(ctxt, res, | |
| xmlRelaxNGCopyValidState(ctxt, | |
| ctxt->states->tabState[j])); | |
| } | |
| } | |
| oldflags = ctxt->flags; | |
| ctxt->flags |= FLAGS_IGNORABLE; | |
| do { | |
| progress = 0; | |
| base = res->nbState; | |
| if (ctxt->states != NULL) { | |
| states = ctxt->states; | |
| for (i = 0; i < states->nbState; i++) { | |
| ctxt->state = states->tabState[i]; | |
| ctxt->states = NULL; | |
| ret = xmlRelaxNGValidateDefinitionList(ctxt, | |
| define-> | |
| content); | |
| if (ret == 0) { | |
| if (ctxt->state != NULL) { | |
| tmp = xmlRelaxNGAddStates(ctxt, res, | |
| ctxt->state); | |
| ctxt->state = NULL; | |
| if (tmp == 1) | |
| progress = 1; | |
| } else if (ctxt->states != NULL) { | |
| for (j = 0; j < ctxt->states->nbState; | |
| j++) { | |
| tmp = | |
| xmlRelaxNGAddStates(ctxt, res, | |
| ctxt->states->tabState[j]); | |
| if (tmp == 1) | |
| progress = 1; | |
| } | |
| xmlRelaxNGFreeStates(ctxt, | |
| ctxt->states); | |
| ctxt->states = NULL; | |
| } | |
| } else { | |
| if (ctxt->state != NULL) { | |
| xmlRelaxNGFreeValidState(ctxt, | |
| ctxt->state); | |
| ctxt->state = NULL; | |
| } | |
| } | |
| } | |
| } else { | |
| ret = xmlRelaxNGValidateDefinitionList(ctxt, | |
| define-> | |
| content); | |
| if (ret != 0) { | |
| xmlRelaxNGFreeValidState(ctxt, ctxt->state); | |
| ctxt->state = NULL; | |
| } else { | |
| base = res->nbState; | |
| if (ctxt->state != NULL) { | |
| tmp = xmlRelaxNGAddStates(ctxt, res, | |
| ctxt->state); | |
| ctxt->state = NULL; | |
| if (tmp == 1) | |
| progress = 1; | |
| } else if (ctxt->states != NULL) { | |
| for (j = 0; j < ctxt->states->nbState; j++) { | |
| tmp = xmlRelaxNGAddStates(ctxt, res, | |
| ctxt->states->tabState[j]); | |
| if (tmp == 1) | |
| progress = 1; | |
| } | |
| if (states == NULL) { | |
| states = ctxt->states; | |
| } else { | |
| xmlRelaxNGFreeStates(ctxt, | |
| ctxt->states); | |
| } | |
| ctxt->states = NULL; | |
| } | |
| } | |
| } | |
| if (progress) { | |
| /* | |
| * Collect all the new nodes added at that step | |
| * and make them the new node set | |
| */ | |
| if (res->nbState - base == 1) { | |
| ctxt->state = xmlRelaxNGCopyValidState(ctxt, | |
| res-> | |
| tabState | |
| [base]); | |
| } else { | |
| if (states == NULL) { | |
| xmlRelaxNGNewStates(ctxt, | |
| res->nbState - base); | |
| states = ctxt->states; | |
| if (states == NULL) { | |
| progress = 0; | |
| break; | |
| } | |
| } | |
| states->nbState = 0; | |
| for (i = base; i < res->nbState; i++) | |
| xmlRelaxNGAddStates(ctxt, states, | |
| xmlRelaxNGCopyValidState | |
| (ctxt, res->tabState[i])); | |
| ctxt->states = states; | |
| } | |
| } | |
| } while (progress == 1); | |
| if (states != NULL) { | |
| xmlRelaxNGFreeStates(ctxt, states); | |
| } | |
| ctxt->states = res; | |
| ctxt->flags = oldflags; | |
| #if 0 | |
| /* | |
| * errors may have to be propagated back... | |
| */ | |
| if (ctxt->errNr > errNr) | |
| xmlRelaxNGPopErrors(ctxt, errNr); | |
| #endif | |
| ret = 0; | |
| break; | |
| } | |
| case XML_RELAXNG_CHOICE:{ | |
| xmlRelaxNGDefinePtr list = NULL; | |
| xmlRelaxNGStatesPtr states = NULL; | |
| node = xmlRelaxNGSkipIgnored(ctxt, node); | |
| errNr = ctxt->errNr; | |
| if ((define->dflags & IS_TRIABLE) && (define->data != NULL) && | |
| (node != NULL)) { | |
| /* | |
| * node == NULL can't be optimized since IS_TRIABLE | |
| * doesn't account for choice which may lead to | |
| * only attributes. | |
| */ | |
| xmlHashTablePtr triage = | |
| (xmlHashTablePtr) define->data; | |
| /* | |
| * Something we can optimize cleanly there is only one | |
| * possble branch out ! | |
| */ | |
| if ((node->type == XML_TEXT_NODE) || | |
| (node->type == XML_CDATA_SECTION_NODE)) { | |
| list = | |
| xmlHashLookup2(triage, BAD_CAST "#text", NULL); | |
| } else if (node->type == XML_ELEMENT_NODE) { | |
| if (node->ns != NULL) { | |
| list = xmlHashLookup2(triage, node->name, | |
| node->ns->href); | |
| if (list == NULL) | |
| list = | |
| xmlHashLookup2(triage, BAD_CAST "#any", | |
| node->ns->href); | |
| } else | |
| list = | |
| xmlHashLookup2(triage, node->name, NULL); | |
| if (list == NULL) | |
| list = | |
| xmlHashLookup2(triage, BAD_CAST "#any", | |
| NULL); | |
| } | |
| if (list == NULL) { | |
| ret = -1; | |
| VALID_ERR2(XML_RELAXNG_ERR_ELEMWRONG, node->name); | |
| break; | |
| } | |
| ret = xmlRelaxNGValidateDefinition(ctxt, list); | |
| if (ret == 0) { | |
| } | |
| break; | |
| } | |
| list = define->content; | |
| oldflags = ctxt->flags; | |
| ctxt->flags |= FLAGS_IGNORABLE; | |
| while (list != NULL) { | |
| oldstate = xmlRelaxNGCopyValidState(ctxt, ctxt->state); | |
| ret = xmlRelaxNGValidateDefinition(ctxt, list); | |
| if (ret == 0) { | |
| if (states == NULL) { | |
| states = xmlRelaxNGNewStates(ctxt, 1); | |
| } | |
| if (ctxt->state != NULL) { | |
| xmlRelaxNGAddStates(ctxt, states, ctxt->state); | |
| } else if (ctxt->states != NULL) { | |
| for (i = 0; i < ctxt->states->nbState; i++) { | |
| xmlRelaxNGAddStates(ctxt, states, | |
| ctxt->states-> | |
| tabState[i]); | |
| } | |
| xmlRelaxNGFreeStates(ctxt, ctxt->states); | |
| ctxt->states = NULL; | |
| } | |
| } else { | |
| xmlRelaxNGFreeValidState(ctxt, ctxt->state); | |
| } | |
| ctxt->state = oldstate; | |
| list = list->next; | |
| } | |
| if (states != NULL) { | |
| xmlRelaxNGFreeValidState(ctxt, oldstate); | |
| ctxt->states = states; | |
| ctxt->state = NULL; | |
| ret = 0; | |
| } else { | |
| ctxt->states = NULL; | |
| } | |
| ctxt->flags = oldflags; | |
| if (ret != 0) { | |
| if ((ctxt->flags & FLAGS_IGNORABLE) == 0) { | |
| xmlRelaxNGDumpValidError(ctxt); | |
| } | |
| } else { | |
| if (ctxt->errNr > errNr) | |
| xmlRelaxNGPopErrors(ctxt, errNr); | |
| } | |
| break; | |
| } | |
| case XML_RELAXNG_DEF: | |
| case XML_RELAXNG_GROUP: | |
| ret = xmlRelaxNGValidateDefinitionList(ctxt, define->content); | |
| break; | |
| case XML_RELAXNG_INTERLEAVE: | |
| ret = xmlRelaxNGValidateInterleave(ctxt, define); | |
| break; | |
| case XML_RELAXNG_ATTRIBUTE: | |
| ret = xmlRelaxNGValidateAttribute(ctxt, define); | |
| break; | |
| case XML_RELAXNG_START: | |
| case XML_RELAXNG_NOOP: | |
| case XML_RELAXNG_REF: | |
| case XML_RELAXNG_EXTERNALREF: | |
| case XML_RELAXNG_PARENTREF: | |
| ret = xmlRelaxNGValidateDefinition(ctxt, define->content); | |
| break; | |
| case XML_RELAXNG_DATATYPE:{ | |
| xmlNodePtr child; | |
| xmlChar *content = NULL; | |
| child = node; | |
| while (child != NULL) { | |
| if (child->type == XML_ELEMENT_NODE) { | |
| VALID_ERR2(XML_RELAXNG_ERR_DATAELEM, | |
| node->parent->name); | |
| ret = -1; | |
| break; | |
| } else if ((child->type == XML_TEXT_NODE) || | |
| (child->type == XML_CDATA_SECTION_NODE)) { | |
| content = xmlStrcat(content, child->content); | |
| } | |
| /* TODO: handle entities ... */ | |
| child = child->next; | |
| } | |
| if (ret == -1) { | |
| if (content != NULL) | |
| xmlFree(content); | |
| break; | |
| } | |
| if (content == NULL) { | |
| content = xmlStrdup(BAD_CAST ""); | |
| if (content == NULL) { | |
| xmlRngVErrMemory(ctxt, "validating\n"); | |
| ret = -1; | |
| break; | |
| } | |
| } | |
| ret = xmlRelaxNGValidateDatatype(ctxt, content, define, | |
| ctxt->state->seq); | |
| if (ret == -1) { | |
| VALID_ERR2(XML_RELAXNG_ERR_DATATYPE, define->name); | |
| } else if (ret == 0) { | |
| ctxt->state->seq = NULL; | |
| } | |
| if (content != NULL) | |
| xmlFree(content); | |
| break; | |
| } | |
| case XML_RELAXNG_VALUE:{ | |
| xmlChar *content = NULL; | |
| xmlChar *oldvalue; | |
| xmlNodePtr child; | |
| child = node; | |
| while (child != NULL) { | |
| if (child->type == XML_ELEMENT_NODE) { | |
| VALID_ERR2(XML_RELAXNG_ERR_VALELEM, | |
| node->parent->name); | |
| ret = -1; | |
| break; | |
| } else if ((child->type == XML_TEXT_NODE) || | |
| (child->type == XML_CDATA_SECTION_NODE)) { | |
| content = xmlStrcat(content, child->content); | |
| } | |
| /* TODO: handle entities ... */ | |
| child = child->next; | |
| } | |
| if (ret == -1) { | |
| if (content != NULL) | |
| xmlFree(content); | |
| break; | |
| } | |
| if (content == NULL) { | |
| content = xmlStrdup(BAD_CAST ""); | |
| if (content == NULL) { | |
| xmlRngVErrMemory(ctxt, "validating\n"); | |
| ret = -1; | |
| break; | |
| } | |
| } | |
| oldvalue = ctxt->state->value; | |
| ctxt->state->value = content; | |
| ret = xmlRelaxNGValidateValue(ctxt, define); | |
| ctxt->state->value = oldvalue; | |
| if (ret == -1) { | |
| VALID_ERR2(XML_RELAXNG_ERR_VALUE, define->name); | |
| } else if (ret == 0) { | |
| ctxt->state->seq = NULL; | |
| } | |
| if (content != NULL) | |
| xmlFree(content); | |
| break; | |
| } | |
| case XML_RELAXNG_LIST:{ | |
| xmlChar *content; | |
| xmlNodePtr child; | |
| xmlChar *oldvalue, *oldendvalue; | |
| int len; | |
| /* | |
| * Make sure it's only text nodes | |
| */ | |
| content = NULL; | |
| child = node; | |
| while (child != NULL) { | |
| if (child->type == XML_ELEMENT_NODE) { | |
| VALID_ERR2(XML_RELAXNG_ERR_LISTELEM, | |
| node->parent->name); | |
| ret = -1; | |
| break; | |
| } else if ((child->type == XML_TEXT_NODE) || | |
| (child->type == XML_CDATA_SECTION_NODE)) { | |
| content = xmlStrcat(content, child->content); | |
| } | |
| /* TODO: handle entities ... */ | |
| child = child->next; | |
| } | |
| if (ret == -1) { | |
| if (content != NULL) | |
| xmlFree(content); | |
| break; | |
| } | |
| if (content == NULL) { | |
| content = xmlStrdup(BAD_CAST ""); | |
| if (content == NULL) { | |
| xmlRngVErrMemory(ctxt, "validating\n"); | |
| ret = -1; | |
| break; | |
| } | |
| } | |
| len = xmlStrlen(content); | |
| oldvalue = ctxt->state->value; | |
| oldendvalue = ctxt->state->endvalue; | |
| ctxt->state->value = content; | |
| ctxt->state->endvalue = content + len; | |
| ret = xmlRelaxNGValidateValue(ctxt, define); | |
| ctxt->state->value = oldvalue; | |
| ctxt->state->endvalue = oldendvalue; | |
| if (ret == -1) { | |
| VALID_ERR(XML_RELAXNG_ERR_LIST); | |
| } else if ((ret == 0) && (node != NULL)) { | |
| ctxt->state->seq = node->next; | |
| } | |
| if (content != NULL) | |
| xmlFree(content); | |
| break; | |
| } | |
| case XML_RELAXNG_EXCEPT: | |
| case XML_RELAXNG_PARAM: | |
| TODO ret = -1; | |
| break; | |
| } | |
| ctxt->depth--; | |
| #ifdef DEBUG | |
| for (i = 0; i < ctxt->depth; i++) | |
| xmlGenericError(xmlGenericErrorContext, " "); | |
| xmlGenericError(xmlGenericErrorContext, | |
| "Validating %s ", xmlRelaxNGDefName(define)); | |
| if (define->name != NULL) | |
| xmlGenericError(xmlGenericErrorContext, "%s ", define->name); | |
| if (ret == 0) | |
| xmlGenericError(xmlGenericErrorContext, "suceeded\n"); | |
| else | |
| xmlGenericError(xmlGenericErrorContext, "failed\n"); | |
| #endif | |
| return (ret); | |
| } | |
| /** | |
| * xmlRelaxNGValidateDefinition: | |
| * @ctxt: a Relax-NG validation context | |
| * @define: the definition to verify | |
| * | |
| * Validate the current node lists against the definition | |
| * | |
| * Returns 0 if the validation succeeded or an error code. | |
| */ | |
| static int | |
| xmlRelaxNGValidateDefinition(xmlRelaxNGValidCtxtPtr ctxt, | |
| xmlRelaxNGDefinePtr define) | |
| { | |
| xmlRelaxNGStatesPtr states, res; | |
| int i, j, k, ret, oldflags; | |
| /* | |
| * We should NOT have both ctxt->state and ctxt->states | |
| */ | |
| if ((ctxt->state != NULL) && (ctxt->states != NULL)) { | |
| TODO xmlRelaxNGFreeValidState(ctxt, ctxt->state); | |
| ctxt->state = NULL; | |
| } | |
| if ((ctxt->states == NULL) || (ctxt->states->nbState == 1)) { | |
| if (ctxt->states != NULL) { | |
| ctxt->state = ctxt->states->tabState[0]; | |
| xmlRelaxNGFreeStates(ctxt, ctxt->states); | |
| ctxt->states = NULL; | |
| } | |
| ret = xmlRelaxNGValidateState(ctxt, define); | |
| if ((ctxt->state != NULL) && (ctxt->states != NULL)) { | |
| TODO xmlRelaxNGFreeValidState(ctxt, ctxt->state); | |
| ctxt->state = NULL; | |
| } | |
| if ((ctxt->states != NULL) && (ctxt->states->nbState == 1)) { | |
| ctxt->state = ctxt->states->tabState[0]; | |
| xmlRelaxNGFreeStates(ctxt, ctxt->states); | |
| ctxt->states = NULL; | |
| } | |
| return (ret); | |
| } | |
| states = ctxt->states; | |
| ctxt->states = NULL; | |
| res = NULL; | |
| j = 0; | |
| oldflags = ctxt->flags; | |
| ctxt->flags |= FLAGS_IGNORABLE; | |
| for (i = 0; i < states->nbState; i++) { | |
| ctxt->state = states->tabState[i]; | |
| ctxt->states = NULL; | |
| ret = xmlRelaxNGValidateState(ctxt, define); | |
| /* | |
| * We should NOT have both ctxt->state and ctxt->states | |
| */ | |
| if ((ctxt->state != NULL) && (ctxt->states != NULL)) { | |
| TODO xmlRelaxNGFreeValidState(ctxt, ctxt->state); | |
| ctxt->state = NULL; | |
| } | |
| if (ret == 0) { | |
| if (ctxt->states == NULL) { | |
| if (res != NULL) { | |
| /* add the state to the container */ | |
| xmlRelaxNGAddStates(ctxt, res, ctxt->state); | |
| ctxt->state = NULL; | |
| } else { | |
| /* add the state directly in states */ | |
| states->tabState[j++] = ctxt->state; | |
| ctxt->state = NULL; | |
| } | |
| } else { | |
| if (res == NULL) { | |
| /* make it the new container and copy other results */ | |
| res = ctxt->states; | |
| ctxt->states = NULL; | |
| for (k = 0; k < j; k++) | |
| xmlRelaxNGAddStates(ctxt, res, | |
| states->tabState[k]); | |
| } else { | |
| /* add all the new results to res and reff the container */ | |
| for (k = 0; k < ctxt->states->nbState; k++) | |
| xmlRelaxNGAddStates(ctxt, res, | |
| ctxt->states->tabState[k]); | |
| xmlRelaxNGFreeStates(ctxt, ctxt->states); | |
| ctxt->states = NULL; | |
| } | |
| } | |
| } else { | |
| if (ctxt->state != NULL) { | |
| xmlRelaxNGFreeValidState(ctxt, ctxt->state); | |
| ctxt->state = NULL; | |
| } else if (ctxt->states != NULL) { | |
| for (k = 0; k < ctxt->states->nbState; k++) | |
| xmlRelaxNGFreeValidState(ctxt, | |
| ctxt->states->tabState[k]); | |
| xmlRelaxNGFreeStates(ctxt, ctxt->states); | |
| ctxt->states = NULL; | |
| } | |
| } | |
| } | |
| ctxt->flags = oldflags; | |
| if (res != NULL) { | |
| xmlRelaxNGFreeStates(ctxt, states); | |
| ctxt->states = res; | |
| ret = 0; | |
| } else if (j > 1) { | |
| states->nbState = j; | |
| ctxt->states = states; | |
| ret = 0; | |
| } else if (j == 1) { | |
| ctxt->state = states->tabState[0]; | |
| xmlRelaxNGFreeStates(ctxt, states); | |
| ret = 0; | |
| } else { | |
| ret = -1; | |
| xmlRelaxNGFreeStates(ctxt, states); | |
| if (ctxt->states != NULL) { | |
| xmlRelaxNGFreeStates(ctxt, ctxt->states); | |
| ctxt->states = NULL; | |
| } | |
| } | |
| if ((ctxt->state != NULL) && (ctxt->states != NULL)) { | |
| TODO xmlRelaxNGFreeValidState(ctxt, ctxt->state); | |
| ctxt->state = NULL; | |
| } | |
| return (ret); | |
| } | |
| /** | |
| * xmlRelaxNGValidateDocument: | |
| * @ctxt: a Relax-NG validation context | |
| * @doc: the document | |
| * | |
| * Validate the given document | |
| * | |
| * Returns 0 if the validation succeeded or an error code. | |
| */ | |
| static int | |
| xmlRelaxNGValidateDocument(xmlRelaxNGValidCtxtPtr ctxt, xmlDocPtr doc) | |
| { | |
| int ret; | |
| xmlRelaxNGPtr schema; | |
| xmlRelaxNGGrammarPtr grammar; | |
| xmlRelaxNGValidStatePtr state; | |
| xmlNodePtr node; | |
| if ((ctxt == NULL) || (ctxt->schema == NULL) || (doc == NULL)) | |
| return (-1); | |
| ctxt->errNo = XML_RELAXNG_OK; | |
| schema = ctxt->schema; | |
| grammar = schema->topgrammar; | |
| if (grammar == NULL) { | |
| VALID_ERR(XML_RELAXNG_ERR_NOGRAMMAR); | |
| return (-1); | |
| } | |
| state = xmlRelaxNGNewValidState(ctxt, NULL); | |
| ctxt->state = state; | |
| ret = xmlRelaxNGValidateDefinition(ctxt, grammar->start); | |
| if ((ctxt->state != NULL) && (state->seq != NULL)) { | |
| state = ctxt->state; | |
| node = state->seq; | |
| node = xmlRelaxNGSkipIgnored(ctxt, node); | |
| if (node != NULL) { | |
| if (ret != -1) { | |
| VALID_ERR(XML_RELAXNG_ERR_EXTRADATA); | |
| ret = -1; | |
| } | |
| } | |
| } else if (ctxt->states != NULL) { | |
| int i; | |
| int tmp = -1; | |
| for (i = 0; i < ctxt->states->nbState; i++) { | |
| state = ctxt->states->tabState[i]; | |
| node = state->seq; | |
| node = xmlRelaxNGSkipIgnored(ctxt, node); | |
| if (node == NULL) | |
| tmp = 0; | |
| xmlRelaxNGFreeValidState(ctxt, state); | |
| } | |
| if (tmp == -1) { | |
| if (ret != -1) { | |
| VALID_ERR(XML_RELAXNG_ERR_EXTRADATA); | |
| ret = -1; | |
| } | |
| } | |
| } | |
| if (ctxt->state != NULL) { | |
| xmlRelaxNGFreeValidState(ctxt, ctxt->state); | |
| ctxt->state = NULL; | |
| } | |
| if (ret != 0) | |
| xmlRelaxNGDumpValidError(ctxt); | |
| #ifdef DEBUG | |
| else if (ctxt->errNr != 0) { | |
| ctxt->error(ctxt->userData, | |
| "%d Extra error messages left on stack !\n", | |
| ctxt->errNr); | |
| xmlRelaxNGDumpValidError(ctxt); | |
| } | |
| #endif | |
| #ifdef LIBXML_VALID_ENABLED | |
| if (ctxt->idref == 1) { | |
| xmlValidCtxt vctxt; | |
| memset(&vctxt, 0, sizeof(xmlValidCtxt)); | |
| vctxt.valid = 1; | |
| vctxt.error = ctxt->error; | |
| vctxt.warning = ctxt->warning; | |
| vctxt.userData = ctxt->userData; | |
| if (xmlValidateDocumentFinal(&vctxt, doc) != 1) | |
| ret = -1; | |
| } | |
| #endif /* LIBXML_VALID_ENABLED */ | |
| if ((ret == 0) && (ctxt->errNo != XML_RELAXNG_OK)) | |
| ret = -1; | |
| return (ret); | |
| } | |
| /** | |
| * xmlRelaxNGCleanPSVI: | |
| * @node: an input element or document | |
| * | |
| * Call this routine to speed up XPath computation on static documents. | |
| * This stamps all the element nodes with the document order | |
| * Like for line information, the order is kept in the element->content | |
| * field, the value stored is actually - the node number (starting at -1) | |
| * to be able to differentiate from line numbers. | |
| * | |
| * Returns the number of elements found in the document or -1 in case | |
| * of error. | |
| */ | |
| static void | |
| xmlRelaxNGCleanPSVI(xmlNodePtr node) { | |
| xmlNodePtr cur; | |
| if ((node == NULL) || | |
| ((node->type != XML_ELEMENT_NODE) && | |
| (node->type != XML_DOCUMENT_NODE) && | |
| (node->type != XML_HTML_DOCUMENT_NODE))) | |
| return; | |
| if (node->type == XML_ELEMENT_NODE) | |
| node->psvi = NULL; | |
| cur = node->children; | |
| while (cur != NULL) { | |
| if (cur->type == XML_ELEMENT_NODE) { | |
| cur->psvi = NULL; | |
| if (cur->children != NULL) { | |
| cur = cur->children; | |
| continue; | |
| } | |
| } | |
| if (cur->next != NULL) { | |
| cur = cur->next; | |
| continue; | |
| } | |
| do { | |
| cur = cur->parent; | |
| if (cur == NULL) | |
| break; | |
| if (cur == node) { | |
| cur = NULL; | |
| break; | |
| } | |
| if (cur->next != NULL) { | |
| cur = cur->next; | |
| break; | |
| } | |
| } while (cur != NULL); | |
| } | |
| return; | |
| } | |
| /************************************************************************ | |
| * * | |
| * Validation interfaces * | |
| * * | |
| ************************************************************************/ | |
| /** | |
| * xmlRelaxNGNewValidCtxt: | |
| * @schema: a precompiled XML RelaxNGs | |
| * | |
| * Create an XML RelaxNGs validation context based on the given schema | |
| * | |
| * Returns the validation context or NULL in case of error | |
| */ | |
| xmlRelaxNGValidCtxtPtr | |
| xmlRelaxNGNewValidCtxt(xmlRelaxNGPtr schema) | |
| { | |
| xmlRelaxNGValidCtxtPtr ret; | |
| ret = (xmlRelaxNGValidCtxtPtr) xmlMalloc(sizeof(xmlRelaxNGValidCtxt)); | |
| if (ret == NULL) { | |
| xmlRngVErrMemory(NULL, "building context\n"); | |
| return (NULL); | |
| } | |
| memset(ret, 0, sizeof(xmlRelaxNGValidCtxt)); | |
| ret->schema = schema; | |
| ret->error = xmlGenericError; | |
| ret->userData = xmlGenericErrorContext; | |
| ret->errNr = 0; | |
| ret->errMax = 0; | |
| ret->err = NULL; | |
| ret->errTab = NULL; | |
| if (schema != NULL) | |
| ret->idref = schema->idref; | |
| ret->states = NULL; | |
| ret->freeState = NULL; | |
| ret->freeStates = NULL; | |
| ret->errNo = XML_RELAXNG_OK; | |
| return (ret); | |
| } | |
| /** | |
| * xmlRelaxNGFreeValidCtxt: | |
| * @ctxt: the schema validation context | |
| * | |
| * Free the resources associated to the schema validation context | |
| */ | |
| void | |
| xmlRelaxNGFreeValidCtxt(xmlRelaxNGValidCtxtPtr ctxt) | |
| { | |
| int k; | |
| if (ctxt == NULL) | |
| return; | |
| if (ctxt->states != NULL) | |
| xmlRelaxNGFreeStates(NULL, ctxt->states); | |
| if (ctxt->freeState != NULL) { | |
| for (k = 0; k < ctxt->freeState->nbState; k++) { | |
| xmlRelaxNGFreeValidState(NULL, ctxt->freeState->tabState[k]); | |
| } | |
| xmlRelaxNGFreeStates(NULL, ctxt->freeState); | |
| } | |
| if (ctxt->freeStates != NULL) { | |
| for (k = 0; k < ctxt->freeStatesNr; k++) { | |
| xmlRelaxNGFreeStates(NULL, ctxt->freeStates[k]); | |
| } | |
| xmlFree(ctxt->freeStates); | |
| } | |
| if (ctxt->errTab != NULL) | |
| xmlFree(ctxt->errTab); | |
| if (ctxt->elemTab != NULL) { | |
| xmlRegExecCtxtPtr exec; | |
| exec = xmlRelaxNGElemPop(ctxt); | |
| while (exec != NULL) { | |
| xmlRegFreeExecCtxt(exec); | |
| exec = xmlRelaxNGElemPop(ctxt); | |
| } | |
| xmlFree(ctxt->elemTab); | |
| } | |
| xmlFree(ctxt); | |
| } | |
| /** | |
| * xmlRelaxNGSetValidErrors: | |
| * @ctxt: a Relax-NG validation context | |
| * @err: the error function | |
| * @warn: the warning function | |
| * @ctx: the functions context | |
| * | |
| * Set the error and warning callback informations | |
| */ | |
| void | |
| xmlRelaxNGSetValidErrors(xmlRelaxNGValidCtxtPtr ctxt, | |
| xmlRelaxNGValidityErrorFunc err, | |
| xmlRelaxNGValidityWarningFunc warn, void *ctx) | |
| { | |
| if (ctxt == NULL) | |
| return; | |
| ctxt->error = err; | |
| ctxt->warning = warn; | |
| ctxt->userData = ctx; | |
| ctxt->serror = NULL; | |
| } | |
| /** | |
| * xmlRelaxNGSetValidStructuredErrors: | |
| * @ctxt: a Relax-NG validation context | |
| * @serror: the structured error function | |
| * @ctx: the functions context | |
| * | |
| * Set the structured error callback | |
| */ | |
| void | |
| xmlRelaxNGSetValidStructuredErrors(xmlRelaxNGValidCtxtPtr ctxt, | |
| xmlStructuredErrorFunc serror, void *ctx) | |
| { | |
| if (ctxt == NULL) | |
| return; | |
| ctxt->serror = serror; | |
| ctxt->error = NULL; | |
| ctxt->warning = NULL; | |
| ctxt->userData = ctx; | |
| } | |
| /** | |
| * xmlRelaxNGGetValidErrors: | |
| * @ctxt: a Relax-NG validation context | |
| * @err: the error function result | |
| * @warn: the warning function result | |
| * @ctx: the functions context result | |
| * | |
| * Get the error and warning callback informations | |
| * | |
| * Returns -1 in case of error and 0 otherwise | |
| */ | |
| int | |
| xmlRelaxNGGetValidErrors(xmlRelaxNGValidCtxtPtr ctxt, | |
| xmlRelaxNGValidityErrorFunc * err, | |
| xmlRelaxNGValidityWarningFunc * warn, void **ctx) | |
| { | |
| if (ctxt == NULL) | |
| return (-1); | |
| if (err != NULL) | |
| *err = ctxt->error; | |
| if (warn != NULL) | |
| *warn = ctxt->warning; | |
| if (ctx != NULL) | |
| *ctx = ctxt->userData; | |
| return (0); | |
| } | |
| /** | |
| * xmlRelaxNGValidateDoc: | |
| * @ctxt: a Relax-NG validation context | |
| * @doc: a parsed document tree | |
| * | |
| * Validate a document tree in memory. | |
| * | |
| * Returns 0 if the document is valid, a positive error code | |
| * number otherwise and -1 in case of internal or API error. | |
| */ | |
| int | |
| xmlRelaxNGValidateDoc(xmlRelaxNGValidCtxtPtr ctxt, xmlDocPtr doc) | |
| { | |
| int ret; | |
| if ((ctxt == NULL) || (doc == NULL)) | |
| return (-1); | |
| ctxt->doc = doc; | |
| ret = xmlRelaxNGValidateDocument(ctxt, doc); | |
| /* | |
| * Remove all left PSVI | |
| */ | |
| xmlRelaxNGCleanPSVI((xmlNodePtr) doc); | |
| /* | |
| * TODO: build error codes | |
| */ | |
| if (ret == -1) | |
| return (1); | |
| return (ret); | |
| } | |
| #define bottom_relaxng | |
| #include "elfgcchack.h" | |
| #endif /* LIBXML_SCHEMAS_ENABLED */ |