switched Relax-NG module to teh new error reporting. Better default
* error.c relaxng.c include/libxml/xmlerror.h: switched Relax-NG
module to teh new error reporting. Better default report, adds
the element associated if found, context and node are included
in the xmlError
* python/tests/reader2.py: the error messages changed.
* result/relaxng/*: error message changed too.
Daniel
diff --git a/relaxng.c b/relaxng.c
index ad15718..3cac364 100644
--- a/relaxng.c
+++ b/relaxng.c
@@ -46,15 +46,25 @@
/* #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 */
+
/* #define DEBUG_ERROR 1 */
+
/* #define DEBUG_COMPILE 1 */
+
/* #define DEBUG_PROGRESSIVE 1 */
#define MAX_ERROR 5
@@ -77,9 +87,9 @@
typedef xmlRelaxNGInclude *xmlRelaxNGIncludePtr;
typedef enum {
- XML_RELAXNG_COMBINE_UNDEFINED = 0, /* undefined */
- XML_RELAXNG_COMBINE_CHOICE, /* choice */
- XML_RELAXNG_COMBINE_INTERLEAVE /* interleave */
+ XML_RELAXNG_COMBINE_UNDEFINED = 0, /* undefined */
+ XML_RELAXNG_COMBINE_CHOICE, /* choice */
+ XML_RELAXNG_COMBINE_INTERLEAVE /* interleave */
} xmlRelaxNGCombine;
typedef enum {
@@ -93,40 +103,40 @@
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 */
+ 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_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 */
+ 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)
@@ -139,21 +149,21 @@
#define IS_NOT_COMPILABLE (1 << 7)
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 */
+ 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 */
};
/**
@@ -162,18 +172,18 @@
* A RelaxNGs definition
*/
struct _xmlRelaxNG {
- void *_private; /* unused by the library for users or bindings */
+ void *_private; /* unused by the library for users or bindings */
xmlRelaxNGGrammarPtr topgrammar;
xmlDocPtr doc;
- int idref; /* requires idref checking */
+ 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 */
+ 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 */
};
@@ -189,52 +199,52 @@
#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 */
+ void *userData; /* user specific data block */
+ xmlRelaxNGValidityErrorFunc error; /* the callback in case of errors */
+ xmlRelaxNGValidityWarningFunc warning; /* the callback in case of warning */
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 */
+ 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 */
+ 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;
+ 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 */
+ int defNr; /* number of defines used */
+ int defMax; /* number of defines aloocated */
+ xmlRelaxNGDefinePtr *defTab; /* pointer to the allocated definitions */
- const char *buffer;
- int size;
+ 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 */
+ 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 */
+ 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 */
+ int idref; /* requires idref checking */
/* used to compile content models */
- xmlAutomataPtr am; /* the automata */
- xmlAutomataStatePtr state; /* used to build the automata */
+ xmlAutomataPtr am; /* the automata */
+ xmlAutomataStatePtr state; /* used to build the automata */
};
#define FLAGS_IGNORABLE 1
@@ -249,13 +259,14 @@
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 */
+ 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:
*
@@ -264,10 +275,10 @@
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 ? */
+ 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;
};
@@ -280,14 +291,14 @@
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 */
+ 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 */
};
/**
@@ -298,12 +309,13 @@
typedef struct _xmlRelaxNGStates xmlRelaxNGStates;
typedef xmlRelaxNGStates *xmlRelaxNGStatesPtr;
struct _xmlRelaxNGStates {
- int nbState; /* the number of states */
- int maxState; /* the size of the array */
+ int nbState; /* the number of states */
+ int maxState; /* the size of the array */
xmlRelaxNGValidStatePtr *tabState;
};
#define ERROR_IS_DUP 1
+
/**
* xmlRelaxNGValidError:
*
@@ -312,12 +324,12 @@
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 */
+ 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 */
};
/**
@@ -327,46 +339,47 @@
*/
struct _xmlRelaxNGValidCtxt {
- void *userData; /* user specific data block */
- xmlRelaxNGValidityErrorFunc error; /* the callback in case of errors */
- xmlRelaxNGValidityWarningFunc warning;/* the callback in case of warning */
+ void *userData; /* user specific data block */
+ xmlRelaxNGValidityErrorFunc error; /* the callback in case of errors */
+ xmlRelaxNGValidityWarningFunc warning; /* the callback in case of warning */
+ 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 */
+ 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 */
+ 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 */
+ 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 */
+ 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 */
+ 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 */
};
/**
@@ -375,11 +388,11 @@
* 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 */
+ 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 */
};
/**
@@ -389,18 +402,147 @@
*/
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 */
+ xmlChar *href; /* the normalized href value */
+ xmlDocPtr doc; /* the associated XML document */
+ xmlRelaxNGDefinePtr content; /* the definitions */
+ xmlRelaxNGPtr schema; /* the schema */
};
/************************************************************************
+ * *
+ * 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)
+{
+ xmlGenericErrorFunc channel = NULL;
+ void *data = NULL;
+
+ if (ctxt != NULL) {
+ channel = ctxt->error;
+ data = ctxt->userData;
+ ctxt->nbErrors++;
+ }
+ if (extra)
+ __xmlRaiseError(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(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)
+{
+ xmlGenericErrorFunc channel = NULL;
+ void *data = NULL;
+
+ if (ctxt != NULL) {
+ channel = ctxt->error;
+ data = ctxt->userData;
+ ctxt->nbErrors++;
+ }
+ if (extra)
+ __xmlRaiseError(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(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
+xmlRngPErr(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node, int error,
+ const char *msg, const xmlChar * str1, const xmlChar * str2)
+{
+ xmlGenericErrorFunc channel = NULL;
+ void *data = NULL;
+
+ if (ctxt != NULL) {
+ channel = ctxt->error;
+ data = ctxt->userData;
+ ctxt->nbErrors++;
+ }
+ __xmlRaiseError(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
+xmlRngVErr(xmlRelaxNGValidCtxtPtr ctxt, xmlNodePtr node, int error,
+ const char *msg, const xmlChar * str1, const xmlChar * str2)
+{
+ xmlGenericErrorFunc channel = NULL;
+ void *data = NULL;
+
+ if (ctxt != NULL) {
+ channel = ctxt->error;
+ data = ctxt->userData;
+ ctxt->nbErrors++;
+ }
+ __xmlRaiseError(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
@@ -411,7 +553,7 @@
*
* Returns 1 if yes, 0 if no and -1 in case of error.
*/
-typedef int (*xmlRelaxNGTypeHave) (void *data, const xmlChar *type);
+typedef int (*xmlRelaxNGTypeHave) (void *data, const xmlChar * type);
/**
* xmlRelaxNGTypeCheck:
@@ -424,9 +566,9 @@
*
* 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);
+typedef int (*xmlRelaxNGTypeCheck) (void *data, const xmlChar * type,
+ const xmlChar * value, void **result,
+ xmlNodePtr node);
/**
* xmlRelaxNGFacetCheck:
@@ -441,9 +583,10 @@
*
* 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);
+typedef int (*xmlRelaxNGFacetCheck) (void *data, const xmlChar * type,
+ const xmlChar * facet,
+ const xmlChar * val,
+ const xmlChar * strval, void *value);
/**
* xmlRelaxNGTypeFree:
@@ -466,22 +609,22 @@
*
* 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 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 */
+ 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 */
};
/************************************************************************
@@ -491,14 +634,14 @@
************************************************************************/
static void xmlRelaxNGFreeGrammar(xmlRelaxNGGrammarPtr grammar);
static void xmlRelaxNGFreeDefine(xmlRelaxNGDefinePtr define);
-static void xmlRelaxNGNormExtSpace(xmlChar *value);
+static void xmlRelaxNGNormExtSpace(xmlChar * value);
static void xmlRelaxNGFreeInnerSchema(xmlRelaxNGPtr schema);
-static int xmlRelaxNGEqualValidState(
- xmlRelaxNGValidCtxtPtr ctxt ATTRIBUTE_UNUSED,
- xmlRelaxNGValidStatePtr state1,
- xmlRelaxNGValidStatePtr state2);
+static int xmlRelaxNGEqualValidState(xmlRelaxNGValidCtxtPtr ctxt
+ ATTRIBUTE_UNUSED,
+ xmlRelaxNGValidStatePtr state1,
+ xmlRelaxNGValidStatePtr state2);
static void xmlRelaxNGFreeValidState(xmlRelaxNGValidCtxtPtr ctxt,
- xmlRelaxNGValidStatePtr state);
+ xmlRelaxNGValidStatePtr state);
/**
* xmlRelaxNGFreeDocument:
@@ -513,11 +656,11 @@
return;
if (docu->href != NULL)
- xmlFree(docu->href);
+ xmlFree(docu->href);
if (docu->doc != NULL)
- xmlFreeDoc(docu->doc);
+ xmlFreeDoc(docu->doc);
if (docu->schema != NULL)
- xmlRelaxNGFreeInnerSchema(docu->schema);
+ xmlRelaxNGFreeInnerSchema(docu->schema);
xmlFree(docu);
}
@@ -531,10 +674,11 @@
xmlRelaxNGFreeDocumentList(xmlRelaxNGDocumentPtr docu)
{
xmlRelaxNGDocumentPtr next;
+
while (docu != NULL) {
- next = docu->next;
- xmlRelaxNGFreeDocument(docu);
- docu = next;
+ next = docu->next;
+ xmlRelaxNGFreeDocument(docu);
+ docu = next;
}
}
@@ -551,11 +695,11 @@
return;
if (incl->href != NULL)
- xmlFree(incl->href);
+ xmlFree(incl->href);
if (incl->doc != NULL)
- xmlFreeDoc(incl->doc);
+ xmlFreeDoc(incl->doc);
if (incl->schema != NULL)
- xmlRelaxNGFree(incl->schema);
+ xmlRelaxNGFree(incl->schema);
xmlFree(incl);
}
@@ -569,10 +713,11 @@
xmlRelaxNGFreeIncludeList(xmlRelaxNGIncludePtr incl)
{
xmlRelaxNGIncludePtr next;
+
while (incl != NULL) {
- next = incl->next;
- xmlRelaxNGFreeInclude(incl);
- incl = next;
+ next = incl->next;
+ xmlRelaxNGFreeInclude(incl);
+ incl = next;
}
}
@@ -591,9 +736,7 @@
ret = (xmlRelaxNGPtr) xmlMalloc(sizeof(xmlRelaxNG));
if (ret == NULL) {
- if ((ctxt != NULL) && (ctxt->error != NULL))
- ctxt->error(ctxt->userData, "Out of memory\n");
- ctxt->nbErrors++;
+ xmlRngPErrMemory(ctxt, NULL);
return (NULL);
}
memset(ret, 0, sizeof(xmlRelaxNG));
@@ -614,13 +757,13 @@
return;
if (schema->doc != NULL)
- xmlFreeDoc(schema->doc);
+ xmlFreeDoc(schema->doc);
if (schema->defTab != NULL) {
- int i;
+ int i;
- for (i = 0;i < schema->defNr;i++)
- xmlRelaxNGFreeDefine(schema->defTab[i]);
- xmlFree(schema->defTab);
+ for (i = 0; i < schema->defNr; i++)
+ xmlRelaxNGFreeDefine(schema->defTab[i]);
+ xmlFree(schema->defTab);
}
xmlFree(schema);
@@ -639,19 +782,19 @@
return;
if (schema->topgrammar != NULL)
- xmlRelaxNGFreeGrammar(schema->topgrammar);
+ xmlRelaxNGFreeGrammar(schema->topgrammar);
if (schema->doc != NULL)
- xmlFreeDoc(schema->doc);
+ xmlFreeDoc(schema->doc);
if (schema->documents != NULL)
- xmlRelaxNGFreeDocumentList(schema->documents);
+ xmlRelaxNGFreeDocumentList(schema->documents);
if (schema->includes != NULL)
- xmlRelaxNGFreeIncludeList(schema->includes);
+ xmlRelaxNGFreeIncludeList(schema->includes);
if (schema->defTab != NULL) {
- int i;
+ int i;
- for (i = 0;i < schema->defNr;i++)
- xmlRelaxNGFreeDefine(schema->defTab[i]);
- xmlFree(schema->defTab);
+ for (i = 0; i < schema->defNr; i++)
+ xmlRelaxNGFreeDefine(schema->defTab[i]);
+ xmlFree(schema->defTab);
}
xmlFree(schema);
@@ -672,9 +815,7 @@
ret = (xmlRelaxNGGrammarPtr) xmlMalloc(sizeof(xmlRelaxNGGrammar));
if (ret == NULL) {
- if ((ctxt != NULL) && (ctxt->error != NULL))
- ctxt->error(ctxt->userData, "Out of memory\n");
- ctxt->nbErrors++;
+ xmlRngPErrMemory(ctxt, NULL);
return (NULL);
}
memset(ret, 0, sizeof(xmlRelaxNGGrammar));
@@ -695,16 +836,16 @@
return;
if (grammar->children != NULL) {
- xmlRelaxNGFreeGrammar(grammar->children);
+ xmlRelaxNGFreeGrammar(grammar->children);
}
if (grammar->next != NULL) {
- xmlRelaxNGFreeGrammar(grammar->next);
+ xmlRelaxNGFreeGrammar(grammar->next);
}
if (grammar->refs != NULL) {
- xmlHashFree(grammar->refs, NULL);
+ xmlHashFree(grammar->refs, NULL);
}
if (grammar->defs != NULL) {
- xmlHashFree(grammar->defs, NULL);
+ xmlHashFree(grammar->defs, NULL);
}
xmlFree(grammar);
@@ -725,35 +866,32 @@
xmlRelaxNGDefinePtr ret;
if (ctxt->defMax == 0) {
- ctxt->defMax = 16;
- ctxt->defNr = 0;
- ctxt->defTab = (xmlRelaxNGDefinePtr *)
- xmlMalloc(ctxt->defMax * sizeof(xmlRelaxNGDefinePtr));
- if (ctxt->defTab == NULL) {
- if ((ctxt != NULL) && (ctxt->error != NULL))
- ctxt->error(ctxt->userData, "Out of memory\n");
- ctxt->nbErrors++;
- return (NULL);
- }
+ 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) {
- if ((ctxt != NULL) && (ctxt->error != NULL))
- ctxt->error(ctxt->userData, "Out of memory\n");
- ctxt->nbErrors++;
- return (NULL);
- }
- ctxt->defTab = tmp;
+ 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) {
- if ((ctxt != NULL) && (ctxt->error != NULL))
- ctxt->error(ctxt->userData, "Out of memory\n");
- ctxt->nbErrors++;
- return(NULL);
+ xmlRngPErrMemory(ctxt, "allocating define\n");
+ return (NULL);
}
memset(ret, 0, sizeof(xmlRelaxNGDefine));
ctxt->defTab[ctxt->defNr++] = ret;
@@ -769,30 +907,32 @@
* Deallocate RelaxNG partition set structures.
*/
static void
-xmlRelaxNGFreePartition(xmlRelaxNGPartitionPtr partitions) {
+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);
+ 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
@@ -805,26 +945,23 @@
if (define == NULL)
return;
- if ((define->type == XML_RELAXNG_VALUE) &&
- (define->attrs != NULL)) {
- xmlRelaxNGTypeLibraryPtr lib;
+ 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);
+ 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->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);
+ xmlFree(define->name);
if (define->ns != NULL)
- xmlFree(define->ns);
+ xmlFree(define->ns);
if (define->value != NULL)
- xmlFree(define->value);
+ xmlFree(define->value);
if (define->contModel != NULL)
xmlRegFreeRegexp(define->contModel);
xmlFree(define);
@@ -845,33 +982,34 @@
xmlRelaxNGStatesPtr ret;
if ((ctxt != NULL) &&
- (ctxt->freeState != NULL) &&
- (ctxt->freeStatesNr > 0)) {
- ctxt->freeStatesNr--;
- ret = ctxt->freeStates[ctxt->freeStatesNr];
- ret->nbState = 0;
- return(ret);
+ (ctxt->freeState != NULL) && (ctxt->freeStatesNr > 0)) {
+ ctxt->freeStatesNr--;
+ ret = ctxt->freeStates[ctxt->freeStatesNr];
+ ret->nbState = 0;
+ return (ret);
}
- if (size < 16) size = 16;
+ if (size < 16)
+ size = 16;
ret = (xmlRelaxNGStatesPtr) xmlMalloc(sizeof(xmlRelaxNGStates) +
- (size - 1) * sizeof(xmlRelaxNGValidStatePtr));
+ (size -
+ 1) *
+ sizeof(xmlRelaxNGValidStatePtr));
if (ret == NULL) {
- if ((ctxt != NULL) && (ctxt->error != NULL))
- ctxt->error(ctxt->userData, "Out of memory\n");
+ xmlRngVErrMemory(ctxt, "allocating states\n");
return (NULL);
}
ret->nbState = 0;
ret->maxState = size;
- ret->tabState = (xmlRelaxNGValidStatePtr *) xmlMalloc(
- (size) * sizeof(xmlRelaxNGValidStatePtr));
+ ret->tabState = (xmlRelaxNGValidStatePtr *) xmlMalloc((size) *
+ sizeof
+ (xmlRelaxNGValidStatePtr));
if (ret->tabState == NULL) {
- if ((ctxt != NULL) && (ctxt->error != NULL))
- ctxt->error(ctxt->userData, "Out of memory\n");
- xmlFree(ret->tabState);
+ xmlRngVErrMemory(ctxt, "allocating states\n");
+ xmlFree(ret);
return (NULL);
}
- return(ret);
+ return (ret);
}
/**
@@ -887,29 +1025,30 @@
*/
static int
xmlRelaxNGAddStatesUniq(xmlRelaxNGValidCtxtPtr ctxt,
- xmlRelaxNGStatesPtr states,
- xmlRelaxNGValidStatePtr state)
+ xmlRelaxNGStatesPtr states,
+ xmlRelaxNGValidStatePtr state)
{
if (state == NULL) {
- return(-1);
+ return (-1);
}
if (states->nbState >= states->maxState) {
- xmlRelaxNGValidStatePtr *tmp;
- int size;
+ xmlRelaxNGValidStatePtr *tmp;
+ int size;
- size = states->maxState * 2;
- tmp = (xmlRelaxNGValidStatePtr *) xmlRealloc(states->tabState,
- (size) * sizeof(xmlRelaxNGValidStatePtr));
+ size = states->maxState * 2;
+ tmp = (xmlRelaxNGValidStatePtr *) xmlRealloc(states->tabState,
+ (size) *
+ sizeof
+ (xmlRelaxNGValidStatePtr));
if (tmp == NULL) {
- if ((ctxt != NULL) && (ctxt->error != NULL))
- ctxt->error(ctxt->userData, "Out of memory\n");
- return(-1);
- }
- states->tabState = tmp;
- states->maxState = size;
+ xmlRngVErrMemory(ctxt, "adding states\n");
+ return (-1);
+ }
+ states->tabState = tmp;
+ states->maxState = size;
}
states->tabState[states->nbState++] = state;
- return(1);
+ return (1);
}
/**
@@ -923,37 +1062,39 @@
* 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)
+xmlRelaxNGAddStates(xmlRelaxNGValidCtxtPtr ctxt,
+ xmlRelaxNGStatesPtr states,
+ xmlRelaxNGValidStatePtr state)
{
int i;
if (state == NULL) {
- return(-1);
+ return (-1);
}
if (states->nbState >= states->maxState) {
- xmlRelaxNGValidStatePtr *tmp;
- int size;
+ xmlRelaxNGValidStatePtr *tmp;
+ int size;
- size = states->maxState * 2;
- tmp = (xmlRelaxNGValidStatePtr *) xmlRealloc(states->tabState,
- (size) * sizeof(xmlRelaxNGValidStatePtr));
+ size = states->maxState * 2;
+ tmp = (xmlRelaxNGValidStatePtr *) xmlRealloc(states->tabState,
+ (size) *
+ sizeof
+ (xmlRelaxNGValidStatePtr));
if (tmp == NULL) {
- if ((ctxt != NULL) && (ctxt->error != NULL))
- ctxt->error(ctxt->userData, "Out of memory\n");
- return(-1);
- }
- states->tabState = tmp;
- states->maxState = size;
+ 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);
- }
+ 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);
+ return (1);
}
/**
@@ -965,39 +1106,40 @@
*/
static void
xmlRelaxNGFreeStates(xmlRelaxNGValidCtxtPtr ctxt,
- xmlRelaxNGStatesPtr states)
+ xmlRelaxNGStatesPtr states)
{
if (states == NULL)
- return;
+ 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) {
- if ((ctxt != NULL) && (ctxt->error != NULL))
- ctxt->error(ctxt->userData, "Out of memory\n");
- }
- } else if ((ctxt != NULL) && (ctxt->freeStatesNr >= ctxt->freeStatesMax)) {
- xmlRelaxNGStatesPtr *tmp;
+ 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) {
- if ((ctxt != NULL) && (ctxt->error != NULL))
- ctxt->error(ctxt->userData, "Out of memory\n");
- xmlFree(states->tabState);
- xmlFree(states);
- return;
- }
- ctxt->freeStates = tmp;
- ctxt->freeStatesMax *= 2;
+ 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->freeState == NULL)) {
- xmlFree(states->tabState);
- xmlFree(states);
+ xmlFree(states->tabState);
+ xmlFree(states);
} else {
- ctxt->freeStates[ctxt->freeStatesNr++] = states;
+ ctxt->freeStates[ctxt->freeStatesNr++] = states;
}
}
@@ -1020,77 +1162,77 @@
xmlNodePtr root = NULL;
if (node == NULL) {
- root = xmlDocGetRootElement(ctxt->doc);
- if (root == NULL)
- return(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;
- }
+ 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];
+ 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) {
- if ((ctxt != NULL) && (ctxt->error != NULL))
- ctxt->error(ctxt->userData, "Out of memory\n");
- return (NULL);
- }
- memset(ret, 0, sizeof(xmlRelaxNGValidState));
+ 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;
+ ret->node = (xmlNodePtr) ctxt->doc;
+ ret->seq = root;
} else {
- ret->node = node;
- ret->seq = node->children;
+ 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) {
- if ((ctxt != NULL) && (ctxt->error != NULL))
- ctxt->error(ctxt->userData, "Out of memory\n");
- return (ret);
- }
- } else if (ret->maxAttrs < nbAttrs) {
- xmlAttrPtr *tmp;
+ 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) {
- if ((ctxt != NULL) && (ctxt->error != NULL))
- ctxt->error(ctxt->userData, "Out of memory\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;
- }
- }
+ 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);
@@ -1107,26 +1249,26 @@
*/
static xmlRelaxNGValidStatePtr
xmlRelaxNGCopyValidState(xmlRelaxNGValidCtxtPtr ctxt,
- xmlRelaxNGValidStatePtr state)
+ 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];
+ 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) {
- if ((ctxt != NULL) && (ctxt->error != NULL))
- ctxt->error(ctxt->userData, "Out of memory\n");
- return (NULL);
- }
- memset(ret, 0, sizeof(xmlRelaxNGValidState));
+ 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;
@@ -1134,33 +1276,32 @@
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) {
- if ((ctxt != NULL) && (ctxt->error != NULL))
- ctxt->error(ctxt->userData, "Out of memory\n");
- ret->nbAttrs = 0;
- return (ret);
- }
- } else if (ret->maxAttrs < state->nbAttrs) {
- xmlAttrPtr *tmp;
+ 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) {
- if ((ctxt != NULL) && (ctxt->error != NULL))
- ctxt->error(ctxt->userData, "Out of memory\n");
- ret->nbAttrs = 0;
- return (ret);
- }
- ret->maxAttrs = state->maxAttrs;
- ret->attrs = tmp;
- }
- memcpy(ret->attrs, state->attrs, state->nbAttrs * sizeof(xmlAttrPtr));
+ 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);
+ return (ret);
}
/**
@@ -1175,33 +1316,33 @@
*/
static int
xmlRelaxNGEqualValidState(xmlRelaxNGValidCtxtPtr ctxt ATTRIBUTE_UNUSED,
- xmlRelaxNGValidStatePtr state1,
- xmlRelaxNGValidStatePtr state2)
+ xmlRelaxNGValidStatePtr state1,
+ xmlRelaxNGValidStatePtr state2)
{
int i;
if ((state1 == NULL) || (state2 == NULL))
- return(0);
+ return (0);
if (state1 == state2)
- return(1);
+ return (1);
if (state1->node != state2->node)
- return(0);
+ return (0);
if (state1->seq != state2->seq)
- return(0);
+ return (0);
if (state1->nbAttrLeft != state2->nbAttrLeft)
- return(0);
+ return (0);
if (state1->nbAttrs != state2->nbAttrs)
- return(0);
+ return (0);
if (state1->endvalue != state2->endvalue)
- return(0);
+ 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);
+ (!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);
+ return (1);
}
/**
@@ -1212,20 +1353,20 @@
*/
static void
xmlRelaxNGFreeValidState(xmlRelaxNGValidCtxtPtr ctxt,
- xmlRelaxNGValidStatePtr state)
+ xmlRelaxNGValidStatePtr state)
{
if (state == NULL)
return;
if ((ctxt != NULL) && (ctxt->freeState == NULL)) {
- ctxt->freeState = xmlRelaxNGNewStates(ctxt, 40);
+ ctxt->freeState = xmlRelaxNGNewStates(ctxt, 40);
}
if ((ctxt == NULL) || (ctxt->freeState == NULL)) {
- if (state->attrs != NULL)
- xmlFree(state->attrs);
- xmlFree(state);
+ if (state->attrs != NULL)
+ xmlFree(state->attrs);
+ xmlFree(state);
} else {
- xmlRelaxNGAddStatesUniq(ctxt, ctxt->freeState, state);
+ xmlRelaxNGAddStatesUniq(ctxt, ctxt->freeState, state);
}
}
@@ -1235,7 +1376,7 @@
* *
************************************************************************/
static xmlDocPtr xmlRelaxNGCleanupDoc(xmlRelaxNGParserCtxtPtr ctxt,
- xmlDocPtr doc);
+ xmlDocPtr doc);
/**
* xmlRelaxNGIncludePush:
@@ -1248,15 +1389,16 @@
*/
static int
xmlRelaxNGIncludePush(xmlRelaxNGParserCtxtPtr ctxt,
- xmlRelaxNGIncludePtr value)
+ xmlRelaxNGIncludePtr value)
{
if (ctxt->incTab == NULL) {
- ctxt->incMax = 4;
- ctxt->incNr = 0;
- ctxt->incTab = (xmlRelaxNGIncludePtr *) xmlMalloc(
- ctxt->incMax * sizeof(ctxt->incTab[0]));
+ ctxt->incMax = 4;
+ ctxt->incNr = 0;
+ ctxt->incTab =
+ (xmlRelaxNGIncludePtr *) xmlMalloc(ctxt->incMax *
+ sizeof(ctxt->incTab[0]));
if (ctxt->incTab == NULL) {
- xmlGenericError(xmlGenericErrorContext, "malloc failed !\n");
+ xmlRngPErrMemory(ctxt, "allocating include\n");
return (0);
}
}
@@ -1264,10 +1406,10 @@
ctxt->incMax *= 2;
ctxt->incTab =
(xmlRelaxNGIncludePtr *) xmlRealloc(ctxt->incTab,
- ctxt->incMax *
- sizeof(ctxt->incTab[0]));
+ ctxt->incMax *
+ sizeof(ctxt->incTab[0]));
if (ctxt->incTab == NULL) {
- xmlGenericError(xmlGenericErrorContext, "realloc failed !\n");
+ xmlRngPErrMemory(ctxt, "allocating include\n");
return (0);
}
}
@@ -1314,61 +1456,65 @@
*/
static int
xmlRelaxNGRemoveRedefine(xmlRelaxNGParserCtxtPtr ctxt,
- const xmlChar *URL ATTRIBUTE_UNUSED,
- xmlNodePtr target, const xmlChar *name) {
+ 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);
+ xmlGenericError(xmlGenericErrorContext,
+ "Elimination of <include> start from %s\n", URL);
else
- xmlGenericError(xmlGenericErrorContext,
- "Elimination of <include> define %s from %s\n", name, URL);
+ 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->_private;
+ 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->_private;
- if ((inc != NULL) && (inc->doc != NULL) &&
- (inc->doc->children != NULL)) {
+ if ((inc != NULL) && (inc->doc != NULL) &&
+ (inc->doc->children != NULL)) {
- if (xmlStrEqual(inc->doc->children->name, BAD_CAST "grammar")) {
+ if (xmlStrEqual
+ (inc->doc->children->name, BAD_CAST "grammar")) {
#ifdef DEBUG_INCLUDE
- href = xmlGetProp(tmp, BAD_CAST "href");
+ href = xmlGetProp(tmp, BAD_CAST "href");
#endif
- if (xmlRelaxNGRemoveRedefine(ctxt, href,
- inc->doc->children->children, name) == 1) {
- found = 1;
- }
- if (href != NULL)
- xmlFree(href);
- }
- }
- }
- tmp = tmp2;
+ if (xmlRelaxNGRemoveRedefine(ctxt, href,
+ inc->doc->children->
+ children, name) == 1) {
+ found = 1;
+ }
+ if (href != NULL)
+ xmlFree(href);
+ }
+ }
+ }
+ tmp = tmp2;
}
- return(found);
+ return (found);
}
/**
@@ -1385,8 +1531,9 @@
* Returns the xmlRelaxNGIncludePtr or NULL in case of error
*/
static xmlRelaxNGIncludePtr
-xmlRelaxNGLoadInclude(xmlRelaxNGParserCtxtPtr ctxt, const xmlChar *URL,
- xmlNodePtr node, const xmlChar *ns) {
+xmlRelaxNGLoadInclude(xmlRelaxNGParserCtxtPtr ctxt, const xmlChar * URL,
+ xmlNodePtr node, const xmlChar * ns)
+{
xmlRelaxNGIncludePtr ret = NULL;
xmlDocPtr doc;
int i;
@@ -1394,21 +1541,19 @@
#ifdef DEBUG_INCLUDE
xmlGenericError(xmlGenericErrorContext,
- "xmlRelaxNGLoadInclude(%s)\n", URL);
+ "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)) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Detected an Include recursion for %s\n",
- URL);
- ctxt->nbErrors++;
- return(NULL);
- }
+ 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);
+ }
}
/*
@@ -1416,16 +1561,12 @@
*/
doc = xmlParseFile((const char *) URL);
if (doc == NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "xmlRelaxNG: could not load %s\n", URL);
- ctxt->nbErrors++;
- return (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);
+ xmlGenericError(xmlGenericErrorContext, "Parsed %s Okay\n", URL);
#endif
/*
@@ -1433,12 +1574,9 @@
*/
ret = (xmlRelaxNGIncludePtr) xmlMalloc(sizeof(xmlRelaxNGInclude));
if (ret == NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "xmlRelaxNG: allocate memory for doc %s\n", URL);
- ctxt->nbErrors++;
- xmlFreeDoc(doc);
- return (NULL);
+ xmlRngPErrMemory(ctxt, "allocating include\n");
+ xmlFreeDoc(doc);
+ return (NULL);
}
memset(ret, 0, sizeof(xmlRelaxNGInclude));
ret->doc = doc;
@@ -1450,12 +1588,12 @@
* 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);
- }
- }
+ root = xmlDocGetRootElement(doc);
+ if (root != NULL) {
+ if (xmlHasProp(root, BAD_CAST "ns") == NULL) {
+ xmlSetProp(root, BAD_CAST "ns", ns);
+ }
+ }
}
/*
@@ -1468,14 +1606,13 @@
* in the include stack.
*/
#ifdef DEBUG_INCLUDE
- xmlGenericError(xmlGenericErrorContext,
- "cleanup of %s\n", URL);
+ xmlGenericError(xmlGenericErrorContext, "cleanup of %s\n", URL);
#endif
doc = xmlRelaxNGCleanupDoc(ctxt, doc);
if (doc == NULL) {
- ctxt->inc = NULL;
- return(NULL);
+ ctxt->inc = NULL;
+ return (NULL);
}
/*
@@ -1484,27 +1621,23 @@
xmlRelaxNGIncludePop(ctxt);
#ifdef DEBUG_INCLUDE
- xmlGenericError(xmlGenericErrorContext,
- "Checking of %s\n", URL);
+ xmlGenericError(xmlGenericErrorContext, "Checking of %s\n", URL);
#endif
/*
* Check that the top element is a grammar
*/
root = xmlDocGetRootElement(doc);
if (root == NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "xmlRelaxNG: included document is empty %s\n", URL);
- ctxt->nbErrors++;
- return (NULL);
+ xmlRngPErr(ctxt, node, XML_RNGP_EMPTY,
+ "xmlRelaxNG: included document is empty %s\n", URL,
+ NULL);
+ return (NULL);
}
if (!IS_RELAXNG(root, "grammar")) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "xmlRelaxNG: included document %s root is not a grammar\n",
- URL);
- ctxt->nbErrors++;
- return (NULL);
+ xmlRngPErr(ctxt, node, XML_RNGP_GRAMMAR_MISSING,
+ "xmlRelaxNG: included document %s root is not a grammar\n",
+ URL, NULL);
+ return (NULL);
}
/*
@@ -1512,48 +1645,43 @@
*/
cur = node->children;
while (cur != NULL) {
- if (IS_RELAXNG(cur, "start")) {
- int found = 0;
+ if (IS_RELAXNG(cur, "start")) {
+ int found = 0;
- found = xmlRelaxNGRemoveRedefine(ctxt, URL, root->children, NULL);
- if (!found) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "xmlRelaxNG: include %s has a start but not the included grammar\n",
- URL);
- ctxt->nbErrors++;
- }
- } else if (IS_RELAXNG(cur, "define")) {
- xmlChar *name;
+ 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "xmlRelaxNG: include %s has define without name\n",
- URL);
- ctxt->nbErrors++;
- } else {
- int found;
+ 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "xmlRelaxNG: include %s has a define %s but not the included grammar\n",
- URL, name);
- ctxt->nbErrors++;
- }
- xmlFree(name);
- }
- }
- cur = cur->next;
+ 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);
+ return (ret);
}
/**
@@ -1569,57 +1697,62 @@
* 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)
+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);
+ "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));
+ ctxt->errMax = 8;
+ ctxt->errNr = 0;
+ ctxt->errTab =
+ (xmlRelaxNGValidErrorPtr) xmlMalloc(ctxt->errMax *
+ sizeof
+ (xmlRelaxNGValidError));
if (ctxt->errTab == NULL) {
- xmlGenericError(xmlGenericErrorContext, "malloc failed !\n");
+ xmlRngVErrMemory(ctxt, "pushing error\n");
return (0);
}
- ctxt->err = NULL;
+ ctxt->err = NULL;
}
if (ctxt->errNr >= ctxt->errMax) {
- ctxt->errMax *= 2;
+ ctxt->errMax *= 2;
ctxt->errTab =
(xmlRelaxNGValidErrorPtr) xmlRealloc(ctxt->errTab,
- ctxt->errMax * sizeof(xmlRelaxNGValidError));
+ ctxt->errMax *
+ sizeof
+ (xmlRelaxNGValidError));
if (ctxt->errTab == NULL) {
- xmlGenericError(xmlGenericErrorContext, "realloc failed !\n");
+ xmlRngVErrMemory(ctxt, "pushing error\n");
return (0);
}
- ctxt->err = &ctxt->errTab[ctxt->errNr - 1];
+ 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);
+ (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;
+ cur->flags = ERROR_IS_DUP;
} else {
cur->arg1 = arg1;
cur->arg2 = arg2;
- cur->flags = 0;
+ cur->flags = 0;
}
if (ctxt->state != NULL) {
- cur->node = ctxt->state->node;
- cur->seq = ctxt->state->seq;
+ cur->node = ctxt->state->node;
+ cur->seq = ctxt->state->seq;
} else {
- cur->node = NULL;
- cur->seq = NULL;
+ cur->node = NULL;
+ cur->seq = NULL;
}
ctxt->err = cur;
return (ctxt->errNr++);
@@ -1637,7 +1770,7 @@
xmlRelaxNGValidErrorPtr cur;
if (ctxt->errNr <= 0) {
- ctxt->err = NULL;
+ ctxt->err = NULL;
return;
}
ctxt->errNr--;
@@ -1647,13 +1780,13 @@
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;
+ 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;
}
}
@@ -1668,15 +1801,16 @@
*/
static int
xmlRelaxNGDocumentPush(xmlRelaxNGParserCtxtPtr ctxt,
- xmlRelaxNGDocumentPtr value)
+ xmlRelaxNGDocumentPtr value)
{
if (ctxt->docTab == NULL) {
- ctxt->docMax = 4;
- ctxt->docNr = 0;
- ctxt->docTab = (xmlRelaxNGDocumentPtr *) xmlMalloc(
- ctxt->docMax * sizeof(ctxt->docTab[0]));
+ ctxt->docMax = 4;
+ ctxt->docNr = 0;
+ ctxt->docTab =
+ (xmlRelaxNGDocumentPtr *) xmlMalloc(ctxt->docMax *
+ sizeof(ctxt->docTab[0]));
if (ctxt->docTab == NULL) {
- xmlGenericError(xmlGenericErrorContext, "malloc failed !\n");
+ xmlRngPErrMemory(ctxt, "adding document\n");
return (0);
}
}
@@ -1684,10 +1818,10 @@
ctxt->docMax *= 2;
ctxt->docTab =
(xmlRelaxNGDocumentPtr *) xmlRealloc(ctxt->docTab,
- ctxt->docMax *
- sizeof(ctxt->docTab[0]));
+ ctxt->docMax *
+ sizeof(ctxt->docTab[0]));
if (ctxt->docTab == NULL) {
- xmlGenericError(xmlGenericErrorContext, "realloc failed !\n");
+ xmlRngPErrMemory(ctxt, "adding document\n");
return (0);
}
}
@@ -1734,8 +1868,9 @@
* Returns the xmlRelaxNGDocumentPtr or NULL in case of error
*/
static xmlRelaxNGDocumentPtr
-xmlRelaxNGLoadExternalRef(xmlRelaxNGParserCtxtPtr ctxt, const xmlChar *URL,
- const xmlChar *ns) {
+xmlRelaxNGLoadExternalRef(xmlRelaxNGParserCtxtPtr ctxt,
+ const xmlChar * URL, const xmlChar * ns)
+{
xmlRelaxNGDocumentPtr ret = NULL;
xmlDocPtr doc;
xmlNodePtr root;
@@ -1744,15 +1879,13 @@
/*
* check against recursion in the stack
*/
- for (i = 0;i < ctxt->docNr;i++) {
- if (xmlStrEqual(ctxt->docTab[i]->href, URL)) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Detected an externalRef recursion for %s\n",
- URL);
- ctxt->nbErrors++;
- return(NULL);
- }
+ 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);
+ }
}
/*
@@ -1760,11 +1893,9 @@
*/
doc = xmlParseFile((const char *) URL);
if (doc == NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "xmlRelaxNG: could not load %s\n", URL);
- ctxt->nbErrors++;
- return (NULL);
+ xmlRngPErr(ctxt, NULL, XML_RNGP_PARSE_ERROR,
+ "xmlRelaxNG: could not load %s\n", URL, NULL);
+ return (NULL);
}
/*
@@ -1772,12 +1903,10 @@
*/
ret = (xmlRelaxNGDocumentPtr) xmlMalloc(sizeof(xmlRelaxNGDocument));
if (ret == NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "xmlRelaxNG: allocate memory for doc %s\n", URL);
- ctxt->nbErrors++;
- xmlFreeDoc(doc);
- return (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;
@@ -1789,12 +1918,12 @@
* 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);
- }
- }
+ root = xmlDocGetRootElement(doc);
+ if (root != NULL) {
+ if (xmlHasProp(root, BAD_CAST "ns") == NULL) {
+ xmlSetProp(root, BAD_CAST "ns", ns);
+ }
+ }
}
/*
@@ -1807,13 +1936,13 @@
*/
doc = xmlRelaxNGCleanupDoc(ctxt, doc);
if (doc == NULL) {
- ctxt->doc = NULL;
- return(NULL);
+ ctxt->doc = NULL;
+ return (NULL);
}
xmlRelaxNGDocumentPop(ctxt);
- return(ret);
+ return (ret);
}
/************************************************************************
@@ -1829,34 +1958,57 @@
#define VALID_ERR3P(a, b, c) xmlRelaxNGAddValidError(ctxt, a, b, c, 1);
static const char *
-xmlRelaxNGDefName(xmlRelaxNGDefinePtr def) {
+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 ("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");
+ return ("unknown");
}
/**
@@ -1870,133 +2022,138 @@
* Returns the error string, it must be deallocated by the caller
*/
static xmlChar *
-xmlRelaxNGGetErrorString(xmlRelaxNGValidErr err, const xmlChar *arg1,
- const xmlChar *arg2) {
+xmlRelaxNGGetErrorString(xmlRelaxNGValidErr err, const xmlChar * arg1,
+ const xmlChar * arg2)
+{
char msg[1000];
if (arg1 == NULL)
- arg1 = BAD_CAST "";
+ arg1 = BAD_CAST "";
if (arg2 == NULL)
- arg2 = BAD_CAST "";
+ arg2 = BAD_CAST "";
msg[0] = 0;
switch (err) {
- case XML_RELAXNG_OK:
- return(NULL);
- case XML_RELAXNG_ERR_MEMORY:
- return(xmlCharStrdup("out of memory"));
+ 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", arg1);
- break;
- case XML_RELAXNG_ERR_TYPEVAL:
- snprintf(msg, 1000, "Type %s doesn't allow value '%s'", arg1, arg2);
- break;
- case XML_RELAXNG_ERR_DUPID:
- snprintf(msg, 1000, "ID %s redefined", arg1);
- break;
- case XML_RELAXNG_ERR_TYPECMP:
- snprintf(msg, 1000, "failed to compare type %s", arg1);
- break;
- case XML_RELAXNG_ERR_NOSTATE:
- return(xmlCharStrdup("Internal error: no state"));
- case XML_RELAXNG_ERR_NODEFINE:
- return(xmlCharStrdup("Internal error: no define"));
- case XML_RELAXNG_ERR_INTERNAL:
- snprintf(msg, 1000, "Internal error: %s", arg1);
- break;
- case XML_RELAXNG_ERR_LISTEXTRA:
- snprintf(msg, 1000, "Extra data in list: %s", arg1);
- break;
- case XML_RELAXNG_ERR_INTERNODATA:
- return(xmlCharStrdup("Internal: interleave block has no data"));
- case XML_RELAXNG_ERR_INTERSEQ:
- return(xmlCharStrdup("Invalid sequence in interleave"));
- case XML_RELAXNG_ERR_INTEREXTRA:
- snprintf(msg, 1000, "Extra element %s in interleave", arg1);
- break;
- case XML_RELAXNG_ERR_ELEMNAME:
- snprintf(msg, 1000, "Expecting element %s, got %s", arg1, arg2);
- break;
- case XML_RELAXNG_ERR_ELEMNONS:
- snprintf(msg, 1000, "Expecting a namespace for element %s", arg1);
- break;
- case XML_RELAXNG_ERR_ELEMWRONGNS:
- snprintf(msg, 1000, "Element %s has wrong namespace: expecting %s",
- arg1, arg2);
- break;
- case XML_RELAXNG_ERR_ELEMWRONG:
- snprintf(msg, 1000, "Did not expect element %s there",
- arg1);
- break;
- case XML_RELAXNG_ERR_TEXTWRONG:
- snprintf(msg, 1000, "Did not expect text in element %s content",
- arg1);
- break;
- case XML_RELAXNG_ERR_ELEMEXTRANS:
- snprintf(msg, 1000, "Expecting no namespace for element %s", arg1);
- break;
- case XML_RELAXNG_ERR_ELEMNOTEMPTY:
- snprintf(msg, 1000, "Expecting element %s to be empty", arg1);
- break;
- case XML_RELAXNG_ERR_NOELEM:
- snprintf(msg, 1000, "Expecting an element %s, got nothing", arg1);
- break;
- case XML_RELAXNG_ERR_NOTELEM:
- return(xmlCharStrdup("Expecting an element got text"));
- case XML_RELAXNG_ERR_ATTRVALID:
- snprintf(msg, 1000, "Element %s failed to validate attributes",
- arg1);
- break;
- case XML_RELAXNG_ERR_CONTENTVALID:
- snprintf(msg, 1000, "Element %s failed to validate content",
- arg1);
- break;
- case XML_RELAXNG_ERR_EXTRACONTENT:
- snprintf(msg, 1000, "Element %s has extra content: %s",
- arg1, arg2);
- break;
- case XML_RELAXNG_ERR_INVALIDATTR:
- snprintf(msg, 1000, "Invalid attribute %s for element %s",
- arg1, arg2);
- break;
- case XML_RELAXNG_ERR_LACKDATA:
- snprintf(msg, 1000, "Datatype element %s contains no data",
- arg1);
- break;
- case XML_RELAXNG_ERR_DATAELEM:
- snprintf(msg, 1000, "Datatype element %s has child elements",
- arg1);
- break;
- case XML_RELAXNG_ERR_VALELEM:
- snprintf(msg, 1000, "Value element %s has child elements",
- arg1);
- break;
- case XML_RELAXNG_ERR_LISTELEM:
- snprintf(msg, 1000, "List element %s has child elements",
- arg1);
- break;
- case XML_RELAXNG_ERR_DATATYPE:
- snprintf(msg, 1000, "Error validating datatype %s",
- arg1);
- break;
- case XML_RELAXNG_ERR_VALUE:
- snprintf(msg, 1000, "Error validating value %s",
- arg1);
- break;
- case XML_RELAXNG_ERR_LIST:
- return(xmlCharStrdup("Error validating list"));
- case XML_RELAXNG_ERR_NOGRAMMAR:
- return(xmlCharStrdup("No top grammar defined"));
- case XML_RELAXNG_ERR_EXTRADATA:
- return(xmlCharStrdup("Extra data in the document"));
- default:
- return(xmlCharStrdup("Unknown error !"));
+ 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", err);
+ snprintf(msg, 1000, "Unknown error code %d\n", err);
}
msg[1000 - 1] = 0;
- return(xmlStrdup((xmlChar *) msg));
+ return (xmlStrdup((xmlChar *) msg));
}
/**
@@ -2009,7 +2166,7 @@
*/
static void
xmlRelaxNGValidErrorContext(xmlRelaxNGValidCtxtPtr ctxt, xmlNodePtr node,
- xmlNodePtr child)
+ xmlNodePtr child)
{
int line = 0;
const xmlChar *file = NULL;
@@ -2017,53 +2174,54 @@
const char *type = "error";
if ((ctxt == NULL) || (ctxt->error == NULL))
- return;
+ return;
if (child != NULL)
- node = child;
+ node = child;
- if (node != NULL) {
- if ((node->type == XML_DOCUMENT_NODE) ||
- (node->type == XML_HTML_DOCUMENT_NODE)) {
- xmlDocPtr doc = (xmlDocPtr) node;
+ if (node != NULL) {
+ if ((node->type == XML_DOCUMENT_NODE) ||
+ (node->type == XML_HTML_DOCUMENT_NODE)) {
+ xmlDocPtr doc = (xmlDocPtr) node;
- file = doc->URL;
- } else {
- /*
- * Try to find contextual informations to report
- */
- if (node->type == XML_ELEMENT_NODE) {
- line = (long) node->content;
- } else if ((node->prev != NULL) &&
- (node->prev->type == XML_ELEMENT_NODE)) {
- line = (long) node->prev->content;
- } else if ((node->parent != NULL) &&
- (node->parent->type == XML_ELEMENT_NODE)) {
- line = (long) node->parent->content;
- }
- if ((node->doc != NULL) && (node->doc->URL != NULL))
- file = node->doc->URL;
- if (node->name != NULL)
- name = node->name;
- }
- }
-
+ file = doc->URL;
+ } else {
+ /*
+ * Try to find contextual informations to report
+ */
+ if (node->type == XML_ELEMENT_NODE) {
+ line = (long) node->content;
+ } else if ((node->prev != NULL) &&
+ (node->prev->type == XML_ELEMENT_NODE)) {
+ line = (long) node->prev->content;
+ } else if ((node->parent != NULL) &&
+ (node->parent->type == XML_ELEMENT_NODE)) {
+ line = (long) node->parent->content;
+ }
+ if ((node->doc != NULL) && (node->doc->URL != NULL))
+ file = node->doc->URL;
+ if (node->name != NULL)
+ name = node->name;
+ }
+ }
+
type = "RNG validity error";
if ((file != NULL) && (line != 0) && (name != NULL))
- ctxt->error(ctxt->userData, "%s: file %s line %d element %s\n",
- type, file, line, name);
+ ctxt->error(ctxt->userData, "%s: file %s line %d element %s\n",
+ type, file, line, name);
else if ((file != NULL) && (name != NULL))
- ctxt->error(ctxt->userData, "%s: file %s element %s\n",
- type, file, name);
+ ctxt->error(ctxt->userData, "%s: file %s element %s\n",
+ type, file, name);
else if ((file != NULL) && (line != 0))
- ctxt->error(ctxt->userData, "%s: file %s line %d\n", type, file, line);
+ ctxt->error(ctxt->userData, "%s: file %s line %d\n", type, file,
+ line);
else if (file != NULL)
- ctxt->error(ctxt->userData, "%s: file %s\n", type, file);
+ ctxt->error(ctxt->userData, "%s: file %s\n", type, file);
else if (name != NULL)
- ctxt->error(ctxt->userData, "%s: element %s\n", type, name);
+ ctxt->error(ctxt->userData, "%s: element %s\n", type, name);
else
- ctxt->error(ctxt->userData, "%s\n", type);
+ ctxt->error(ctxt->userData, "%s\n", type);
}
/**
@@ -2078,9 +2236,10 @@
* Show a validation error.
*/
static void
-xmlRelaxNGShowValidError(xmlRelaxNGValidCtxtPtr ctxt, xmlRelaxNGValidErr err,
- xmlNodePtr node, xmlNodePtr child,
- const xmlChar *arg1, const xmlChar *arg2)
+xmlRelaxNGShowValidError(xmlRelaxNGValidCtxtPtr ctxt,
+ xmlRelaxNGValidErr err, xmlNodePtr node,
+ xmlNodePtr child, const xmlChar * arg1,
+ const xmlChar * arg2)
{
xmlChar *msg;
@@ -2088,17 +2247,16 @@
return;
#ifdef DEBUG_ERROR
- xmlGenericError(xmlGenericErrorContext,
- "Show error %d\n", err);
+ xmlGenericError(xmlGenericErrorContext, "Show error %d\n", err);
#endif
msg = xmlRelaxNGGetErrorString(err, arg1, arg2);
if (msg == NULL)
- return;
+ return;
if (ctxt->errNo == XML_RELAXNG_OK)
- ctxt->errNo = err;
- xmlRelaxNGValidErrorContext(ctxt, node, child);
- ctxt->error(ctxt->userData, "%s\n", msg);
+ ctxt->errNo = err;
+ xmlRngVErr(ctxt, (child == NULL ? node : child), err,
+ (const char *) msg, arg1, arg2);
xmlFree(msg);
}
@@ -2110,30 +2268,32 @@
* pop and discard all errors until the given level is reached
*/
static void
-xmlRelaxNGPopErrors(xmlRelaxNGValidCtxtPtr ctxt, int level) {
+xmlRelaxNGPopErrors(xmlRelaxNGValidCtxtPtr ctxt, int level)
+{
int i;
xmlRelaxNGValidErrorPtr err;
#ifdef DEBUG_ERROR
xmlGenericError(xmlGenericErrorContext,
- "Pop errors till level %d\n", level);
+ "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;
- }
+ 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;
+ ctxt->err = NULL;
}
+
/**
* xmlRelaxNGDumpValidError:
* @ctxt: the validation context
@@ -2141,42 +2301,44 @@
* Show all validation error over a given index.
*/
static void
-xmlRelaxNGDumpValidError(xmlRelaxNGValidCtxtPtr ctxt) {
+xmlRelaxNGDumpValidError(xmlRelaxNGValidCtxtPtr ctxt)
+{
int i, j, k;
xmlRelaxNGValidErrorPtr err, dup;
#ifdef DEBUG_ERROR
xmlGenericError(xmlGenericErrorContext,
- "Dumping error stack %d errors\n", ctxt->errNr);
+ "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;
- }
+ 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
@@ -2189,40 +2351,41 @@
* or stacking it for later handling if unsure.
*/
static void
-xmlRelaxNGAddValidError(xmlRelaxNGValidCtxtPtr ctxt, xmlRelaxNGValidErr err,
- const xmlChar *arg1, const xmlChar *arg2, int dup)
+xmlRelaxNGAddValidError(xmlRelaxNGValidCtxtPtr ctxt,
+ xmlRelaxNGValidErr err, const xmlChar * arg1,
+ const xmlChar * arg2, int dup)
{
if ((ctxt == NULL) || (ctxt->error == NULL))
- return;
+ return;
#ifdef DEBUG_ERROR
- xmlGenericError(xmlGenericErrorContext,
- "Adding error %d\n", err);
+ xmlGenericError(xmlGenericErrorContext, "Adding error %d\n", err);
#endif
/*
* generate the error directly
*/
if (((ctxt->flags & 1) == 0) || (ctxt->flags & 2)) {
- 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;
- }
- xmlRelaxNGShowValidError(ctxt, err, node, seq, arg1, arg2);
+ 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;
+ }
+ xmlRelaxNGShowValidError(ctxt, err, node, seq, arg1, arg2);
}
/*
* Stack the error for later processing if needed
*/
else {
- xmlRelaxNGValidErrorPush(ctxt, err, arg1, arg2, dup);
+ xmlRelaxNGValidErrorPush(ctxt, err, arg1, arg2, dup);
}
}
@@ -2233,7 +2396,7 @@
* *
************************************************************************/
static xmlChar *xmlRelaxNGNormalize(xmlRelaxNGValidCtxtPtr ctxt,
- const xmlChar *str);
+ const xmlChar * str);
/**
* xmlRelaxNGSchemaTypeHave:
@@ -2246,17 +2409,18 @@
* Returns 1 if yes, 0 if no and -1 in case of error.
*/
static int
-xmlRelaxNGSchemaTypeHave(void *data ATTRIBUTE_UNUSED,
- const xmlChar *type) {
+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");
+ return (-1);
+ typ = xmlSchemaGetPredefinedType(type,
+ BAD_CAST
+ "http://www.w3.org/2001/XMLSchema");
if (typ == NULL)
- return(0);
- return(1);
+ return (0);
+ return (1);
}
/**
@@ -2273,28 +2437,29 @@
*/
static int
xmlRelaxNGSchemaTypeCheck(void *data ATTRIBUTE_UNUSED,
- const xmlChar *type,
- const xmlChar *value,
- void **result,
- xmlNodePtr node) {
+ 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");
+ return (-1);
+ typ = xmlSchemaGetPredefinedType(type,
+ BAD_CAST
+ "http://www.w3.org/2001/XMLSchema");
if (typ == NULL)
- return(-1);
+ return (-1);
ret = xmlSchemaValPredefTypeNode(typ, value,
- (xmlSchemaValPtr *) result, node);
- if (ret == 2) /* special ID error code */
- return(2);
+ (xmlSchemaValPtr *) result, node);
+ if (ret == 2) /* special ID error code */
+ return (2);
if (ret == 0)
- return(1);
+ return (1);
if (ret > 0)
- return(0);
- return(-1);
+ return (0);
+ return (-1);
}
/**
@@ -2311,63 +2476,66 @@
* 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) {
+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");
+ return (-1);
+ typ = xmlSchemaGetPredefinedType(type,
+ BAD_CAST
+ "http://www.w3.org/2001/XMLSchema");
if (typ == NULL)
- return(-1);
+ return (-1);
facet = xmlSchemaNewFacet();
if (facet == NULL)
- return(-1);
+ return (-1);
- if (xmlStrEqual(facetname, BAD_CAST "minInclusive")) {
+ if (xmlStrEqual(facetname, BAD_CAST "minInclusive")) {
facet->type = XML_SCHEMA_FACET_MININCLUSIVE;
- } else if (xmlStrEqual(facetname, BAD_CAST "minExclusive")) {
+ } else if (xmlStrEqual(facetname, BAD_CAST "minExclusive")) {
facet->type = XML_SCHEMA_FACET_MINEXCLUSIVE;
- } else if (xmlStrEqual(facetname, BAD_CAST "maxInclusive")) {
+ } else if (xmlStrEqual(facetname, BAD_CAST "maxInclusive")) {
facet->type = XML_SCHEMA_FACET_MAXINCLUSIVE;
- } else if (xmlStrEqual(facetname, BAD_CAST "maxExclusive")) {
+ } else if (xmlStrEqual(facetname, BAD_CAST "maxExclusive")) {
facet->type = XML_SCHEMA_FACET_MAXEXCLUSIVE;
- } else if (xmlStrEqual(facetname, BAD_CAST "totalDigits")) {
+ } else if (xmlStrEqual(facetname, BAD_CAST "totalDigits")) {
facet->type = XML_SCHEMA_FACET_TOTALDIGITS;
- } else if (xmlStrEqual(facetname, BAD_CAST "fractionDigits")) {
+ } else if (xmlStrEqual(facetname, BAD_CAST "fractionDigits")) {
facet->type = XML_SCHEMA_FACET_FRACTIONDIGITS;
- } else if (xmlStrEqual(facetname, BAD_CAST "pattern")) {
+ } else if (xmlStrEqual(facetname, BAD_CAST "pattern")) {
facet->type = XML_SCHEMA_FACET_PATTERN;
- } else if (xmlStrEqual(facetname, BAD_CAST "enumeration")) {
+ } else if (xmlStrEqual(facetname, BAD_CAST "enumeration")) {
facet->type = XML_SCHEMA_FACET_ENUMERATION;
- } else if (xmlStrEqual(facetname, BAD_CAST "whiteSpace")) {
+ } else if (xmlStrEqual(facetname, BAD_CAST "whiteSpace")) {
facet->type = XML_SCHEMA_FACET_WHITESPACE;
- } else if (xmlStrEqual(facetname, BAD_CAST "length")) {
+ } else if (xmlStrEqual(facetname, BAD_CAST "length")) {
facet->type = XML_SCHEMA_FACET_LENGTH;
- } else if (xmlStrEqual(facetname, BAD_CAST "maxLength")) {
+ } 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);
+ xmlSchemaFreeFacet(facet);
+ return (-1);
}
facet->value = xmlStrdup(val);
ret = xmlSchemaCheckFacet(facet, typ, NULL, type);
if (ret != 0) {
- xmlSchemaFreeFacet(facet);
- return(-1);
+ xmlSchemaFreeFacet(facet);
+ return (-1);
}
ret = xmlSchemaValidateFacet(typ, facet, strval, value);
xmlSchemaFreeFacet(facet);
if (ret != 0)
- return(-1);
- return(0);
+ return (-1);
+ return (0);
}
/**
@@ -2380,7 +2548,8 @@
* Returns 1 if yes, 0 if no and -1 in case of error.
*/
static void
-xmlRelaxNGSchemaFreeValue (void *data ATTRIBUTE_UNUSED, void *value) {
+xmlRelaxNGSchemaFreeValue(void *data ATTRIBUTE_UNUSED, void *value)
+{
xmlSchemaFreeValue(value);
}
@@ -2398,51 +2567,52 @@
*/
static int
xmlRelaxNGSchemaTypeCompare(void *data ATTRIBUTE_UNUSED,
- const xmlChar *type,
- const xmlChar *value1,
- xmlNodePtr ctxt1,
- void *comp1,
- const xmlChar *value2,
- xmlNodePtr ctxt2) {
+ 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");
+ return (-1);
+ typ = xmlSchemaGetPredefinedType(type,
+ BAD_CAST
+ "http://www.w3.org/2001/XMLSchema");
if (typ == NULL)
- return(-1);
+ return (-1);
if (comp1 == NULL) {
- ret = xmlSchemaValPredefTypeNode(typ, value1, &res1, ctxt1);
- if (ret != 0)
- return(-1);
- if (res1 == NULL)
- return(-1);
+ ret = xmlSchemaValPredefTypeNode(typ, value1, &res1, ctxt1);
+ if (ret != 0)
+ return (-1);
+ if (res1 == NULL)
+ return (-1);
} else {
- res1 = (xmlSchemaValPtr) comp1;
+ res1 = (xmlSchemaValPtr) comp1;
}
ret = xmlSchemaValPredefTypeNode(typ, value2, &res2, ctxt2);
if (ret != 0) {
- xmlSchemaFreeValue(res1);
- return(-1);
+ xmlSchemaFreeValue(res1);
+ return (-1);
}
if (res1 == NULL) {
- xmlSchemaFreeValue(res1);
- return(-1);
+ xmlSchemaFreeValue(res1);
+ return (-1);
}
ret = xmlSchemaCompareValues(res1, res2);
if (res1 != (xmlSchemaValPtr) comp1)
- xmlSchemaFreeValue(res1);
+ xmlSchemaFreeValue(res1);
xmlSchemaFreeValue(res2);
if (ret == -2)
- return(-1);
+ return (-1);
if (ret == 0)
- return(1);
- return(0);
+ return (1);
+ return (0);
}
-
+
/**
* xmlRelaxNGDefaultTypeHave:
* @data: data needed for the library
@@ -2454,14 +2624,16 @@
* Returns 1 if yes, 0 if no and -1 in case of error.
*/
static int
-xmlRelaxNGDefaultTypeHave(void *data ATTRIBUTE_UNUSED, const xmlChar *type) {
+xmlRelaxNGDefaultTypeHave(void *data ATTRIBUTE_UNUSED,
+ const xmlChar * type)
+{
if (type == NULL)
- return(-1);
+ return (-1);
if (xmlStrEqual(type, BAD_CAST "string"))
- return(1);
+ return (1);
if (xmlStrEqual(type, BAD_CAST "token"))
- return(1);
- return(0);
+ return (1);
+ return (0);
}
/**
@@ -2478,19 +2650,20 @@
*/
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) {
+ const xmlChar * type ATTRIBUTE_UNUSED,
+ const xmlChar * value ATTRIBUTE_UNUSED,
+ void **result ATTRIBUTE_UNUSED,
+ xmlNodePtr node ATTRIBUTE_UNUSED)
+{
if (value == NULL)
- return(-1);
+ return (-1);
if (xmlStrEqual(type, BAD_CAST "string"))
- return(1);
+ return (1);
if (xmlStrEqual(type, BAD_CAST "token")) {
- return(1);
+ return (1);
}
- return(0);
+ return (0);
}
/**
@@ -2507,43 +2680,44 @@
*/
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) {
+ 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);
+ ret = xmlStrEqual(value1, value2);
} else if (xmlStrEqual(type, BAD_CAST "token")) {
- if (!xmlStrEqual(value1, value2)) {
- xmlChar *nval, *nvalue;
+ 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);
+ /*
+ * 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;
+ 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);
+ return (ret);
}
-
+
static int xmlRelaxNGTypeInitialized = 0;
static xmlHashTablePtr xmlRelaxNGRegisteredTypes = NULL;
@@ -2556,11 +2730,12 @@
*/
static void
xmlRelaxNGFreeTypeLibrary(xmlRelaxNGTypeLibraryPtr lib,
- const xmlChar *namespace ATTRIBUTE_UNUSED) {
+ const xmlChar * namespace ATTRIBUTE_UNUSED)
+{
if (lib == NULL)
- return;
+ return;
if (lib->namespace != NULL)
- xmlFree((xmlChar *)lib->namespace);
+ xmlFree((xmlChar *) lib->namespace);
xmlFree(lib);
}
@@ -2577,27 +2752,30 @@
* 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) {
+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);
+ (check == NULL) || (comp == NULL))
+ return (-1);
if (xmlHashLookup(xmlRelaxNGRegisteredTypes, namespace) != NULL) {
- xmlGenericError(xmlGenericErrorContext,
- "Relax-NG types library '%s' already registered\n",
- namespace);
- return(-1);
+ xmlGenericError(xmlGenericErrorContext,
+ "Relax-NG types library '%s' already registered\n",
+ namespace);
+ return (-1);
}
- lib = (xmlRelaxNGTypeLibraryPtr) xmlMalloc(sizeof(xmlRelaxNGTypeLibrary));
+ lib =
+ (xmlRelaxNGTypeLibraryPtr)
+ xmlMalloc(sizeof(xmlRelaxNGTypeLibrary));
if (lib == NULL) {
- xmlGenericError(xmlGenericErrorContext,
- "Relax-NG types library '%s' malloc() failed\n",
- namespace);
+ xmlRngVErrMemory(NULL, "adding types library\n");
return (-1);
}
memset(lib, 0, sizeof(xmlRelaxNGTypeLibrary));
@@ -2610,13 +2788,13 @@
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);
+ xmlGenericError(xmlGenericErrorContext,
+ "Relax-NG types library failed to register '%s'\n",
+ namespace);
+ xmlRelaxNGFreeTypeLibrary(lib, namespace);
+ return (-1);
}
- return(0);
+ return (0);
}
/**
@@ -2627,33 +2805,30 @@
* Returns 0 in case of success and -1 in case of error.
*/
static int
-xmlRelaxNGInitTypes(void) {
+xmlRelaxNGInitTypes(void)
+{
if (xmlRelaxNGTypeInitialized != 0)
- return(0);
+ return (0);
xmlRelaxNGRegisteredTypes = xmlHashCreate(10);
if (xmlRelaxNGRegisteredTypes == NULL) {
- xmlGenericError(xmlGenericErrorContext,
- "Failed to allocate sh table for Relax-NG types\n");
- return(-1);
+ 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);
+ 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);
+ return (0);
}
/**
@@ -2661,13 +2836,14 @@
*
* Cleanup the default Schemas type library associated to RelaxNG
*/
-void
-xmlRelaxNGCleanupTypes(void) {
+void
+xmlRelaxNGCleanupTypes(void)
+{
xmlSchemaCleanupTypes();
if (xmlRelaxNGTypeInitialized == 0)
- return;
+ return;
xmlHashFree(xmlRelaxNGRegisteredTypes, (xmlHashDeallocator)
- xmlRelaxNGFreeTypeLibrary);
+ xmlRelaxNGFreeTypeLibrary);
xmlRelaxNGTypeInitialized = 0;
}
@@ -2692,103 +2868,107 @@
* Returns 1 if yes, 0 if no and -1 in case of error
*/
static int
-xmlRelaxNGIsCompileable(xmlRelaxNGDefinePtr def) {
+xmlRelaxNGIsCompileable(xmlRelaxNGDefinePtr def)
+{
int ret = -1;
if (def == NULL) {
- return(-1);
+ return (-1);
}
if ((def->type != XML_RELAXNG_ELEMENT) &&
(def->dflags & IS_COMPILABLE))
- return(1);
+ return (1);
if ((def->type != XML_RELAXNG_ELEMENT) &&
(def->dflags & IS_NOT_COMPILABLE))
- return(0);
- switch(def->type) {
+ return (0);
+ switch (def->type) {
case XML_RELAXNG_NOOP:
- ret = xmlRelaxNGIsCompileable(def->content);
- break;
+ ret = xmlRelaxNGIsCompileable(def->content);
+ break;
case XML_RELAXNG_TEXT:
case XML_RELAXNG_EMPTY:
- ret = 1;
- break;
+ 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;
- }
- if (ret == 0) def->dflags |= IS_NOT_COMPILABLE;
- if (ret == 1) def->dflags |= IS_COMPILABLE;
+ /*
+ * 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;
+ }
+ if (ret == 0)
+ def->dflags |= IS_NOT_COMPILABLE;
+ if (ret == 1)
+ 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);
- }
+ 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);
+ }
+ /*
+ * 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;
+ 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;
+ 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;
+ case XML_RELAXNG_DEF:{
+ xmlRelaxNGDefinePtr list;
- list = def->content;
- while (list != NULL) {
- ret = xmlRelaxNGIsCompileable(list);
- if (ret != 1)
- break;
- list = list->next;
- }
- break;
- }
+ 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:
@@ -2796,30 +2976,32 @@
case XML_RELAXNG_LIST:
case XML_RELAXNG_PARAM:
case XML_RELAXNG_VALUE:
- ret = 0;
- break;
+ ret = 0;
+ break;
case XML_RELAXNG_NOT_ALLOWED:
- ret = -1;
- break;
+ ret = -1;
+ break;
}
- if (ret == 0) def->dflags |= IS_NOT_COMPILABLE;
- if (ret == 1) def->dflags |= IS_COMPILABLE;
+ 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));
+ xmlGenericError(xmlGenericErrorContext,
+ "RelaxNGIsCompileable %s : true\n",
+ xmlRelaxNGDefName(def));
} else if (ret == 0) {
- xmlGenericError(xmlGenericErrorContext,
- "RelaxNGIsCompileable %s : false\n",
- xmlRelaxNGDefName(def));
+ xmlGenericError(xmlGenericErrorContext,
+ "RelaxNGIsCompileable %s : false\n",
+ xmlRelaxNGDefName(def));
} else {
- xmlGenericError(xmlGenericErrorContext,
- "Problem in RelaxNGIsCompileable %s\n",
- xmlRelaxNGDefName(def));
+ xmlGenericError(xmlGenericErrorContext,
+ "Problem in RelaxNGIsCompileable %s\n",
+ xmlRelaxNGDefName(def));
}
#endif
- return(ret);
+ return (ret);
}
/**
@@ -2833,172 +3015,184 @@
* Returns 0 if success and -1 in case of error
*/
static int
-xmlRelaxNGCompile(xmlRelaxNGParserCtxtPtr ctxt, xmlRelaxNGDefinePtr def) {
+xmlRelaxNGCompile(xmlRelaxNGParserCtxtPtr ctxt, xmlRelaxNGDefinePtr def)
+{
int ret = 0;
xmlRelaxNGDefinePtr list;
- if ((ctxt == NULL) || (def == NULL)) return(-1);
+ if ((ctxt == NULL) || (def == NULL))
+ return (-1);
- switch(def->type) {
+ switch (def->type) {
case XML_RELAXNG_START:
if ((xmlRelaxNGIsCompileable(def) == 1) && (def->depth != -25)) {
- xmlAutomataPtr oldam = ctxt->am;
- xmlAutomataStatePtr oldstate = ctxt->state;
+ xmlAutomataPtr oldam = ctxt->am;
+ xmlAutomataStatePtr oldstate = ctxt->state;
def->depth = -25;
- list = def->content;
- ctxt->am = xmlNewAutomata();
- if (ctxt->am == NULL)
- return(-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);
- xmlRegexpIsDeterminist(def->contModel);
+ list = def->content;
+ ctxt->am = xmlNewAutomata();
+ if (ctxt->am == NULL)
+ return (-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);
+ xmlRegexpIsDeterminist(def->contModel);
- xmlFreeAutomata(ctxt->am);
- ctxt->state = oldstate;
- ctxt->am = oldam;
- }
- break;
+ 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 ((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;
+ xmlAutomataPtr oldam = ctxt->am;
+ xmlAutomataStatePtr oldstate = ctxt->state;
def->depth = -25;
- list = def->content;
- ctxt->am = xmlNewAutomata();
- if (ctxt->am == NULL)
- return(-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)) {
- /*
- * 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;
+ list = def->content;
+ ctxt->am = xmlNewAutomata();
+ if (ctxt->am == NULL)
+ return (-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)) {
+ /*
+ * 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;
+ /*
+ * 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;
-
- xmlRelaxNGCompile(ctxt, def->content);
- xmlAutomataNewEpsilon(ctxt->am, oldstate, ctxt->state);
- break;
- }
- case XML_RELAXNG_ZEROORMORE: {
- xmlAutomataStatePtr oldstate;
+ ret = xmlRelaxNGCompile(ctxt, def->content);
+ break;
+ case XML_RELAXNG_OPTIONAL:{
+ xmlAutomataStatePtr oldstate = ctxt->state;
- 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;
+ xmlRelaxNGCompile(ctxt, def->content);
+ xmlAutomataNewEpsilon(ctxt->am, oldstate, ctxt->state);
+ break;
+ }
+ case XML_RELAXNG_ZEROORMORE:{
+ 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;
+ 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;
- break;
- }
+ 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;
+ 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;
- }
+ 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;
+ ctxt->state =
+ xmlAutomataNewEpsilon(ctxt->am, ctxt->state, NULL);
+ break;
case XML_RELAXNG_EXCEPT:
case XML_RELAXNG_ATTRIBUTE:
case XML_RELAXNG_INTERLEAVE:
@@ -3007,12 +3201,12 @@
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;
+ /* This should not happen and generate an internal error */
+ fprintf(stderr, "RNG internal error trying to compile %s\n",
+ xmlRelaxNGDefName(def));
+ break;
}
- return(ret);
+ return (ret);
}
/**
@@ -3026,42 +3220,45 @@
* Returns 0 if success and -1 in case of error
*/
static int
-xmlRelaxNGTryCompile(xmlRelaxNGParserCtxtPtr ctxt, xmlRelaxNGDefinePtr def) {
+xmlRelaxNGTryCompile(xmlRelaxNGParserCtxtPtr ctxt, xmlRelaxNGDefinePtr def)
+{
int ret = 0;
xmlRelaxNGDefinePtr list;
- if ((ctxt == NULL) || (def == NULL)) return(-1);
+ 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);
+ 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);
- }
+ 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);
- }
+ return (ret);
+ }
}
- switch(def->type) {
+ switch (def->type) {
case XML_RELAXNG_NOOP:
- ret = xmlRelaxNGTryCompile(ctxt, def->content);
- break;
+ ret = xmlRelaxNGTryCompile(ctxt, def->content);
+ break;
case XML_RELAXNG_TEXT:
case XML_RELAXNG_DATATYPE:
case XML_RELAXNG_LIST:
@@ -3069,8 +3266,8 @@
case XML_RELAXNG_VALUE:
case XML_RELAXNG_EMPTY:
case XML_RELAXNG_ELEMENT:
- ret = 0;
- break;
+ ret = 0;
+ break;
case XML_RELAXNG_OPTIONAL:
case XML_RELAXNG_ZEROORMORE:
case XML_RELAXNG_ONEORMORE:
@@ -3081,22 +3278,22 @@
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;
+ 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;
+ ret = 0;
+ break;
}
- return(ret);
+ return (ret);
}
/************************************************************************
@@ -3105,25 +3302,28 @@
* *
************************************************************************/
-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);
+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))
@@ -3137,27 +3337,30 @@
* Returns 1 if yes, 0 if no and -1 in case of error
*/
static int
-xmlRelaxNGIsNullable(xmlRelaxNGDefinePtr define) {
+xmlRelaxNGIsNullable(xmlRelaxNGDefinePtr define)
+{
int ret;
+
if (define == NULL)
- return(-1);
+ return (-1);
if (define->dflags & IS_NULLABLE)
- return(1);
+ return (1);
if (define->dflags & IS_NOT_NULLABLE)
- return(0);
+ return (0);
switch (define->type) {
case XML_RELAXNG_EMPTY:
case XML_RELAXNG_TEXT:
- ret = 1; break;
+ 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;
+ ret = xmlRelaxNGIsNullable(define->content);
+ break;
case XML_RELAXNG_EXCEPT:
case XML_RELAXNG_NOT_ALLOWED:
case XML_RELAXNG_ELEMENT:
@@ -3166,40 +3369,42 @@
case XML_RELAXNG_VALUE:
case XML_RELAXNG_LIST:
case XML_RELAXNG_ATTRIBUTE:
- ret = 0; break;
- case XML_RELAXNG_CHOICE: {
- xmlRelaxNGDefinePtr list = define->content;
+ 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;
- }
+ 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;
+ 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);
+ while (list != NULL) {
+ ret = xmlRelaxNGIsNullable(list);
+ if (ret != 1)
+ goto done;
+ list = list->next;
+ }
+ return (1);
+ }
+ default:
+ return (-1);
}
-done:
+ done:
if (ret == 0)
- define->dflags |= IS_NOT_NULLABLE;
+ define->dflags |= IS_NOT_NULLABLE;
if (ret == 1)
- define->dflags |= IS_NULLABLE;
- return(ret);
+ define->dflags |= IS_NULLABLE;
+ return (ret);
}
/**
@@ -3211,14 +3416,16 @@
* Returns 1 if the string is NULL or made of blanks chars, 0 otherwise
*/
static int
-xmlRelaxNGIsBlank(xmlChar *str) {
+xmlRelaxNGIsBlank(xmlChar * str)
+{
if (str == NULL)
- return(1);
+ return (1);
while (*str != 0) {
- if (!(IS_BLANK(*str))) return(0);
- str++;
+ if (!(IS_BLANK(*str)))
+ return (0);
+ str++;
}
- return(1);
+ return (1);
}
/**
@@ -3232,42 +3439,43 @@
*/
static xmlChar *
xmlRelaxNGGetDataTypeLibrary(xmlRelaxNGParserCtxtPtr ctxt ATTRIBUTE_UNUSED,
- xmlNodePtr node) {
+ xmlNodePtr node)
+{
xmlChar *ret, *escape;
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);
- }
+ 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;
+ 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);
+ return (NULL);
}
/**
@@ -3280,7 +3488,8 @@
* Returns the definition pointer or NULL in case of error
*/
static xmlRelaxNGDefinePtr
-xmlRelaxNGParseValue(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node) {
+xmlRelaxNGParseValue(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
+{
xmlRelaxNGDefinePtr def = NULL;
xmlRelaxNGTypeLibraryPtr lib = NULL;
xmlChar *type;
@@ -3289,88 +3498,76 @@
def = xmlRelaxNGNewDefine(ctxt, node);
if (def == NULL)
- return(NULL);
+ return (NULL);
def->type = XML_RELAXNG_VALUE;
type = xmlGetProp(node, BAD_CAST "type");
if (type != NULL) {
- xmlRelaxNGNormExtSpace(type);
- if (xmlValidateNCName(type, 0)) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "value type '%s' is not an NCName\n",
- type);
- ctxt->nbErrors++;
- }
- library = xmlRelaxNGGetDataTypeLibrary(ctxt, node);
- if (library == NULL)
- library = xmlStrdup(BAD_CAST "http://relaxng.org/ns/structure/1.0");
+ 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;
+ def->name = type;
+ def->ns = library;
- lib = (xmlRelaxNGTypeLibraryPtr)
- xmlHashLookup(xmlRelaxNGRegisteredTypes, library);
- if (lib == NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Use of unregistered type library '%s'\n",
- library);
- ctxt->nbErrors++;
- def->data = NULL;
- } else {
- def->data = lib;
- if (lib->have == NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Internal error with type library '%s': no 'have'\n",
- library);
- ctxt->nbErrors++;
- } else {
- success = lib->have(lib->data, def->name);
- if (success != 1) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Error type '%s' is not exported by type library '%s'\n",
- def->name, library);
- ctxt->nbErrors++;
- }
- }
- }
+ 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 "");
+ def->value = xmlStrdup(BAD_CAST "");
} else if (((node->children->type != XML_TEXT_NODE) &&
- (node->children->type != XML_CDATA_SECTION_NODE)) ||
- (node->children->next != NULL)) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Expecting a single text value for <value>content\n");
- ctxt->nbErrors++;
+ (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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Element <value> has no content\n");
- ctxt->nbErrors++;
- } else if ((lib != NULL) && (lib->check != NULL) && (success == 1)) {
- void *val = 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Value '%s' is not acceptable for type '%s'\n",
- def->value, def->name);
- ctxt->nbErrors++;
- } else {
- if (val != NULL)
- def->attrs = val;
- }
- }
+ 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);
+ return (def);
}
/**
@@ -3383,7 +3580,8 @@
* Returns the definition pointer or NULL in case of error
*/
static xmlRelaxNGDefinePtr
-xmlRelaxNGParseData(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node) {
+xmlRelaxNGParseData(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
+{
xmlRelaxNGDefinePtr def = NULL, except, last = NULL;
xmlRelaxNGDefinePtr param, lastparam = NULL;
xmlRelaxNGTypeLibraryPtr lib;
@@ -3394,65 +3592,58 @@
type = xmlGetProp(node, BAD_CAST "type");
if (type == NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "data has no type\n");
- ctxt->nbErrors++;
- return(NULL);
+ xmlRngPErr(ctxt, node, XML_RNGP_TYPE_MISSING, "data has no type\n", NULL,
+ NULL);
+ return (NULL);
}
xmlRelaxNGNormExtSpace(type);
if (xmlValidateNCName(type, 0)) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "data type '%s' is not an NCName\n",
- type);
- ctxt->nbErrors++;
+ 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");
+ library =
+ xmlStrdup(BAD_CAST "http://relaxng.org/ns/structure/1.0");
def = xmlRelaxNGNewDefine(ctxt, node);
if (def == NULL) {
- xmlFree(type);
- return(NULL);
+ xmlFree(type);
+ return (NULL);
}
def->type = XML_RELAXNG_DATATYPE;
def->name = type;
def->ns = library;
lib = (xmlRelaxNGTypeLibraryPtr)
- xmlHashLookup(xmlRelaxNGRegisteredTypes, library);
+ xmlHashLookup(xmlRelaxNGRegisteredTypes, library);
if (lib == NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Use of unregistered type library '%s'\n",
- library);
- ctxt->nbErrors++;
- def->data = 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Internal error with type library '%s': no 'have'\n",
- library);
- ctxt->nbErrors++;
- } else {
- tmp = lib->have(lib->data, def->name);
- if (tmp != 1) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Error type '%s' is not exported by type library '%s'\n",
- def->name, library);
- ctxt->nbErrors++;
- } 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;
- }
- }
+ 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;
@@ -3460,92 +3651,86 @@
* 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")) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Type library '%s' does not allow type parameters\n",
- library);
- ctxt->nbErrors++;
- 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "param has no name\n");
- ctxt->nbErrors++;
- }
- param->value = xmlNodeGetContent(content);
- if (lastparam == NULL) {
- def->attrs = lastparam = param;
- } else {
- lastparam->next = param;
- lastparam = param;
- }
- if (lib != NULL) {
- }
- }
- content = content->next;
- }
+ 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, last2 = NULL;
+ if ((content != NULL)
+ && (xmlStrEqual(content->name, BAD_CAST "except"))) {
+ xmlNodePtr child;
+ xmlRelaxNGDefinePtr tmp2, last2 = NULL;
- except = xmlRelaxNGNewDefine(ctxt, node);
- if (except == NULL) {
- return(def);
- }
- except->type = XML_RELAXNG_EXCEPT;
- child = content->children;
- if (last == NULL) {
- def->content = except;
- } else {
- last->next = except;
- }
- if (child == NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "except has no content\n");
- ctxt->nbErrors++;
- }
- while (child != NULL) {
- tmp2 = xmlRelaxNGParsePattern(ctxt, child);
- if (tmp2 != NULL) {
- if (last2 == NULL) {
- except->content = last2 = tmp2;
- } else {
- last2->next = tmp2;
- last2 = tmp2;
- }
- }
- child = child->next;
- }
- content = content->next;
+ except = xmlRelaxNGNewDefine(ctxt, node);
+ if (except == NULL) {
+ return (def);
+ }
+ except->type = XML_RELAXNG_EXCEPT;
+ child = content->children;
+ if (last == NULL) {
+ def->content = except;
+ } else {
+ last->next = 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 (last2 == NULL) {
+ except->content = last2 = tmp2;
+ } else {
+ last2->next = tmp2;
+ last2 = tmp2;
+ }
+ }
+ child = child->next;
+ }
+ content = content->next;
}
/*
* Check there is no unhandled data
*/
if (content != NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Element data has unexpected content %s\n", content->name);
- ctxt->nbErrors++;
+ xmlRngPErr(ctxt, content, XML_RNGP_DATA_CONTENT,
+ "Element data has unexpected content %s\n",
+ content->name, NULL);
}
- return(def);
+ return (def);
}
static const xmlChar *invalidName = BAD_CAST "\1";
@@ -3565,88 +3750,87 @@
*/
static int
xmlRelaxNGCompareNameClasses(xmlRelaxNGDefinePtr def1,
- xmlRelaxNGDefinePtr def2) {
+ xmlRelaxNGDefinePtr def2)
+{
int ret = 1;
xmlNode node;
xmlNs ns;
xmlRelaxNGValidCtxt ctxt;
+
ctxt.flags = FLAGS_IGNORABLE;
memset(&ctxt, 0, sizeof(xmlRelaxNGValidCtxt));
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;
- }
- node.ns = &ns;
- if (def1->ns != NULL) {
- if (def1->ns[0] == 0) {
- node.ns = NULL;
- } else {
- ns.href = def1->ns;
- }
- } else {
- ns.href = invalidName;
- }
+ (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;
+ }
+ node.ns = &ns;
+ if (def1->ns != NULL) {
+ if (def1->ns[0] == 0) {
+ node.ns = NULL;
+ } else {
+ ns.href = def1->ns;
+ }
+ } else {
+ ns.href = invalidName;
+ }
if (xmlRelaxNGElementMatch(&ctxt, def2, &node)) {
- if (def1->nameClass != NULL) {
- ret = xmlRelaxNGCompareNameClasses(def1->nameClass, def2);
- } else {
- ret = 0;
- }
- } else {
- ret = 1;
- }
+ 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);
+ if (def2->type == XML_RELAXNG_TEXT)
+ return (0);
+ return (1);
} else if (def1->type == XML_RELAXNG_EXCEPT) {
- TODO
- ret = 0;
+ TODO ret = 0;
} else {
- TODO
- ret = 0;
+ TODO ret = 0;
}
if (ret == 0)
- return(ret);
+ 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;
- }
+ (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;
- }
+ if (def2->nameClass != NULL) {
+ ret = xmlRelaxNGCompareNameClasses(def2->nameClass, def1);
+ } else {
+ ret = 0;
+ }
+ } else {
+ ret = 1;
+ }
} else {
- TODO
- ret = 0;
+ TODO ret = 0;
}
- return(ret);
+ return (ret);
}
/**
@@ -3662,25 +3846,26 @@
* Returns 1 disttinct, 0 if equal
*/
static int
-xmlRelaxNGCompareElemDefLists(xmlRelaxNGParserCtxtPtr ctxt ATTRIBUTE_UNUSED,
- xmlRelaxNGDefinePtr *def1,
- xmlRelaxNGDefinePtr *def2) {
+xmlRelaxNGCompareElemDefLists(xmlRelaxNGParserCtxtPtr ctxt
+ ATTRIBUTE_UNUSED, xmlRelaxNGDefinePtr * def1,
+ xmlRelaxNGDefinePtr * def2)
+{
xmlRelaxNGDefinePtr *basedef2 = def2;
-
+
if ((def1 == NULL) || (def2 == NULL))
- return(1);
+ return (1);
if ((*def1 == NULL) || (*def2 == NULL))
- return(1);
+ return (1);
while (*def1 != NULL) {
- while ((*def2) != NULL) {
- if (xmlRelaxNGCompareNameClasses(*def1, *def2) == 0)
- return(0);
- def2++;
- }
- def2 = basedef2;
- def1++;
+ while ((*def2) != NULL) {
+ if (xmlRelaxNGCompareNameClasses(*def1, *def2) == 0)
+ return (0);
+ def2++;
+ }
+ def2 = basedef2;
+ def1++;
}
- return(1);
+ return (1);
}
/**
@@ -3694,7 +3879,8 @@
*/
static int
xmlRelaxNGGenerateAttributes(xmlRelaxNGParserCtxtPtr ctxt,
- xmlRelaxNGDefinePtr def) {
+ xmlRelaxNGDefinePtr def)
+{
xmlRelaxNGDefinePtr parent, cur, tmp;
/*
@@ -3702,59 +3888,61 @@
* becomes possible.
*/
if (ctxt->nbErrors != 0)
- return(-1);
+ 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);
+ 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);
+ return (1);
}
-
+
/**
* xmlRelaxNGGetElements:
* @ctxt: a Relax-NG parser context
@@ -3767,8 +3955,8 @@
*/
static xmlRelaxNGDefinePtr *
xmlRelaxNGGetElements(xmlRelaxNGParserCtxtPtr ctxt,
- xmlRelaxNGDefinePtr def,
- int eora) {
+ xmlRelaxNGDefinePtr def, int eora)
+{
xmlRelaxNGDefinePtr *ret = NULL, parent, cur, tmp;
int len = 0;
int max = 0;
@@ -3778,81 +3966,79 @@
* becomes possible.
*/
if (ctxt->nbErrors != 0)
- return(NULL);
+ 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Out of memory in element search\n");
- ctxt->nbErrors++;
- return(NULL);
- }
- } else if (max <= len) {
- max *= 2;
- ret = xmlRealloc(ret, (max + 1) * sizeof(xmlRelaxNGDefinePtr));
- if (ret == NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Out of memory in element search\n");
- ctxt->nbErrors++;
- return(NULL);
- }
- }
- 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)) {
- /*
- * 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);
+ 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) {
+ max *= 2;
+ ret =
+ xmlRealloc(ret,
+ (max + 1) * sizeof(xmlRelaxNGDefinePtr));
+ if (ret == NULL) {
+ xmlRngPErrMemory(ctxt, "getting element list\n");
+ return (NULL);
+ }
+ }
+ 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)) {
+ /*
+ * 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);
+ return (ret);
}
-
+
/**
* xmlRelaxNGCheckChoiceDeterminism:
* @ctxt: a Relax-NG parser context
@@ -3862,7 +4048,8 @@
*/
static void
xmlRelaxNGCheckChoiceDeterminism(xmlRelaxNGParserCtxtPtr ctxt,
- xmlRelaxNGDefinePtr def) {
+ xmlRelaxNGDefinePtr def)
+{
xmlRelaxNGDefinePtr **list;
xmlRelaxNGDefinePtr cur;
int nbchild = 0, i, j, ret;
@@ -3871,122 +4058,119 @@
xmlHashTablePtr triage = NULL;
int is_triable = 1;
- if ((def == NULL) ||
- (def->type != XML_RELAXNG_CHOICE))
- return;
+ if ((def == NULL) || (def->type != XML_RELAXNG_CHOICE))
+ return;
if (def->dflags & IS_PROCESSED)
- return;
+ return;
/*
* Don't run that check in case of error. Infinite recursion
* becomes possible.
*/
if (ctxt->nbErrors != 0)
- return;
+ return;
is_nullable = xmlRelaxNGIsNullable(def);
cur = def->content;
while (cur != NULL) {
- nbchild++;
- cur = cur->next;
+ nbchild++;
+ cur = cur->next;
}
list = (xmlRelaxNGDefinePtr **) xmlMalloc(nbchild *
- sizeof(xmlRelaxNGDefinePtr *));
+ sizeof(xmlRelaxNGDefinePtr
+ *));
if (list == NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Out of memory in choice computation\n");
- ctxt->nbErrors++;
- return;
+ xmlRngPErrMemory(ctxt, "building choice\n");
+ return;
}
i = 0;
/*
* a bit strong but safe
*/
if (is_nullable == 0) {
- triage = xmlHashCreate(10);
+ triage = xmlHashCreate(10);
} else {
- is_triable = 0;
+ 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;
+ 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;
+ 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)
+ 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]);
+ for (i = 0; i < nbchild; i++) {
+ if (list[i] != NULL)
+ xmlFree(list[i]);
}
xmlFree(list);
if (is_indeterminist) {
- def->dflags |= IS_INDETERMINIST;
+ def->dflags |= IS_INDETERMINIST;
}
if (is_triable == 1) {
- def->dflags |= IS_TRIABLE;
- def->data = triage;
+ def->dflags |= IS_TRIABLE;
+ def->data = triage;
} else if (triage != NULL) {
- xmlHashFree(triage, NULL);
+ xmlHashFree(triage, NULL);
}
def->dflags |= IS_PROCESSED;
}
@@ -4000,78 +4184,75 @@
*/
static void
xmlRelaxNGCheckGroupAttrs(xmlRelaxNGParserCtxtPtr ctxt,
- xmlRelaxNGDefinePtr def) {
+ 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;
+ ((def->type != XML_RELAXNG_GROUP) &&
+ (def->type != XML_RELAXNG_ELEMENT)))
+ return;
if (def->dflags & IS_PROCESSED)
- return;
+ return;
/*
* Don't run that check in case of error. Infinite recursion
* becomes possible.
*/
if (ctxt->nbErrors != 0)
- return;
+ return;
cur = def->attrs;
while (cur != NULL) {
- nbchild++;
- cur = cur->next;
+ nbchild++;
+ cur = cur->next;
}
cur = def->content;
while (cur != NULL) {
- nbchild++;
- cur = cur->next;
+ nbchild++;
+ cur = cur->next;
}
list = (xmlRelaxNGDefinePtr **) xmlMalloc(nbchild *
- sizeof(xmlRelaxNGDefinePtr *));
+ sizeof(xmlRelaxNGDefinePtr
+ *));
if (list == NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Out of memory in group computation\n");
- ctxt->nbErrors++;
- return;
+ xmlRngPErrMemory(ctxt, "building group\n");
+ return;
}
i = 0;
cur = def->attrs;
while (cur != NULL) {
- list[i] = xmlRelaxNGGetElements(ctxt, cur, 1);
- i++;
- cur = cur->next;
+ 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;
+ 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Attributes conflicts in group\n");
- ctxt->nbErrors++;
- }
- }
+ 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]);
+ for (i = 0; i < nbchild; i++) {
+ if (list[i] != NULL)
+ xmlFree(list[i]);
}
xmlFree(list);
@@ -4095,14 +4276,15 @@
*/
static void
xmlRelaxNGComputeInterleaves(xmlRelaxNGDefinePtr def,
- xmlRelaxNGParserCtxtPtr ctxt,
- xmlChar *name ATTRIBUTE_UNUSED) {
+ xmlRelaxNGParserCtxtPtr ctxt,
+ xmlChar * name ATTRIBUTE_UNUSED)
+{
xmlRelaxNGDefinePtr cur, *tmp;
xmlRelaxNGPartitionPtr partitions = NULL;
xmlRelaxNGInterleaveGroupPtr *groups = NULL;
xmlRelaxNGInterleaveGroupPtr group;
- int i,j,ret, res;
+ int i, j, ret, res;
int nbgroups = 0;
int nbchild = 0;
int is_mixed = 0;
@@ -4113,39 +4295,38 @@
* becomes possible.
*/
if (ctxt->nbErrors != 0)
- return;
+ return;
#ifdef DEBUG_INTERLEAVE
xmlGenericError(xmlGenericErrorContext,
- "xmlRelaxNGComputeInterleaves(%s)\n",
- name);
+ "xmlRelaxNGComputeInterleaves(%s)\n", name);
#endif
cur = def->content;
while (cur != NULL) {
- nbchild++;
- cur = cur->next;
+ nbchild++;
+ cur = cur->next;
}
-
+
#ifdef DEBUG_INTERLEAVE
xmlGenericError(xmlGenericErrorContext, " %d child\n", nbchild);
#endif
groups = (xmlRelaxNGInterleaveGroupPtr *)
- xmlMalloc(nbchild * sizeof(xmlRelaxNGInterleaveGroupPtr));
+ xmlMalloc(nbchild * sizeof(xmlRelaxNGInterleaveGroupPtr));
if (groups == NULL)
- goto error;
+ 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;
+ 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);
@@ -4155,77 +4336,75 @@
* Let's check that all rules makes a partitions according to 7.4
*/
partitions = (xmlRelaxNGPartitionPtr)
- xmlMalloc(sizeof(xmlRelaxNGPartition));
+ 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Element or text conflicts in interleave\n");
- ctxt->nbErrors++;
- }
- ret = xmlRelaxNGCompareElemDefLists(ctxt, group->attrs,
- groups[j]->attrs);
- if (ret == 0) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Attributes conflicts in interleave\n");
- ctxt->nbErrors++;
- }
- }
- 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;
- }
+ 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;
@@ -4234,26 +4413,23 @@
*/
def->data = partitions;
if (is_mixed != 0)
- def->dflags |= IS_MIXED;
+ def->dflags |= IS_MIXED;
if (is_determinist == 1)
- partitions->flags = IS_DETERMINIST;
+ partitions->flags = IS_DETERMINIST;
if (is_determinist == 2)
- partitions->flags = IS_DETERMINIST | IS_NEEDCHECK;
+ partitions->flags = IS_DETERMINIST | IS_NEEDCHECK;
return;
-error:
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Out of memory in interleave computation\n");
- ctxt->nbErrors++;
+ 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);
+ 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);
}
@@ -4268,60 +4444,56 @@
* Returns the definition pointer or NULL in case of error
*/
static xmlRelaxNGDefinePtr
-xmlRelaxNGParseInterleave(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node) {
+xmlRelaxNGParseInterleave(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
+{
xmlRelaxNGDefinePtr def = NULL;
xmlRelaxNGDefinePtr last = NULL, cur;
xmlNodePtr child;
def = xmlRelaxNGNewDefine(ctxt, node);
if (def == NULL) {
- return(NULL);
+ return (NULL);
}
def->type = XML_RELAXNG_INTERLEAVE;
if (ctxt->interleaves == NULL)
- ctxt->interleaves = xmlHashCreate(10);
+ ctxt->interleaves = xmlHashCreate(10);
if (ctxt->interleaves == NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Failed to create interleaves hash table\n");
- ctxt->nbErrors++;
+ xmlRngPErrMemory(ctxt, "create interleaves\n");
} else {
- char name[32];
+ char name[32];
- snprintf(name, 32, "interleave%d", ctxt->nbInterleaves++);
- if (xmlHashAddEntry(ctxt->interleaves, BAD_CAST name, def) < 0) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Failed to add %s to hash table\n", name);
- ctxt->nbErrors++;
- }
+ 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData, "Element interleave is empty\n");
- ctxt->nbErrors++;
+ 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;
+ 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);
+ return (def);
}
/**
@@ -4334,49 +4506,44 @@
* Returns 0 in case of success or -1 in case of error
*/
static int
-xmlRelaxNGParseInclude(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node) {
+xmlRelaxNGParseInclude(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
+{
xmlRelaxNGIncludePtr incl;
xmlNodePtr root;
int ret = 0, tmp;
incl = node->_private;
if (incl == NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Include node has no data\n");
- ctxt->nbErrors++;
- return(-1);
+ xmlRngPErr(ctxt, node, XML_RNGP_INCLUDE_EMPTY,
+ "Include node has no data\n", NULL, NULL);
+ return (-1);
}
root = xmlDocGetRootElement(incl->doc);
if (root == NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Include document is empty\n");
- ctxt->nbErrors++;
- return(-1);
+ xmlRngPErr(ctxt, node, XML_RNGP_EMPTY, "Include document is empty\n",
+ NULL, NULL);
+ return (-1);
}
if (!xmlStrEqual(root->name, BAD_CAST "grammar")) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Include document root is not a grammar\n");
- ctxt->nbErrors++;
- return(-1);
+ 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;
+ tmp = xmlRelaxNGParseGrammarContent(ctxt, root->children);
+ if (tmp != 0)
+ ret = -1;
}
if (node->children != NULL) {
- tmp = xmlRelaxNGParseGrammarContent(ctxt, node->children);
- if (tmp != 0)
- ret = -1;
+ tmp = xmlRelaxNGParseGrammarContent(ctxt, node->children);
+ if (tmp != 0)
+ ret = -1;
}
- return(ret);
+ return (ret);
}
/**
@@ -4389,7 +4556,8 @@
* Returns 0 in case of success or -1 in case of error
*/
static int
-xmlRelaxNGParseDefine(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node) {
+xmlRelaxNGParseDefine(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
+{
xmlChar *name;
int ret = 0, tmp;
xmlRelaxNGDefinePtr def;
@@ -4397,67 +4565,57 @@
name = xmlGetProp(node, BAD_CAST "name");
if (name == NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "define has no name\n");
- ctxt->nbErrors++;
+ xmlRngPErr(ctxt, node, XML_RNGP_DEFINE_NAME_MISSING,
+ "define has no name\n", NULL, NULL);
} else {
- xmlRelaxNGNormExtSpace(name);
- if (xmlValidateNCName(name, 0)) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "define name '%s' is not an NCName\n",
- name);
- ctxt->nbErrors++;
- }
- def = xmlRelaxNGNewDefine(ctxt, node);
- if (def == NULL) {
- xmlFree(name);
- return(-1);
- }
- def->type = XML_RELAXNG_DEF;
- def->name = name;
- if (node->children == NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "define has no children\n");
- ctxt->nbErrors++;
- } 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Could not create definition hash\n");
- ctxt->nbErrors++;
- ret = -1;
- } else {
- tmp = xmlHashAddEntry(ctxt->grammar->defs, name, def);
- if (tmp < 0) {
- xmlRelaxNGDefinePtr prev;
+ 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Internal error on define aggregation of %s\n",
- name);
- ctxt->nbErrors++;
- ret = -1;
- } else {
- while (prev->nextHash != NULL)
- prev = prev->nextHash;
- prev->nextHash = def;
- }
- }
- }
+ 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);
+ return (ret);
}
/**
@@ -4470,7 +4628,8 @@
* Returns the xmlRelaxNGDefinePtr or NULL in case of error
*/
static xmlRelaxNGDefinePtr
-xmlRelaxNGProcessExternalRef(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node) {
+xmlRelaxNGProcessExternalRef(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
+{
xmlRelaxNGDocumentPtr docu;
xmlNodePtr root, tmp;
xmlChar *ns;
@@ -4479,71 +4638,68 @@
docu = node->_private;
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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "xmlRelaxNGParse: %s is empty\n",
- ctxt->URL);
- ctxt->nbErrors++;
- 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);
- }
+ def = xmlRelaxNGNewDefine(ctxt, node);
+ if (def == NULL)
+ return (NULL);
+ def->type = XML_RELAXNG_EXTERNALREF;
- /*
- * 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->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);
+ }
- /*
- * the externalRef may be reused in a different ns context
- */
- if (newNs == 1) {
- xmlUnsetProp(root, BAD_CAST "ns");
- }
- }
- def->content = docu->content;
+ /*
+ * 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;
+ }
+
+ /*
+ * 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;
+ def = NULL;
}
- return(def);
+ return (def);
}
/**
@@ -4557,324 +4713,295 @@
* pattern is generated.
*/
static xmlRelaxNGDefinePtr
-xmlRelaxNGParsePattern(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node) {
+xmlRelaxNGParsePattern(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
+{
xmlRelaxNGDefinePtr def = NULL;
if (node == NULL) {
- return(NULL);
+ return (NULL);
}
if (IS_RELAXNG(node, "element")) {
- def = xmlRelaxNGParseElement(ctxt, node);
+ def = xmlRelaxNGParseElement(ctxt, node);
} else if (IS_RELAXNG(node, "attribute")) {
- def = xmlRelaxNGParseAttribute(ctxt, node);
+ 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData, "empty: had a child node\n");
- ctxt->nbErrors++;
- }
+ 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData, "text: had a child node\n");
- ctxt->nbErrors++;
- }
+ 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Element %s is empty\n", node->name);
- ctxt->nbErrors++;
- } else {
- def->content = xmlRelaxNGParsePatterns(ctxt, node->children, 1);
- }
+ 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Element %s is empty\n", node->name);
- ctxt->nbErrors++;
- } else {
- def->content = xmlRelaxNGParsePatterns(ctxt, node->children, 1);
- }
+ 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Element %s is empty\n", node->name);
- ctxt->nbErrors++;
- } else {
- def->content = xmlRelaxNGParsePatterns(ctxt, node->children, 1);
- }
+ 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Element %s is empty\n", node->name);
- ctxt->nbErrors++;
- } else {
- def->content = xmlRelaxNGParsePatterns(ctxt, node->children, 0);
- }
+ 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Element %s is empty\n", node->name);
- ctxt->nbErrors++;
- } else {
- def->content = xmlRelaxNGParsePatterns(ctxt, node->children, 0);
- }
+ 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "ref has no name\n");
- ctxt->nbErrors++;
- } else {
- xmlRelaxNGNormExtSpace(def->name);
- if (xmlValidateNCName(def->name, 0)) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "ref name '%s' is not an NCName\n",
- def->name);
- ctxt->nbErrors++;
- }
- }
- if (node->children != NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "ref is not empty\n");
- ctxt->nbErrors++;
- }
- if (ctxt->grammar->refs == NULL)
- ctxt->grammar->refs = xmlHashCreate(10);
- if (ctxt->grammar->refs == NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Could not create references hash\n");
- ctxt->nbErrors++;
- def = NULL;
- } else {
- int tmp;
+ 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;
+ 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Error refs definitions '%s'\n",
- def->name);
- } else {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Error refs definitions\n");
- }
- ctxt->nbErrors++;
- def = NULL;
- } else {
- def->nextHash = prev->nextHash;
- prev->nextHash = def;
- }
- }
- }
+ prev = (xmlRelaxNGDefinePtr)
+ xmlHashLookup(ctxt->grammar->refs, def->name);
+ if (prev == NULL) {
+ if (def->name != NULL) {
+ if (ctxt->error != NULL)
+ ctxt->error(ctxt->userData,
+ "Error refs definitions '%s'\n",
+ def->name);
+ } else {
+ if (ctxt->error != NULL)
+ ctxt->error(ctxt->userData,
+ "Error refs definitions\n");
+ }
+ ctxt->nbErrors++;
+ def = NULL;
+ } else {
+ def->nextHash = prev->nextHash;
+ prev->nextHash = def;
+ }
+ }
+ }
} else if (IS_RELAXNG(node, "data")) {
- def = xmlRelaxNGParseData(ctxt, node);
+ def = xmlRelaxNGParseData(ctxt, node);
} else if (IS_RELAXNG(node, "value")) {
- def = xmlRelaxNGParseValue(ctxt, node);
+ 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Element %s is empty\n", node->name);
- ctxt->nbErrors++;
- } else {
- def->content = xmlRelaxNGParsePatterns(ctxt, node->children, 0);
- }
+ 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);
+ def = xmlRelaxNGParseInterleave(ctxt, node);
} else if (IS_RELAXNG(node, "externalRef")) {
- def = xmlRelaxNGProcessExternalRef(ctxt, node);
+ 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "xmlRelaxNGParse: notAllowed element is not empty\n");
- ctxt->nbErrors++;
- }
+ 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;
+ xmlRelaxNGGrammarPtr grammar, old;
+ xmlRelaxNGGrammarPtr oldparent;
#ifdef DEBUG_GRAMMAR
- xmlGenericError(xmlGenericErrorContext, "Found <grammar> pattern\n");
+ 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;
+ 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;
- }
+ if (grammar != NULL) {
+ grammar->next = old->next;
+ old->next = grammar;
+ }
#endif
- }
- if (grammar != NULL)
- def = grammar->start;
- else
- def = NULL;
+ }
+ if (grammar != NULL)
+ def = grammar->start;
+ else
+ def = NULL;
} else if (IS_RELAXNG(node, "parentRef")) {
- if (ctxt->parentgrammar == NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Use of parentRef without a parent grammar\n");
- ctxt->nbErrors++;
- 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "parentRef has no name\n");
- ctxt->nbErrors++;
- } else {
- xmlRelaxNGNormExtSpace(def->name);
- if (xmlValidateNCName(def->name, 0)) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "parentRef name '%s' is not an NCName\n",
- def->name);
- ctxt->nbErrors++;
- }
- }
- if (node->children != NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "parentRef is not empty\n");
- ctxt->nbErrors++;
- }
- if (ctxt->parentgrammar->refs == NULL)
- ctxt->parentgrammar->refs = xmlHashCreate(10);
- if (ctxt->parentgrammar->refs == NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Could not create references hash\n");
- ctxt->nbErrors++;
- def = NULL;
- } else if (def->name != NULL) {
- int tmp;
+ 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;
+ tmp =
+ xmlHashAddEntry(ctxt->parentgrammar->refs, def->name, def);
+ if (tmp < 0) {
+ xmlRelaxNGDefinePtr prev;
- prev = (xmlRelaxNGDefinePtr)
- xmlHashLookup(ctxt->parentgrammar->refs, def->name);
- if (prev == NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Internal error parentRef definitions '%s'\n",
- def->name);
- ctxt->nbErrors++;
- def = NULL;
- } else {
- def->nextHash = prev->nextHash;
- prev->nextHash = def;
- }
- }
- }
+ 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Mixed is empty\n");
- ctxt->nbErrors++;
- def = NULL;
- } else {
- def = xmlRelaxNGParseInterleave(ctxt, node);
- if (def != NULL) {
- xmlRelaxNGDefinePtr tmp;
+ 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;
- }
- }
+ 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;
- }
- }
+ tmp = xmlRelaxNGNewDefine(ctxt, node);
+ if (tmp == NULL)
+ return (def);
+ tmp->type = XML_RELAXNG_TEXT;
+ tmp->next = def->content;
+ def->content = tmp;
+ }
+ }
} else {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Unexpected node %s is not a pattern\n",
- node->name);
- ctxt->nbErrors++;
- def = NULL;
+ xmlRngPErr(ctxt, node, XML_RNGP_UNKNOWN_CONSTRUCT,
+ "Unexpected node %s is not a pattern\n", node->name,
+ NULL);
+ def = NULL;
}
- return(def);
+ return (def);
}
/**
@@ -4887,80 +5014,77 @@
* Returns the definition pointer or NULL in case of error.
*/
static xmlRelaxNGDefinePtr
-xmlRelaxNGParseAttribute(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node) {
+xmlRelaxNGParseAttribute(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
+{
xmlRelaxNGDefinePtr ret, cur;
xmlNodePtr child;
int old_flags;
ret = xmlRelaxNGNewDefine(ctxt, node);
if (ret == NULL)
- return(NULL);
+ return (NULL);
ret->type = XML_RELAXNG_ATTRIBUTE;
ret->parent = ctxt->def;
child = node->children;
if (child == NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "xmlRelaxNGParseattribute: attribute has no children\n");
- ctxt->nbErrors++;
- return(ret);
- }
+ 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;
+ 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:
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "attribute has invalid content\n");
- ctxt->nbErrors++;
- break;
- case XML_RELAXNG_NOOP:
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "RNG Internal error, noop found in attribute\n");
- ctxt->nbErrors++;
- break;
- }
- }
- child = child->next;
+ 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData, "attribute has multiple children\n");
- ctxt->nbErrors++;
+ xmlRngPErr(ctxt, node, XML_RNGP_ATTRIBUTE_CHILDREN,
+ "attribute has multiple children\n", NULL, NULL);
}
ctxt->flags = old_flags;
- return(ret);
+ return (ret);
}
/**
@@ -4975,57 +5099,53 @@
*/
static xmlRelaxNGDefinePtr
xmlRelaxNGParseExceptNameClass(xmlRelaxNGParserCtxtPtr ctxt,
- xmlNodePtr node, int attr) {
+ xmlNodePtr node, int attr)
+{
xmlRelaxNGDefinePtr ret, cur, last = NULL;
xmlNodePtr child;
if (!IS_RELAXNG(node, "except")) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Expecting an except node\n");
- ctxt->nbErrors++;
- return(NULL);
+ xmlRngPErr(ctxt, node, XML_RNGP_EXCEPT_MISSING,
+ "Expecting an except node\n", NULL, NULL);
+ return (NULL);
}
if (node->next != NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "exceptNameClass allows only a single except node\n");
- ctxt->nbErrors++;
+ xmlRngPErr(ctxt, node, XML_RNGP_EXCEPT_MULTIPLE,
+ "exceptNameClass allows only a single except node\n",
+ NULL, NULL);
}
if (node->children == NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "except has no content\n");
- ctxt->nbErrors++;
- return(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);
+ 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;
-
+ 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;
+ if (last == NULL) {
+ ret->content = cur;
+ } else {
+ last->next = cur;
+ }
+ last = cur;
+ }
+ child = child->next;
}
- return(ret);
+ return (ret);
}
/**
@@ -5040,142 +5160,137 @@
*/
static xmlRelaxNGDefinePtr
xmlRelaxNGParseNameClass(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node,
- xmlRelaxNGDefinePtr def) {
+ xmlRelaxNGDefinePtr def)
+{
xmlRelaxNGDefinePtr ret, tmp;
xmlChar *val;
ret = def;
- if ((IS_RELAXNG(node, "name")) || (IS_RELAXNG(node, "anyName")) ||
+ 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 ((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 (ctxt->error != NULL) {
- if (node->parent != NULL)
- ctxt->error(ctxt->userData,
- "Element %s name '%s' is not an NCName\n",
- node->parent->name, val);
- else
- ctxt->error(ctxt->userData,
- "name '%s' is not an NCName\n",
- val);
- }
- ctxt->nbErrors++;
- }
- 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"))) {
- ctxt->error(ctxt->userData,
- "Attribute with namespace '%s' is not allowed\n",
- val);
- ctxt->nbErrors++;
- }
- if ((ctxt->flags & XML_RELAXNG_IN_ATTRIBUTE) &&
- (val != NULL) &&
- (val[0] == 0) &&
- (xmlStrEqual(ret->name, BAD_CAST "xmlns"))) {
- ctxt->error(ctxt->userData,
- "Attribute with QName 'xmlns' is not allowed\n",
- val);
- ctxt->nbErrors++;
- }
+ val = xmlNodeGetContent(node);
+ xmlRelaxNGNormExtSpace(val);
+ if (xmlValidateNCName(val, 0)) {
+ if (ctxt->error != NULL) {
+ if (node->parent != NULL)
+ ctxt->error(ctxt->userData,
+ "Element %s name '%s' is not an NCName\n",
+ node->parent->name, val);
+ else
+ ctxt->error(ctxt->userData,
+ "name '%s' is not an NCName\n", val);
+ }
+ ctxt->nbErrors++;
+ }
+ 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"))) {
+ ctxt->error(ctxt->userData,
+ "Attribute with namespace '%s' is not allowed\n",
+ val);
+ ctxt->nbErrors++;
+ }
+ if ((ctxt->flags & XML_RELAXNG_IN_ATTRIBUTE) &&
+ (val != NULL) &&
+ (val[0] == 0) && (xmlStrEqual(ret->name, BAD_CAST "xmlns"))) {
+ ctxt->error(ctxt->userData,
+ "Attribute with QName 'xmlns' is not allowed\n",
+ val);
+ ctxt->nbErrors++;
+ }
} 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));
- }
+ 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "nsName has no ns attribute\n");
- ctxt->nbErrors++;
- }
- if ((ctxt->flags & XML_RELAXNG_IN_ATTRIBUTE) &&
- (ret->ns != NULL) &&
- (xmlStrEqual(ret->ns, BAD_CAST "http://www.w3.org/2000/xmlns"))) {
- ctxt->error(ctxt->userData,
- "Attribute with namespace '%s' is not allowed\n",
- ret->ns);
- ctxt->nbErrors++;
- }
- if (node->children != NULL) {
- ret->nameClass =
- xmlRelaxNGParseExceptNameClass(ctxt, node->children,
- (def->type == XML_RELAXNG_ATTRIBUTE));
- }
+ 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;
+ xmlNodePtr child;
+ xmlRelaxNGDefinePtr last = NULL;
- ret = xmlRelaxNGNewDefine(ctxt, node);
- if (ret == NULL)
- return(NULL);
- ret->parent = def;
- ret->type = XML_RELAXNG_CHOICE;
+ ret = xmlRelaxNGNewDefine(ctxt, node);
+ if (ret == NULL)
+ return (NULL);
+ ret->parent = def;
+ ret->type = XML_RELAXNG_CHOICE;
- if (node->children == NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Element choice is empty\n");
- ctxt->nbErrors++;
- } else {
+ 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;
- }
- }
+ 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 {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "expecting name, anyName, nsName or choice : got %s\n",
- node->name);
- ctxt->nbErrors++;
- return(NULL);
+ xmlRngPErr(ctxt, node, XML_RNGP_CHOICE_CONTENT,
+ "expecting name, anyName, nsName or choice : got %s\n",
+ 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;
- }
+ if (def->nameClass == NULL) {
+ def->nameClass = ret;
+ } else {
+ tmp = def->nameClass;
+ while (tmp->next != NULL) {
+ tmp = tmp->next;
+ }
+ tmp->next = ret;
+ }
}
- return(ret);
+ return (ret);
}
/**
@@ -5188,112 +5303,106 @@
* Returns the definition pointer or NULL in case of error.
*/
static xmlRelaxNGDefinePtr
-xmlRelaxNGParseElement(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node) {
+xmlRelaxNGParseElement(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
+{
xmlRelaxNGDefinePtr ret, cur, last;
xmlNodePtr child;
const xmlChar *olddefine;
ret = xmlRelaxNGNewDefine(ctxt, node);
if (ret == NULL)
- return(NULL);
+ return (NULL);
ret->type = XML_RELAXNG_ELEMENT;
ret->parent = ctxt->def;
child = node->children;
if (child == NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "xmlRelaxNGParseElement: element has no children\n");
- ctxt->nbErrors++;
- return(ret);
- }
+ 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;
+ child = child->next;
if (child == NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "xmlRelaxNGParseElement: element has no content\n");
- ctxt->nbErrors++;
- return(ret);
- }
+ 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:
- /* HERE !!! */
- cur->next = ret->attrs;
- ret->attrs = cur;
- break;
- case XML_RELAXNG_START:
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "RNG Internal error, start found in element\n");
- ctxt->nbErrors++;
- break;
- case XML_RELAXNG_PARAM:
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "RNG Internal error, param found in element\n");
- ctxt->nbErrors++;
- break;
- case XML_RELAXNG_EXCEPT:
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "RNG Internal error, except found in element\n");
- ctxt->nbErrors++;
- break;
- case XML_RELAXNG_NOOP:
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "RNG Internal error, noop found in element\n");
- ctxt->nbErrors++;
- break;
- }
- }
- child = child->next;
+ 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);
+ return (ret);
}
/**
@@ -5308,40 +5417,41 @@
*/
static xmlRelaxNGDefinePtr
xmlRelaxNGParsePatterns(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr nodes,
- int group) {
+ 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;
+ 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);
+ return (def);
}
/**
@@ -5354,58 +5464,52 @@
* Returns 0 in case of success, -1 in case of error
*/
static int
-xmlRelaxNGParseStart(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr nodes) {
+xmlRelaxNGParseStart(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr nodes)
+{
int ret = 0;
xmlRelaxNGDefinePtr def = NULL, last;
if (nodes == NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "start has no children\n");
- ctxt->nbErrors++;
- return(-1);
+ 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData, "element empty is not empty\n");
- ctxt->nbErrors++;
- }
+ 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "element notAllowed is not empty\n");
- ctxt->nbErrors++;
- }
+ 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);
+ def = xmlRelaxNGParsePatterns(ctxt, nodes, 1);
}
if (ctxt->grammar->start != NULL) {
- last = ctxt->grammar->start;
- while (last->next != NULL)
- last = last->next;
- last->next = def;
+ last = ctxt->grammar->start;
+ while (last->next != NULL)
+ last = last->next;
+ last->next = def;
} else {
- ctxt->grammar->start = def;
+ ctxt->grammar->start = def;
}
nodes = nodes->next;
if (nodes != NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "start more than one children\n");
- ctxt->nbErrors++;
- return(-1);
+ xmlRngPErr(ctxt, nodes, XML_RNGP_START_CONTENT,
+ "start more than one children\n", NULL, NULL);
+ return (-1);
}
- return(ret);
+ return (ret);
}
/**
@@ -5418,44 +5522,40 @@
* Returns 0 in case of success, -1 in case of error
*/
static int
-xmlRelaxNGParseGrammarContent(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr nodes)
+xmlRelaxNGParseGrammarContent(xmlRelaxNGParserCtxtPtr ctxt,
+ xmlNodePtr nodes)
{
int ret = 0, tmp;
if (nodes == NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "grammar has no children\n");
- ctxt->nbErrors++;
- return(-1);
+ 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "start has no children\n");
- ctxt->nbErrors++;
- } 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;
+ 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 {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "grammar has unexpected child %s\n", nodes->name);
- ctxt->nbErrors++;
- ret = -1;
- }
+ xmlRngPErr(ctxt, nodes, XML_RNGP_GRAMMAR_CONTENT,
+ "grammar has unexpected child %s\n", nodes->name,
+ NULL);
+ ret = -1;
+ }
nodes = nodes->next;
}
return (ret);
@@ -5472,48 +5572,42 @@
*/
static void
xmlRelaxNGCheckReference(xmlRelaxNGDefinePtr ref,
- xmlRelaxNGParserCtxtPtr ctxt, const xmlChar *name) {
+ xmlRelaxNGParserCtxtPtr ctxt,
+ const xmlChar * name)
+{
xmlRelaxNGGrammarPtr grammar;
xmlRelaxNGDefinePtr def, cur;
grammar = ctxt->grammar;
if (grammar == NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Internal error: no grammar in CheckReference %s\n",
- name);
- ctxt->nbErrors++;
- return;
+ xmlRngPErr(ctxt, ref->node, XML_ERR_INTERNAL_ERROR,
+ "Internal error: no grammar in CheckReference %s\n",
+ name, NULL);
+ return;
}
if (ref->content != NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Internal error: reference has content in CheckReference %s\n",
- name);
- ctxt->nbErrors++;
- return;
+ 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 {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Reference %s has no matching definition\n",
- name);
- ctxt->nbErrors++;
- }
+ 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 {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Reference %s has no matching definition\n",
- name);
- ctxt->nbErrors++;
+ xmlRngPErr(ctxt, ref->node, XML_RNGP_REF_NO_DEF,
+ "Reference %s has no matching definition\n", name,
+ NULL);
}
}
@@ -5528,120 +5622,112 @@
*/
static void
xmlRelaxNGCheckCombine(xmlRelaxNGDefinePtr define,
- xmlRelaxNGParserCtxtPtr ctxt, const xmlChar *name) {
+ xmlRelaxNGParserCtxtPtr ctxt, const xmlChar * name)
+{
xmlChar *combine;
int choiceOrInterleave = -1;
int missing = 0;
xmlRelaxNGDefinePtr cur, last, tmp, tmp2;
if (define->nextHash == NULL)
- return;
+ 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Defines for %s use both 'choice' and 'interleave'\n",
- name);
- ctxt->nbErrors++;
- }
- } else if (xmlStrEqual(combine, BAD_CAST "interleave")) {
- if (choiceOrInterleave == -1)
- choiceOrInterleave = 0;
- else if (choiceOrInterleave == 1) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Defines for %s use both 'choice' and 'interleave'\n",
- name);
- ctxt->nbErrors++;
- }
- } else {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Defines for %s use unknown combine value '%s''\n",
- name, combine);
- ctxt->nbErrors++;
- }
- xmlFree(combine);
- } else {
- if (missing == 0)
- missing = 1;
- else {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Some defines for %s needs the combine attribute\n",
- name);
- ctxt->nbErrors++;
- }
- }
+ 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;
+ cur = cur->nextHash;
}
#ifdef DEBUG
xmlGenericError(xmlGenericErrorContext,
- "xmlRelaxNGCheckCombine(): merging %s defines: %d\n",
- name, choiceOrInterleave);
+ "xmlRelaxNGCheckCombine(): merging %s defines: %d\n",
+ name, choiceOrInterleave);
#endif
if (choiceOrInterleave == -1)
- choiceOrInterleave = 0;
+ choiceOrInterleave = 0;
cur = xmlRelaxNGNewDefine(ctxt, define->node);
if (cur == NULL)
- return;
+ return;
if (choiceOrInterleave == 0)
- cur->type = XML_RELAXNG_INTERLEAVE;
+ cur->type = XML_RELAXNG_INTERLEAVE;
else
- cur->type = XML_RELAXNG_CHOICE;
+ 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;
+ 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Failed to create interleaves hash table\n");
- ctxt->nbErrors++;
- } else {
- char tmpname[32];
+ 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Failed to add %s to hash table\n", tmpname);
- ctxt->nbErrors++;
- }
- }
+ 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);
+ }
+ }
}
}
@@ -5655,7 +5741,8 @@
*/
static void
xmlRelaxNGCombineStart(xmlRelaxNGParserCtxtPtr ctxt,
- xmlRelaxNGGrammarPtr grammar) {
+ xmlRelaxNGGrammarPtr grammar)
+{
xmlRelaxNGDefinePtr starts;
xmlChar *combine;
int choiceOrInterleave = -1;
@@ -5664,94 +5751,88 @@
starts = grammar->start;
if ((starts == NULL) || (starts->next == NULL))
- return;
+ return;
cur = starts;
while (cur != NULL) {
- if ((cur->node == NULL) || (cur->node->parent == NULL) ||
- (!xmlStrEqual(cur->node->parent->name, BAD_CAST "start"))) {
- combine = NULL;
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Internal error: start element not found\n");
- ctxt->nbErrors++;
- } 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "<start> use both 'choice' and 'interleave'\n");
- ctxt->nbErrors++;
- }
- } else if (xmlStrEqual(combine, BAD_CAST "interleave")) {
- if (choiceOrInterleave == -1)
- choiceOrInterleave = 0;
- else if (choiceOrInterleave == 1) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "<start> use both 'choice' and 'interleave'\n");
- ctxt->nbErrors++;
- }
- } else {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "<start> uses unknown combine value '%s''\n", combine);
- ctxt->nbErrors++;
- }
- xmlFree(combine);
- } else {
- if (missing == 0)
- missing = 1;
- else {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Some <start> element miss the combine attribute\n");
- ctxt->nbErrors++;
- }
- }
+ 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");
+ }
- cur = cur->next;
+ 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);
+ "xmlRelaxNGCombineStart(): merging <start>: %d\n",
+ choiceOrInterleave);
#endif
if (choiceOrInterleave == -1)
- choiceOrInterleave = 0;
+ choiceOrInterleave = 0;
cur = xmlRelaxNGNewDefine(ctxt, starts->node);
if (cur == NULL)
- return;
+ return;
if (choiceOrInterleave == 0)
- cur->type = XML_RELAXNG_INTERLEAVE;
+ cur->type = XML_RELAXNG_INTERLEAVE;
else
- cur->type = XML_RELAXNG_CHOICE;
+ 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Failed to create interleaves hash table\n");
- ctxt->nbErrors++;
- } else {
- char tmpname[32];
+ 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Failed to add %s to hash table\n", tmpname);
- ctxt->nbErrors++;
- }
- }
+ 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);
+ }
+ }
}
}
@@ -5766,32 +5847,32 @@
* Returns 0 if check passed, and -1 in case of error
*/
static int
-xmlRelaxNGCheckCycles(xmlRelaxNGParserCtxtPtr ctxt,
- xmlRelaxNGDefinePtr cur, int depth) {
+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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Detected a cycle in %s references\n", cur->name);
- ctxt->nbErrors++;
- 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;
+ 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);
+ return (ret);
}
/**
@@ -5806,26 +5887,26 @@
* Returns the new prev definition
*/
static xmlRelaxNGDefinePtr
-xmlRelaxNGTryUnlink(xmlRelaxNGParserCtxtPtr ctxt ATTRIBUTE_UNUSED,
- xmlRelaxNGDefinePtr cur,
- xmlRelaxNGDefinePtr parent,
- xmlRelaxNGDefinePtr prev) {
+xmlRelaxNGTryUnlink(xmlRelaxNGParserCtxtPtr ctxt ATTRIBUTE_UNUSED,
+ xmlRelaxNGDefinePtr cur,
+ xmlRelaxNGDefinePtr parent, xmlRelaxNGDefinePtr prev)
+{
if (prev != NULL) {
- prev->next = cur->next;
+ 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;
- }
+ 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);
+ return (prev);
}
/**
@@ -5836,161 +5917,161 @@
* Check for simplification of empty and notAllowed
*/
static void
-xmlRelaxNGSimplify(xmlRelaxNGParserCtxtPtr ctxt,
- xmlRelaxNGDefinePtr cur,
- xmlRelaxNGDefinePtr parent) {
+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;
+ 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;
+ 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;
}
}
@@ -6005,18 +6086,19 @@
*/
static xmlRelaxNGContentType
xmlRelaxNGGroupContentType(xmlRelaxNGContentType ct1,
- xmlRelaxNGContentType ct2) {
+ xmlRelaxNGContentType ct2)
+{
if ((ct1 == XML_RELAXNG_CONTENT_ERROR) ||
- (ct2 == XML_RELAXNG_CONTENT_ERROR))
- return(XML_RELAXNG_CONTENT_ERROR);
+ (ct2 == XML_RELAXNG_CONTENT_ERROR))
+ return (XML_RELAXNG_CONTENT_ERROR);
if (ct1 == XML_RELAXNG_CONTENT_EMPTY)
- return(ct2);
+ return (ct2);
if (ct2 == XML_RELAXNG_CONTENT_EMPTY)
- return(ct1);
+ return (ct1);
if ((ct1 == XML_RELAXNG_CONTENT_COMPLEX) &&
- (ct2 == XML_RELAXNG_CONTENT_COMPLEX))
- return(XML_RELAXNG_CONTENT_COMPLEX);
- return(XML_RELAXNG_CONTENT_ERROR);
+ (ct2 == XML_RELAXNG_CONTENT_COMPLEX))
+ return (XML_RELAXNG_CONTENT_COMPLEX);
+ return (XML_RELAXNG_CONTENT_ERROR);
}
/**
@@ -6030,17 +6112,18 @@
*/
static xmlRelaxNGContentType
xmlRelaxNGMaxContentType(xmlRelaxNGContentType ct1,
- xmlRelaxNGContentType ct2) {
+ xmlRelaxNGContentType ct2)
+{
if ((ct1 == XML_RELAXNG_CONTENT_ERROR) ||
- (ct2 == XML_RELAXNG_CONTENT_ERROR))
- return(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);
+ (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);
+ (ct2 == XML_RELAXNG_CONTENT_COMPLEX))
+ return (XML_RELAXNG_CONTENT_COMPLEX);
+ return (XML_RELAXNG_CONTENT_EMPTY);
}
/**
@@ -6055,314 +6138,296 @@
* Returns the content type of @cur
*/
static xmlRelaxNGContentType
-xmlRelaxNGCheckRules(xmlRelaxNGParserCtxtPtr ctxt,
- xmlRelaxNGDefinePtr cur, int flags,
- xmlRelaxNGType ptype) {
+xmlRelaxNGCheckRules(xmlRelaxNGParserCtxtPtr ctxt,
+ xmlRelaxNGDefinePtr cur, int flags,
+ xmlRelaxNGType ptype)
+{
int nflags = flags;
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)) {
- if (flags & XML_RELAXNG_IN_LIST) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Found forbidden pattern list//ref\n");
- ctxt->nbErrors++;
- }
- if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Found forbidden pattern data/except//ref\n");
- ctxt->nbErrors++;
- }
- 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Found forbidden pattern data/except//element(ref)\n");
- ctxt->nbErrors++;
- }
- if (flags & XML_RELAXNG_IN_LIST) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Found forbidden pattern list//element(ref)\n");
- ctxt->nbErrors++;
- }
- if (flags & XML_RELAXNG_IN_ATTRIBUTE) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Found forbidden pattern attribute//element(ref)\n");
- ctxt->nbErrors++;
- }
- if (flags & XML_RELAXNG_IN_ATTRIBUTE) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Found forbidden pattern attribute//element(ref)\n");
- ctxt->nbErrors++;
- }
- /*
- * 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Element %s attributes have a content type error\n",
- cur->name);
- ctxt->nbErrors++;
- }
- ret = xmlRelaxNGCheckRules(ctxt, cur->content, nflags, cur->type);
- if (ret == XML_RELAXNG_CONTENT_ERROR) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Element %s has a content type error\n",
- cur->name);
- ctxt->nbErrors++;
- } else {
- ret = XML_RELAXNG_CONTENT_COMPLEX;
- }
- } else if (cur->type == XML_RELAXNG_ATTRIBUTE) {
- if (flags & XML_RELAXNG_IN_ATTRIBUTE) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Found forbidden pattern attribute//attribute\n");
- ctxt->nbErrors++;
- }
- if (flags & XML_RELAXNG_IN_LIST) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Found forbidden pattern list//attribute\n");
- ctxt->nbErrors++;
- }
- if (flags & XML_RELAXNG_IN_OOMGROUP) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Found forbidden pattern oneOrMore//group//attribute\n");
- ctxt->nbErrors++;
- }
- if (flags & XML_RELAXNG_IN_OOMINTERLEAVE) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Found forbidden pattern oneOrMore//interleave//attribute\n");
- ctxt->nbErrors++;
- }
- if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Found forbidden pattern data/except//attribute\n");
- ctxt->nbErrors++;
- }
- if (flags & XML_RELAXNG_IN_START) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Found forbidden pattern start//attribute\n");
- ctxt->nbErrors++;
- }
- if ((!(flags & XML_RELAXNG_IN_ONEORMORE)) && (cur->name == NULL)) {
- if (cur->ns == NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Found anyName attribute without oneOrMore ancestor\n");
- ctxt->nbErrors++;
- } else {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Found nsName attribute without oneOrMore ancestor\n");
- ctxt->nbErrors++;
- }
- }
- 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Found forbidden pattern data/except//oneOrMore\n");
- ctxt->nbErrors++;
- }
- if (flags & XML_RELAXNG_IN_START) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Found forbidden pattern start//oneOrMore\n");
- ctxt->nbErrors++;
- }
- 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Found forbidden pattern list//list\n");
- ctxt->nbErrors++;
- }
- if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Found forbidden pattern data/except//list\n");
- ctxt->nbErrors++;
- }
- if (flags & XML_RELAXNG_IN_START) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Found forbidden pattern start//list\n");
- ctxt->nbErrors++;
- }
- 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Found forbidden pattern data/except//group\n");
- ctxt->nbErrors++;
- }
- if (flags & XML_RELAXNG_IN_START) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Found forbidden pattern start//group\n");
- ctxt->nbErrors++;
- }
- 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Found forbidden pattern list//interleave\n");
- ctxt->nbErrors++;
- }
- if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Found forbidden pattern data/except//interleave\n");
- ctxt->nbErrors++;
- }
- if (flags & XML_RELAXNG_IN_START) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Found forbidden pattern start//interleave\n");
- ctxt->nbErrors++;
- }
- 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Found forbidden pattern start//data\n");
- ctxt->nbErrors++;
- }
- 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Found forbidden pattern start//value\n");
- ctxt->nbErrors++;
- }
- 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Found forbidden pattern list//text\n");
- ctxt->nbErrors++;
- }
- if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Found forbidden pattern data/except//text\n");
- ctxt->nbErrors++;
- }
- if (flags & XML_RELAXNG_IN_START) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Found forbidden pattern start//text\n");
- ctxt->nbErrors++;
- }
- ret = XML_RELAXNG_CONTENT_COMPLEX;
- } else if (cur->type == XML_RELAXNG_EMPTY) {
- if (flags & XML_RELAXNG_IN_DATAEXCEPT) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Found forbidden pattern data/except//empty\n");
- ctxt->nbErrors++;
- }
- if (flags & XML_RELAXNG_IN_START) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Found forbidden pattern start//empty\n");
- ctxt->nbErrors++;
- }
- 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) {
- 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);
- }
+ ret = XML_RELAXNG_CONTENT_EMPTY;
+ if ((cur->type == XML_RELAXNG_REF) ||
+ (cur->type == XML_RELAXNG_PARENTREF)) {
+ if (flags & XML_RELAXNG_IN_LIST) {
+ xmlRngPErr(ctxt, cur->node, XML_RNGP_PAT_LIST_REF,
+ "Found forbidden pattern list//ref\n", NULL,
+ NULL);
+ }
+ 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->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) {
+ 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);
+ return (val);
}
/**
@@ -6376,7 +6441,8 @@
* NULL in case of error
*/
static xmlRelaxNGGrammarPtr
-xmlRelaxNGParseGrammar(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr nodes) {
+xmlRelaxNGParseGrammar(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr nodes)
+{
xmlRelaxNGGrammarPtr ret, tmp, old;
#ifdef DEBUG_GRAMMAR
@@ -6385,21 +6451,21 @@
ret = xmlRelaxNGNewGrammar(ctxt);
if (ret == NULL)
- return(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;
- }
+ 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;
@@ -6407,15 +6473,11 @@
xmlRelaxNGParseGrammarContent(ctxt, nodes);
ctxt->grammar = ret;
if (ctxt->grammar == NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Failed to parse <grammar> content\n");
- ctxt->nbErrors++;
+ xmlRngPErr(ctxt, nodes, XML_RNGP_GRAMMAR_CONTENT,
+ "Failed to parse <grammar> content\n", NULL, NULL);
} else if (ctxt->grammar->start == NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Element <grammar> has no <start>\n");
- ctxt->nbErrors++;
+ xmlRngPErr(ctxt, nodes, XML_RNGP_GRAMMAR_NO_START,
+ "Element <grammar> has no <start>\n", NULL, NULL);
}
/*
@@ -6423,20 +6485,20 @@
*/
xmlRelaxNGCombineStart(ctxt, ret);
if (ret->defs != NULL) {
- xmlHashScan(ret->defs, (xmlHashScanner) xmlRelaxNGCheckCombine,
- ctxt);
+ xmlHashScan(ret->defs, (xmlHashScanner) xmlRelaxNGCheckCombine,
+ ctxt);
}
/*
* link together defines and refs in this grammar
*/
if (ret->refs != NULL) {
- xmlHashScan(ret->refs, (xmlHashScanner) xmlRelaxNGCheckReference,
- ctxt);
+ xmlHashScan(ret->refs, (xmlHashScanner) xmlRelaxNGCheckReference,
+ ctxt);
}
ctxt->grammar = old;
- return(ret);
+ return (ret);
}
/**
@@ -6451,7 +6513,8 @@
* NULL in case of error
*/
static xmlRelaxNGPtr
-xmlRelaxNGParseDocument(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node) {
+xmlRelaxNGParseDocument(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node)
+{
xmlRelaxNGPtr schema = NULL;
const xmlChar *olddefine;
xmlRelaxNGGrammarPtr old;
@@ -6461,53 +6524,53 @@
schema = xmlRelaxNGNewRelaxNG(ctxt);
if (schema == NULL)
- return(NULL);
+ return (NULL);
olddefine = ctxt->define;
ctxt->define = NULL;
if (IS_RELAXNG(node, "grammar")) {
- schema->topgrammar = xmlRelaxNGParseGrammar(ctxt, node->children);
+ schema->topgrammar = xmlRelaxNGParseGrammar(ctxt, node->children);
} else {
- xmlRelaxNGGrammarPtr tmp, ret;
+ xmlRelaxNGGrammarPtr tmp, ret;
- schema->topgrammar = ret = xmlRelaxNGNewGrammar(ctxt);
- if (schema->topgrammar == NULL) {
- return(schema);
- }
- /*
- * 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;
+ schema->topgrammar = ret = xmlRelaxNGNewGrammar(ctxt);
+ if (schema->topgrammar == NULL) {
+ return (schema);
+ }
+ /*
+ * 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);
- }
+ 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,
@@ -6533,20 +6596,21 @@
* Returns the parser context or NULL in case of error
*/
xmlRelaxNGParserCtxtPtr
-xmlRelaxNGNewParserCtxt(const char *URL) {
+xmlRelaxNGNewParserCtxt(const char *URL)
+{
xmlRelaxNGParserCtxtPtr ret;
if (URL == NULL)
- return(NULL);
+ return (NULL);
- ret = (xmlRelaxNGParserCtxtPtr) xmlMalloc(sizeof(xmlRelaxNGParserCtxt));
+ ret =
+ (xmlRelaxNGParserCtxtPtr) xmlMalloc(sizeof(xmlRelaxNGParserCtxt));
if (ret == NULL) {
- xmlGenericError(xmlGenericErrorContext,
- "Failed to allocate new schama parser context for %s\n", URL);
+ xmlRngPErrMemory(NULL, "building parser\n");
return (NULL);
}
memset(ret, 0, sizeof(xmlRelaxNGParserCtxt));
- ret->URL = xmlStrdup((const xmlChar *)URL);
+ ret->URL = xmlStrdup((const xmlChar *) URL);
ret->error = xmlGenericError;
ret->userData = xmlGenericErrorContext;
return (ret);
@@ -6563,16 +6627,17 @@
* Returns the parser context or NULL in case of error
*/
xmlRelaxNGParserCtxtPtr
-xmlRelaxNGNewMemParserCtxt(const char *buffer, int size) {
+xmlRelaxNGNewMemParserCtxt(const char *buffer, int size)
+{
xmlRelaxNGParserCtxtPtr ret;
if ((buffer == NULL) || (size <= 0))
- return(NULL);
+ return (NULL);
- ret = (xmlRelaxNGParserCtxtPtr) xmlMalloc(sizeof(xmlRelaxNGParserCtxt));
+ ret =
+ (xmlRelaxNGParserCtxtPtr) xmlMalloc(sizeof(xmlRelaxNGParserCtxt));
if (ret == NULL) {
- xmlGenericError(xmlGenericErrorContext,
- "Failed to allocate new schama parser context\n");
+ xmlRngPErrMemory(NULL, "building parser\n");
return (NULL);
}
memset(ret, 0, sizeof(xmlRelaxNGParserCtxt));
@@ -6594,20 +6659,21 @@
* Returns the parser context or NULL in case of error
*/
xmlRelaxNGParserCtxtPtr
-xmlRelaxNGNewDocParserCtxt(xmlDocPtr doc) {
+xmlRelaxNGNewDocParserCtxt(xmlDocPtr doc)
+{
xmlRelaxNGParserCtxtPtr ret;
xmlDocPtr copy;
if (doc == NULL)
- return(NULL);
+ return (NULL);
copy = xmlCopyDoc(doc, 1);
if (copy == NULL)
- return(NULL);
+ return (NULL);
- ret = (xmlRelaxNGParserCtxtPtr) xmlMalloc(sizeof(xmlRelaxNGParserCtxt));
+ ret =
+ (xmlRelaxNGParserCtxtPtr) xmlMalloc(sizeof(xmlRelaxNGParserCtxt));
if (ret == NULL) {
- xmlGenericError(xmlGenericErrorContext,
- "Failed to allocate new schama parser context\n");
+ xmlRngPErrMemory(NULL, "building parser\n");
return (NULL);
}
memset(ret, 0, sizeof(xmlRelaxNGParserCtxt));
@@ -6623,29 +6689,30 @@
* Free the resources associated to the schema parser context
*/
void
-xmlRelaxNGFreeParserCtxt(xmlRelaxNGParserCtxtPtr ctxt) {
+xmlRelaxNGFreeParserCtxt(xmlRelaxNGParserCtxtPtr ctxt)
+{
if (ctxt == NULL)
- return;
+ return;
if (ctxt->URL != NULL)
- xmlFree(ctxt->URL);
+ xmlFree(ctxt->URL);
if (ctxt->doc != NULL)
- xmlRelaxNGFreeDocument(ctxt->doc);
+ xmlRelaxNGFreeDocument(ctxt->doc);
if (ctxt->interleaves != NULL)
xmlHashFree(ctxt->interleaves, NULL);
if (ctxt->documents != NULL)
- xmlRelaxNGFreeDocumentList(ctxt->documents);
+ xmlRelaxNGFreeDocumentList(ctxt->documents);
if (ctxt->includes != NULL)
- xmlRelaxNGFreeIncludeList(ctxt->includes);
+ xmlRelaxNGFreeIncludeList(ctxt->includes);
if (ctxt->docTab != NULL)
- xmlFree(ctxt->docTab);
+ xmlFree(ctxt->docTab);
if (ctxt->incTab != NULL)
- xmlFree(ctxt->incTab);
+ xmlFree(ctxt->incTab);
if (ctxt->defTab != NULL) {
- int i;
+ int i;
- for (i = 0;i < ctxt->defNr;i++)
- xmlRelaxNGFreeDefine(ctxt->defTab[i]);
- xmlFree(ctxt->defTab);
+ for (i = 0; i < ctxt->defNr; i++)
+ xmlRelaxNGFreeDefine(ctxt->defTab[i]);
+ xmlFree(ctxt->defTab);
}
xmlFree(ctxt);
}
@@ -6658,41 +6725,47 @@
* The string is modified "in situ"
*/
static void
-xmlRelaxNGNormExtSpace(xmlChar *value) {
+xmlRelaxNGNormExtSpace(xmlChar * value)
+{
xmlChar *start = value;
xmlChar *cur = value;
- if (value == NULL)
- return;
- while (IS_BLANK(*cur)) cur++;
+ if (value == NULL)
+ return;
+
+ while (IS_BLANK(*cur))
+ cur++;
if (cur == start) {
- do {
- while ((*cur != 0) && (!IS_BLANK(*cur))) cur++;
- if (*cur == 0)
- return;
- start = cur;
- while (IS_BLANK(*cur)) cur++;
- if (*cur == 0) {
- *start = 0;
- return;
- }
- } while (1);
+ do {
+ while ((*cur != 0) && (!IS_BLANK(*cur)))
+ cur++;
+ if (*cur == 0)
+ return;
+ start = cur;
+ while (IS_BLANK(*cur))
+ cur++;
+ if (*cur == 0) {
+ *start = 0;
+ return;
+ }
+ } while (1);
} else {
- do {
- while ((*cur != 0) && (!IS_BLANK(*cur)))
- *start++ = *cur++;
- if (*cur == 0) {
- *start = 0;
- return;
- }
- /* don't try to normalize the inner spaces */
- while (IS_BLANK(*cur)) cur++;
- *start++ = *cur++;
- if (*cur == 0) {
- *start = 0;
- return;
- }
- } while (1);
+ do {
+ while ((*cur != 0) && (!IS_BLANK(*cur)))
+ *start++ = *cur++;
+ if (*cur == 0) {
+ *start = 0;
+ return;
+ }
+ /* don't try to normalize the inner spaces */
+ while (IS_BLANK(*cur))
+ cur++;
+ *start++ = *cur++;
+ if (*cur == 0) {
+ *start = 0;
+ return;
+ }
+ } while (1);
}
}
@@ -6704,97 +6777,82 @@
* Check all the attributes on the given node
*/
static void
-xmlRelaxNGCleanupAttributes(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr node) {
+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"))) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Attribute %s is not allowed on %s\n",
- cur->name, node->name);
- ctxt->nbErrors++;
- }
- } else if (xmlStrEqual(cur->name, BAD_CAST "type")) {
- if ((!xmlStrEqual(node->name, BAD_CAST "value")) &&
- (!xmlStrEqual(node->name, BAD_CAST "data"))) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Attribute %s is not allowed on %s\n",
- cur->name, node->name);
- ctxt->nbErrors++;
- }
- } else if (xmlStrEqual(cur->name, BAD_CAST "href")) {
- if ((!xmlStrEqual(node->name, BAD_CAST "externalRef")) &&
- (!xmlStrEqual(node->name, BAD_CAST "include"))) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Attribute %s is not allowed on %s\n",
- cur->name, node->name);
- ctxt->nbErrors++;
- }
- } else if (xmlStrEqual(cur->name, BAD_CAST "combine")) {
- if ((!xmlStrEqual(node->name, BAD_CAST "start")) &&
- (!xmlStrEqual(node->name, BAD_CAST "define"))) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Attribute %s is not allowed on %s\n",
- cur->name, node->name);
- ctxt->nbErrors++;
- }
- } else if (xmlStrEqual(cur->name, BAD_CAST "datatypeLibrary")) {
- xmlChar *val;
- xmlURIPtr uri;
+ 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Attribute %s contains invalid URI %s\n",
- cur->name, val);
- ctxt->nbErrors++;
- } else {
- if (uri->scheme == NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Attribute %s URI %s is not absolute\n",
- cur->name, val);
- ctxt->nbErrors++;
- }
- if (uri->fragment != NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Attribute %s URI %s has a fragment ID\n",
- cur->name, val);
- ctxt->nbErrors++;
- }
- xmlFreeURI(uri);
- }
- }
- xmlFree(val);
- }
- } else if (!xmlStrEqual(cur->name, BAD_CAST "ns")) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Unknown attribute %s on %s\n",
- cur->name, node->name);
- ctxt->nbErrors++;
- }
- }
- cur = next;
+ 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;
}
}
@@ -6807,387 +6865,387 @@
* Include and externalRef lookups.
*/
static void
-xmlRelaxNGCleanupTree(xmlRelaxNGParserCtxtPtr ctxt, xmlNodePtr root) {
+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")))) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "element %s doesn't allow foreign elements\n",
- cur->parent->name);
- ctxt->nbErrors++;
- }
- 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;
+ 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;
- 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "xmlRelaxNGParse: externalRef has no href attribute\n");
- ctxt->nbErrors++;
- delete = cur;
- goto skip_children;
- }
- base = xmlNodeGetBase(cur->doc, cur);
- URL = xmlBuildURI(href, base);
- if (URL == NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Failed to compute URL for externalRef %s\n", href);
- ctxt->nbErrors++;
- 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Failed to load externalRef %s\n", URL);
- ctxt->nbErrors++;
- xmlFree(URL);
- delete = cur;
- goto skip_children;
- }
- if (ns != NULL)
- xmlFree(ns);
- xmlFree(URL);
- cur->_private = docu;
- } else if (xmlStrEqual(cur->name, BAD_CAST "include")) {
- xmlChar *href, *ns, *base, *URL;
- xmlRelaxNGIncludePtr incl;
- xmlNodePtr tmp;
+ 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);
+ 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 externalRef %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);
+ docu = xmlRelaxNGLoadExternalRef(ctxt, URL, ns);
+ if (docu == NULL) {
+ xmlRngPErr(ctxt, cur, XML_RNGP_EXTERNAL_REF_FAILURE,
+ "Failed to load externalRef %s\n", URL,
+ NULL);
+ xmlFree(URL);
+ delete = cur;
+ goto skip_children;
+ }
+ if (ns != NULL)
+ xmlFree(ns);
+ xmlFree(URL);
+ cur->_private = 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "xmlRelaxNGParse: include has no href attribute\n");
- ctxt->nbErrors++;
- delete = cur;
- goto skip_children;
- }
- base = xmlNodeGetBase(cur->doc, cur);
- URL = xmlBuildURI(href, base);
- if (URL == NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Failed to compute URL for include %s\n", href);
- ctxt->nbErrors++;
- 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Failed to load include %s\n", URL);
- ctxt->nbErrors++;
- xmlFree(URL);
- delete = cur;
- goto skip_children;
- }
- xmlFree(URL);
- cur->_private = 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 = xmlNewNode(cur->ns, BAD_CAST "name");
- if (node != NULL) {
- xmlAddPrevSibling(cur->children, node);
- text = xmlNewText(name);
- xmlAddChild(node, text);
- text = node;
- }
- }
- if (text == NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Failed to create a name %s element\n", name);
- ctxt->nbErrors++;
- }
- 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;
+ 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->_private = incl;
+ } else if ((xmlStrEqual(cur->name, BAD_CAST "element")) ||
+ (xmlStrEqual(cur->name, BAD_CAST "attribute")))
+ {
+ xmlChar *name, *ns;
+ xmlNodePtr text = 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.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;
- /*
- * Simplification: 4.10. QNames
- */
- name = xmlNodeGetContent(cur);
- if (name != NULL) {
- local = xmlSplitQName2(name, &prefix);
- if (local != NULL) {
- xmlNsPtr ns;
+ node = xmlNewNode(cur->ns, BAD_CAST "name");
+ 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;
- ns = xmlSearchNs(cur->doc, cur, prefix);
- if (ns == NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "xmlRelaxNGParse: no namespace for prefix %s\n", prefix);
- ctxt->nbErrors++;
- } 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Found nsName/except//nsName forbidden construct\n");
- ctxt->nbErrors++;
- }
- }
- } else if ((xmlStrEqual(cur->name, BAD_CAST "except")) &&
- (cur != root)) {
- int oldflags = ctxt->flags;
+ 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;
- /*
- * 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) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Found anyName/except//anyName forbidden construct\n");
- ctxt->nbErrors++;
- } else if (ctxt->flags & XML_RELAXNG_IN_NSEXCEPT) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "Found nsName/except//anyName forbidden construct\n");
- ctxt->nbErrors++;
- }
- }
- /*
- * Thisd is not an else since "include" is transformed
- * into a div
- */
- if (xmlStrEqual(cur->name, BAD_CAST "div")) {
- xmlChar *ns;
- xmlNodePtr child, ins, tmp;
+ /*
+ * Simplification: 4.10. QNames
+ */
+ name = xmlNodeGetContent(cur);
+ if (name != NULL) {
+ local = xmlSplitQName2(name, &prefix);
+ if (local != NULL) {
+ xmlNsPtr ns;
- /*
- * implements rule 4.11
- */
+ 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;
- ns = xmlGetProp(cur, BAD_CAST "ns");
+ /*
+ * 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);
+ }
+ }
+ /*
+ * Thisd is not an else since "include" is transformed
+ * into a div
+ */
+ if (xmlStrEqual(cur->name, BAD_CAST "div")) {
+ xmlChar *ns;
+ xmlNodePtr child, ins, tmp;
- 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);
- 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->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;
- }
+ /*
+ * implements rule 4.11
+ */
- /*
- * 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);
+ 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);
+ 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->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;
+ xmlUnlinkNode(delete);
+ xmlFreeNode(delete);
+ delete = NULL;
}
}
@@ -7202,7 +7260,8 @@
* Returns the cleaned up document or NULL in case of error
*/
static xmlDocPtr
-xmlRelaxNGCleanupDoc(xmlRelaxNGParserCtxtPtr ctxt, xmlDocPtr doc) {
+xmlRelaxNGCleanupDoc(xmlRelaxNGParserCtxtPtr ctxt, xmlDocPtr doc)
+{
xmlNodePtr root;
/*
@@ -7210,14 +7269,12 @@
*/
root = xmlDocGetRootElement(doc);
if (root == NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData, "xmlRelaxNGParse: %s is empty\n",
- ctxt->URL);
- ctxt->nbErrors++;
+ xmlRngPErr(ctxt, (xmlNodePtr) doc, XML_RNGP_EMPTY, "xmlRelaxNGParse: %s is empty\n",
+ ctxt->URL, NULL);
return (NULL);
}
xmlRelaxNGCleanupTree(ctxt, root);
- return(doc);
+ return (doc);
}
/**
@@ -7247,33 +7304,29 @@
* First step is to parse the input document into an DOM/Infoset
*/
if (ctxt->URL != NULL) {
- doc = xmlParseFile((const char *) ctxt->URL);
- if (doc == NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "xmlRelaxNGParse: could not load %s\n", ctxt->URL);
- ctxt->nbErrors++;
- return (NULL);
- }
+ doc = xmlParseFile((const char *) ctxt->URL);
+ 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 = xmlParseMemory(ctxt->buffer, ctxt->size);
- if (doc == NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "xmlRelaxNGParse: could not parse schemas\n");
- ctxt->nbErrors++;
- return (NULL);
- }
- doc->URL = xmlStrdup(BAD_CAST "in_memory_buffer");
- ctxt->URL = xmlStrdup(BAD_CAST "in_memory_buffer");
+ doc = xmlParseMemory(ctxt->buffer, ctxt->size);
+ 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 {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData,
- "xmlRelaxNGParse: nothing to parse\n");
- ctxt->nbErrors++;
- return (NULL);
+ xmlRngPErr(ctxt, NULL, XML_RNGP_EMPTY,
+ "xmlRelaxNGParse: nothing to parse\n", NULL, NULL);
+ return (NULL);
}
ctxt->document = doc;
@@ -7282,9 +7335,9 @@
*/
doc = xmlRelaxNGCleanupDoc(ctxt, doc);
if (doc == NULL) {
- xmlFreeDoc(ctxt->document);
- ctxt->document = NULL;
- return(NULL);
+ xmlFreeDoc(ctxt->document);
+ ctxt->document = NULL;
+ return (NULL);
}
/*
@@ -7292,17 +7345,16 @@
*/
root = xmlDocGetRootElement(doc);
if (root == NULL) {
- if (ctxt->error != NULL)
- ctxt->error(ctxt->userData, "xmlRelaxNGParse: %s is empty\n",
- ctxt->URL);
- ctxt->nbErrors++;
- xmlFreeDoc(doc);
+ xmlRngPErr(ctxt, (xmlNodePtr) doc,
+ XML_RNGP_EMPTY, "xmlRelaxNGParse: %s is empty\n",
+ ctxt->URL, NULL);
+ xmlFreeDoc(doc);
return (NULL);
}
ret = xmlRelaxNGParseDocument(ctxt, root);
if (ret == NULL) {
- xmlFreeDoc(doc);
- return(NULL);
+ xmlFreeDoc(doc);
+ return (NULL);
}
/*
@@ -7312,18 +7364,18 @@
* try to preprocess interleaves
*/
if (ctxt->interleaves != NULL) {
- xmlHashScan(ctxt->interleaves,
- (xmlHashScanner)xmlRelaxNGComputeInterleaves, ctxt);
+ 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);
+ xmlRelaxNGFree(ret);
+ ctxt->document = NULL;
+ xmlFreeDoc(doc);
+ return (NULL);
}
/*
@@ -7331,16 +7383,16 @@
*/
if ((ret->topgrammar != NULL) && (ret->topgrammar->start != NULL)) {
if (ret->topgrammar->start->type != XML_RELAXNG_START) {
- xmlRelaxNGDefinePtr def;
+ 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);
+ 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);
}
/*
@@ -7350,18 +7402,18 @@
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;
+ ret->idref = 1;
return (ret);
}
-
+
/**
* xmlRelaxNGSetParserErrors:
* @ctxt: a Relax-NG validation context
@@ -7373,10 +7425,11 @@
*/
void
xmlRelaxNGSetParserErrors(xmlRelaxNGParserCtxtPtr ctxt,
- xmlRelaxNGValidityErrorFunc err,
- xmlRelaxNGValidityWarningFunc warn, void *ctx) {
+ xmlRelaxNGValidityErrorFunc err,
+ xmlRelaxNGValidityWarningFunc warn, void *ctx)
+{
if (ctxt == NULL)
- return;
+ return;
ctxt->error = err;
ctxt->warning = warn;
ctxt->userData = ctx;
@@ -7395,23 +7448,29 @@
*/
int
xmlRelaxNGGetParserErrors(xmlRelaxNGParserCtxtPtr ctxt,
- xmlRelaxNGValidityErrorFunc *err,
- xmlRelaxNGValidityWarningFunc *warn, void **ctx) {
+ 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);
+ return (-1);
+ if (err != NULL)
+ *err = ctxt->error;
+ if (warn != NULL)
+ *warn = ctxt->warning;
+ if (ctx != NULL)
+ *ctx = ctxt->userData;
+ return (0);
}
#ifdef LIBXML_OUTPUT_ENABLED
+
/************************************************************************
* *
* Dump back a compiled form *
* *
************************************************************************/
-static void xmlRelaxNGDumpDefine(FILE * output, xmlRelaxNGDefinePtr define);
+static void xmlRelaxNGDumpDefine(FILE * output,
+ xmlRelaxNGDefinePtr define);
/**
* xmlRelaxNGDumpDefines:
@@ -7421,10 +7480,11 @@
* Dump a RelaxNG structure back
*/
static void
-xmlRelaxNGDumpDefines(FILE * output, xmlRelaxNGDefinePtr defines) {
+xmlRelaxNGDumpDefines(FILE * output, xmlRelaxNGDefinePtr defines)
+{
while (defines != NULL) {
- xmlRelaxNGDumpDefine(output, defines);
- defines = defines->next;
+ xmlRelaxNGDumpDefine(output, defines);
+ defines = defines->next;
}
}
@@ -7436,115 +7496,114 @@
* Dump a RelaxNG structure back
*/
static void
-xmlRelaxNGDumpDefine(FILE * output, xmlRelaxNGDefinePtr define) {
+xmlRelaxNGDumpDefine(FILE * output, xmlRelaxNGDefinePtr define)
+{
if (define == NULL)
- return;
- switch(define->type) {
+ return;
+ switch (define->type) {
case XML_RELAXNG_EMPTY:
- fprintf(output, "<empty/>\n");
- break;
+ fprintf(output, "<empty/>\n");
+ break;
case XML_RELAXNG_NOT_ALLOWED:
- fprintf(output, "<notAllowed/>\n");
- break;
+ fprintf(output, "<notAllowed/>\n");
+ break;
case XML_RELAXNG_TEXT:
- fprintf(output, "<text/>\n");
- break;
+ 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;
+ 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;
+ 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;
+ 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;
+ 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;
+ 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;
+ 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;
+ 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;
+ 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;
+ 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;
+ 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;
+ 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;
+ 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
@@ -7557,31 +7616,30 @@
xmlRelaxNGDumpGrammar(FILE * output, xmlRelaxNGGrammarPtr grammar, int top)
{
if (grammar == NULL)
- return;
-
+ 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, " 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 -->");
+ fprintf(output, " <!-- grammar had no start -->");
} else {
- fprintf(output, "<start>\n");
- xmlRelaxNGDumpDefine(output, grammar->start);
- fprintf(output, "</start>\n");
+ fprintf(output, "<start>\n");
+ xmlRelaxNGDumpDefine(output, grammar->start);
+ fprintf(output, "</start>\n");
}
/* TODO ? Dump the defines ? */
fprintf(output, "</grammar>\n");
@@ -7598,20 +7656,20 @@
xmlRelaxNGDump(FILE * output, xmlRelaxNGPtr schema)
{
if (schema == NULL) {
- fprintf(output, "RelaxNG empty or failed to compile\n");
- return;
+ fprintf(output, "RelaxNG empty or failed to compile\n");
+ return;
}
fprintf(output, "RelaxNG: ");
if (schema->doc == NULL) {
- fprintf(output, "no document\n");
+ fprintf(output, "no document\n");
} else if (schema->doc->URL != NULL) {
- fprintf(output, "%s\n", schema->doc->URL);
+ fprintf(output, "%s\n", schema->doc->URL);
} else {
- fprintf(output, "\n");
+ fprintf(output, "\n");
}
if (schema->topgrammar == NULL) {
- fprintf(output, "RelaxNG has no top grammar\n");
- return;
+ fprintf(output, "RelaxNG has no top grammar\n");
+ return;
}
xmlRelaxNGDumpGrammar(output, schema->topgrammar, 1);
}
@@ -7627,13 +7685,13 @@
xmlRelaxNGDumpTree(FILE * output, xmlRelaxNGPtr schema)
{
if (schema == NULL) {
- fprintf(output, "RelaxNG empty or failed to compile\n");
- return;
+ fprintf(output, "RelaxNG empty or failed to compile\n");
+ return;
}
if (schema->doc == NULL) {
- fprintf(output, "no document\n");
+ fprintf(output, "no document\n");
} else {
- xmlDocDump(output, schema->doc);
+ xmlDocDump(output, schema->doc);
}
}
#endif /* LIBXML_OUTPUT_ENABLED */
@@ -7643,8 +7701,8 @@
* Validation of compiled content *
* *
************************************************************************/
-static int xmlRelaxNGValidateDefinition(xmlRelaxNGValidCtxtPtr ctxt,
- xmlRelaxNGDefinePtr define);
+static int xmlRelaxNGValidateDefinition(xmlRelaxNGValidCtxtPtr ctxt,
+ xmlRelaxNGDefinePtr define);
/**
* xmlRelaxNGValidateCompiledCallback:
@@ -7655,43 +7713,43 @@
*
* Handle the callback and if needed validate the element children.
*/
-static void
+static void
xmlRelaxNGValidateCompiledCallback(xmlRegExecCtxtPtr exec ATTRIBUTE_UNUSED,
- const xmlChar *token,
- void *transdata,
- void *inputdata) {
+ 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);
+ "Compiled callback for: '%s'\n", token);
#endif
if (ctxt == NULL) {
- fprintf(stderr, "callback on %s missing context\n", token);
- if ((ctxt != NULL) && (ctxt->errNo == XML_RELAXNG_OK))
- ctxt->errNo = XML_RELAXNG_ERR_INTERNAL;
- return;
+ fprintf(stderr, "callback on %s missing context\n", token);
+ if ((ctxt != NULL) && (ctxt->errNo == XML_RELAXNG_OK))
+ ctxt->errNo = XML_RELAXNG_ERR_INTERNAL;
+ 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;
+ 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;
+ 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;
+ 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)
@@ -7710,62 +7768,65 @@
*/
static int
xmlRelaxNGValidateCompiledContent(xmlRelaxNGValidCtxtPtr ctxt,
- xmlRegexpPtr regexp, xmlNodePtr content) {
+ xmlRegexpPtr regexp, xmlNodePtr content)
+{
xmlRegExecCtxtPtr exec;
xmlNodePtr cur;
int ret = 0;
int oldperr = ctxt->perr;
if ((ctxt == NULL) || (regexp == NULL))
- return(-1);
- exec = xmlRegNewExecCtxt(regexp,
+ return (-1);
+ 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;
+ 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;
+ 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);
+ * 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;
}
@@ -7778,7 +7839,7 @@
ret = ctxt->perr;
}
ctxt->perr = oldperr;
- return(ret);
+ return (ret);
}
/************************************************************************
@@ -7786,9 +7847,10 @@
* Progressive validation of when possible *
* *
************************************************************************/
-static int xmlRelaxNGValidateAttributeList(xmlRelaxNGValidCtxtPtr ctxt,
- xmlRelaxNGDefinePtr defines);
-static int xmlRelaxNGValidateElementEnd(xmlRelaxNGValidCtxtPtr ctxt, int log);
+static int xmlRelaxNGValidateAttributeList(xmlRelaxNGValidCtxtPtr ctxt,
+ xmlRelaxNGDefinePtr defines);
+static int xmlRelaxNGValidateElementEnd(xmlRelaxNGValidCtxtPtr ctxt,
+ int log);
static void xmlRelaxNGLogBestError(xmlRelaxNGValidCtxtPtr ctxt);
/**
@@ -7801,28 +7863,32 @@
* Returns 0 in case of success and -1 in case of error.
*/
static int
-xmlRelaxNGElemPush(xmlRelaxNGValidCtxtPtr ctxt, xmlRegExecCtxtPtr exec) {
+xmlRelaxNGElemPush(xmlRelaxNGValidCtxtPtr ctxt, xmlRegExecCtxtPtr exec)
+{
if (ctxt->elemTab == NULL) {
- ctxt->elemMax = 10;
- ctxt->elemTab = (xmlRegExecCtxtPtr *) xmlMalloc(ctxt->elemMax *
- sizeof(xmlRegExecCtxtPtr));
+ ctxt->elemMax = 10;
+ ctxt->elemTab = (xmlRegExecCtxtPtr *) xmlMalloc(ctxt->elemMax *
+ sizeof
+ (xmlRegExecCtxtPtr));
if (ctxt->elemTab == NULL) {
- VALID_ERR(XML_RELAXNG_ERR_MEMORY);
- return(-1);
- }
+ xmlRngVErrMemory(ctxt, "validating\n");
+ return (-1);
+ }
}
if (ctxt->elemNr >= ctxt->elemMax) {
- ctxt->elemMax *= 2;
+ ctxt->elemMax *= 2;
ctxt->elemTab = (xmlRegExecCtxtPtr *) xmlRealloc(ctxt->elemTab,
- ctxt->elemMax * sizeof(xmlRegExecCtxtPtr));
+ ctxt->elemMax *
+ sizeof
+ (xmlRegExecCtxtPtr));
if (ctxt->elemTab == NULL) {
- VALID_ERR(XML_RELAXNG_ERR_MEMORY);
- return(-1);
- }
+ xmlRngVErrMemory(ctxt, "validating\n");
+ return (-1);
+ }
}
ctxt->elemTab[ctxt->elemNr++] = exec;
ctxt->elem = exec;
- return(0);
+ return (0);
}
/**
@@ -7834,18 +7900,20 @@
* Returns the exec or NULL if empty
*/
static xmlRegExecCtxtPtr
-xmlRelaxNGElemPop(xmlRelaxNGValidCtxtPtr ctxt) {
+xmlRelaxNGElemPop(xmlRelaxNGValidCtxtPtr ctxt)
+{
xmlRegExecCtxtPtr ret;
- if (ctxt->elemNr <= 0) return(NULL);
+ if (ctxt->elemNr <= 0)
+ return (NULL);
ctxt->elemNr--;
ret = ctxt->elemTab[ctxt->elemNr];
ctxt->elemTab[ctxt->elemNr] = NULL;
- if (ctxt->elemNr > 0)
+ if (ctxt->elemNr > 0)
ctxt->elem = ctxt->elemTab[ctxt->elemNr - 1];
else
- ctxt->elem = NULL;
- return(ret);
+ ctxt->elem = NULL;
+ return (ret);
}
/**
@@ -7858,11 +7926,12 @@
* 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) {
+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;
@@ -7871,60 +7940,60 @@
#ifdef DEBUG_PROGRESSIVE
xmlGenericError(xmlGenericErrorContext,
- "Progressive callback for: '%s'\n", token);
+ "Progressive callback for: '%s'\n", token);
#endif
if (ctxt == NULL) {
- fprintf(stderr, "callback on %s missing context\n", token);
- return;
+ fprintf(stderr, "callback on %s missing context\n", token);
+ return;
}
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;
+ 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;
+ 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;
+ 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;
+ 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
- */
+ * this node cannot be validated in a streamable fashion
+ */
#ifdef DEBUG_PROGRESSIVE
- xmlGenericError(xmlGenericErrorContext,
- "Element '%s' validation is not streamable\n", token);
+ xmlGenericError(xmlGenericErrorContext,
+ "Element '%s' validation is not streamable\n",
+ token);
#endif
- ctxt->pstate = 0;
- ctxt->pdef = define;
- return;
+ ctxt->pstate = 0;
+ ctxt->pdef = define;
+ return;
}
exec = xmlRegNewExecCtxt(define->contModel,
- xmlRelaxNGValidateProgressiveCallback,
- ctxt);
+ xmlRelaxNGValidateProgressiveCallback, ctxt);
if (exec == NULL) {
- ctxt->pstate = -1;
- return;
+ ctxt->pstate = -1;
+ return;
}
xmlRelaxNGElemPush(ctxt, exec);
@@ -7933,61 +8002,60 @@
*/
state = xmlRelaxNGNewValidState(ctxt, node);
if (state == NULL) {
- ctxt->pstate = -1;
- return;
+ 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);
- }
+ 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);
+ 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;
+ 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;
+ 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 (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);
- }
+ if ((ctxt->flags & FLAGS_IGNORABLE) == 0) {
+ xmlRelaxNGDumpValidError(ctxt);
+ }
}
ctxt->state = oldstate;
}
@@ -8034,7 +8102,7 @@
}
define = grammar->start;
if (define->contModel == NULL) {
- ctxt->pdef = define;
+ ctxt->pdef = define;
return (0);
}
exec = xmlRegNewExecCtxt(define->contModel,
@@ -8058,16 +8126,16 @@
VALID_ERR2(XML_RELAXNG_ERR_ELEMWRONG, elem->name);
} else {
if (ctxt->pstate == 0)
- ret = 0;
+ ret = 0;
else if (ctxt->pstate < 0)
- ret = -1;
- else
- ret = 1;
+ ret = -1;
+ else
+ ret = 1;
}
#ifdef DEBUG_PROGRESSIVE
if (ret < 0)
- xmlGenericError(xmlGenericErrorContext, "PushElem %s failed\n",
- elem->name);
+ xmlGenericError(xmlGenericErrorContext, "PushElem %s failed\n",
+ elem->name);
#endif
return (ret);
}
@@ -8084,8 +8152,7 @@
*/
int
xmlRelaxNGValidatePushCData(xmlRelaxNGValidCtxtPtr ctxt,
- const xmlChar * data,
- int len ATTRIBUTE_UNUSED)
+ const xmlChar * data, int len ATTRIBUTE_UNUSED)
{
int ret = 1;
@@ -8102,18 +8169,18 @@
data++;
}
if (*data == 0)
- return(1);
+ 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");
+ xmlGenericError(xmlGenericErrorContext, "CDATA failed\n");
#endif
- return(-1);
+ return (-1);
}
- return(1);
+ return (1);
}
/**
@@ -8129,11 +8196,13 @@
int
xmlRelaxNGValidatePopElement(xmlRelaxNGValidCtxtPtr ctxt,
xmlDocPtr doc ATTRIBUTE_UNUSED,
- xmlNodePtr elem) {
+ xmlNodePtr elem)
+{
int ret;
xmlRegExecCtxtPtr exec;
- if ((ctxt == NULL) || (ctxt->elem == NULL) || (elem == NULL)) return(-1);
+ if ((ctxt == NULL) || (ctxt->elem == NULL) || (elem == NULL))
+ return (-1);
#ifdef DEBUG_PROGRESSIVE
xmlGenericError(xmlGenericErrorContext, "PopElem %s\n", elem->name);
#endif
@@ -8144,10 +8213,10 @@
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;
+ * 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 {
@@ -8156,10 +8225,10 @@
xmlRegFreeExecCtxt(exec);
#ifdef DEBUG_PROGRESSIVE
if (ret < 0)
- xmlGenericError(xmlGenericErrorContext, "PopElem %s failed\n",
- elem->name);
+ xmlGenericError(xmlGenericErrorContext, "PopElem %s failed\n",
+ elem->name);
#endif
- return(ret);
+ return (ret);
}
/**
@@ -8176,32 +8245,36 @@
int
xmlRelaxNGValidateFullElement(xmlRelaxNGValidCtxtPtr ctxt,
xmlDocPtr doc ATTRIBUTE_UNUSED,
- xmlNodePtr elem) {
+ xmlNodePtr elem)
+{
int ret;
xmlRelaxNGValidStatePtr state;
- if ((ctxt == NULL) || (ctxt->pdef == NULL) || (elem == NULL)) return(-1);
+ 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);
+ 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;
+ if ((ret != 0) || (ctxt->errNo != XML_RELAXNG_OK))
+ ret = -1;
+ else
+ ret = 1;
xmlRelaxNGFreeValidState(ctxt, state);
ctxt->state = NULL;
#ifdef DEBUG_PROGRESSIVE
if (ret < 0)
- xmlGenericError(xmlGenericErrorContext, "FullElem %s failed\n",
- elem->name);
+ xmlGenericError(xmlGenericErrorContext, "FullElem %s failed\n",
+ elem->name);
#endif
- return(ret);
+ return (ret);
}
/************************************************************************
@@ -8209,8 +8282,8 @@
* Generic interpreted validation implementation *
* *
************************************************************************/
-static int xmlRelaxNGValidateValue(xmlRelaxNGValidCtxtPtr ctxt,
- xmlRelaxNGDefinePtr define);
+static int xmlRelaxNGValidateValue(xmlRelaxNGValidCtxtPtr ctxt,
+ xmlRelaxNGDefinePtr define);
/**
* xmlRelaxNGSkipIgnored:
@@ -8223,20 +8296,21 @@
*/
static xmlNodePtr
xmlRelaxNGSkipIgnored(xmlRelaxNGValidCtxtPtr ctxt ATTRIBUTE_UNUSED,
- xmlNodePtr node) {
+ xmlNodePtr node)
+{
/*
* TODO complete and handle entities
*/
while ((node != NULL) &&
- ((node->type == XML_COMMENT_NODE) ||
- (node->type == XML_PI_NODE) ||
- (((node->type == XML_TEXT_NODE) ||
- (node->type == XML_CDATA_SECTION_NODE)) &&
- ((ctxt->flags & FLAGS_MIXED_CONTENT) ||
- (IS_BLANK_NODE(node)))))) {
- node = node->next;
+ ((node->type == XML_COMMENT_NODE) ||
+ (node->type == XML_PI_NODE) ||
+ (((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);
+ return (node);
}
/**
@@ -8250,40 +8324,39 @@
* Returns the new string or NULL in case of error.
*/
static xmlChar *
-xmlRelaxNGNormalize(xmlRelaxNGValidCtxtPtr ctxt, const xmlChar *str) {
+xmlRelaxNGNormalize(xmlRelaxNGValidCtxtPtr ctxt, const xmlChar * str)
+{
xmlChar *ret, *p;
const xmlChar *tmp;
int len;
-
+
if (str == NULL)
- return(NULL);
+ return (NULL);
tmp = str;
- while (*tmp != 0) tmp++;
+ while (*tmp != 0)
+ tmp++;
len = tmp - str;
ret = (xmlChar *) xmlMallocAtomic((len + 1) * sizeof(xmlChar));
if (ret == NULL) {
- if (ctxt != NULL) {
- VALID_ERR(XML_RELAXNG_ERR_MEMORY);
- } else {
- xmlGenericError(xmlGenericErrorContext,
- "xmlRelaxNGNormalize: out of memory\n");
- }
- return(NULL);
+ xmlRngVErrMemory(ctxt, "validating\n");
+ return (NULL);
}
p = ret;
- while (IS_BLANK(*str)) str++;
+ while (IS_BLANK(*str))
+ str++;
while (*str != 0) {
- if (IS_BLANK(*str)) {
- while (IS_BLANK(*str)) str++;
- if (*str == 0)
- break;
- *p++ = ' ';
- } else
- *p++ = *str++;
+ if (IS_BLANK(*str)) {
+ while (IS_BLANK(*str))
+ str++;
+ if (*str == 0)
+ break;
+ *p++ = ' ';
+ } else
+ *p++ = *str++;
}
*p = 0;
- return(ret);
+ return (ret);
}
/**
@@ -8298,63 +8371,66 @@
* Returns 0 if the validation succeeded or an error code.
*/
static int
-xmlRelaxNGValidateDatatype(xmlRelaxNGValidCtxtPtr ctxt, const xmlChar *value,
- xmlRelaxNGDefinePtr define, xmlNodePtr node) {
+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);
+ 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 ((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);
+ 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;
+ ret = 0;
} else if (ret == 2) {
- VALID_ERR2P(XML_RELAXNG_ERR_DUPID, value);
+ VALID_ERR2P(XML_RELAXNG_ERR_DUPID, value);
} else {
- VALID_ERR3P(XML_RELAXNG_ERR_TYPEVAL, define->name, value);
- ret = -1;
+ 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 (lib->facet != NULL) {
+ tmp = lib->facet(lib->data, define->name, cur->name,
+ cur->value, value, result);
if (tmp != 0)
- ret = -1;
- }
- cur = cur->next;
+ ret = -1;
+ }
+ cur = cur->next;
}
if ((ret == 0) && (define->content != NULL)) {
- const xmlChar *oldvalue, *oldendvalue;
+ 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;
+ 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);
+ lib->freef(lib->data, result);
+ return (ret);
}
/**
@@ -8366,22 +8442,25 @@
* Returns 0 if the operation succeeded or an error code.
*/
static int
-xmlRelaxNGNextValue(xmlRelaxNGValidCtxtPtr ctxt) {
+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);
+ ctxt->state->value = NULL;
+ ctxt->state->endvalue = NULL;
+ return (0);
}
- while (*cur != 0) cur++;
- while ((cur != ctxt->state->endvalue) && (*cur == 0)) cur++;
+ while (*cur != 0)
+ cur++;
+ while ((cur != ctxt->state->endvalue) && (*cur == 0))
+ cur++;
if (cur == ctxt->state->endvalue)
- ctxt->state->value = NULL;
+ ctxt->state->value = NULL;
else
- ctxt->state->value = cur;
- return(0);
+ ctxt->state->value = cur;
+ return (0);
}
/**
@@ -8394,17 +8473,18 @@
* Returns 0 if the validation succeeded or an error code.
*/
static int
-xmlRelaxNGValidateValueList(xmlRelaxNGValidCtxtPtr ctxt,
- xmlRelaxNGDefinePtr defines) {
+xmlRelaxNGValidateValueList(xmlRelaxNGValidCtxtPtr ctxt,
+ xmlRelaxNGDefinePtr defines)
+{
int ret = 0;
while (defines != NULL) {
- ret = xmlRelaxNGValidateValue(ctxt, defines);
- if (ret != 0)
- break;
- defines = defines->next;
+ ret = xmlRelaxNGValidateValue(ctxt, defines);
+ if (ret != 0)
+ break;
+ defines = defines->next;
}
- return(ret);
+ return (ret);
}
/**
@@ -8417,248 +8497,256 @@
* Returns 0 if the validation succeeded or an error code.
*/
static int
-xmlRelaxNGValidateValue(xmlRelaxNGValidCtxtPtr ctxt,
- xmlRelaxNGDefinePtr define) {
+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;
+ case XML_RELAXNG_EMPTY:{
+ if ((value != NULL) && (value[0] != 0)) {
+ int idx = 0;
- while (IS_BLANK(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;
+ while (IS_BLANK(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;
- /*
- * TODO: trivial optimizations are possible by
- * computing at compile-time
- */
- nval = xmlRelaxNGNormalize(ctxt, define->value);
- nvalue = xmlRelaxNGNormalize(ctxt, value);
+ 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;
- 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;
+ /*
+ * TODO: trivial optimizations are possible by
+ * computing at compile-time
+ */
+ nval = xmlRelaxNGNormalize(ctxt, define->value);
+ nvalue = xmlRelaxNGNormalize(ctxt, value);
- oldflags = ctxt->flags;
- ctxt->flags |= FLAGS_IGNORABLE;
+ 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);
- 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);
- }
- if (ret == 0)
- xmlRelaxNGNextValue(ctxt);
- break;
- }
- case XML_RELAXNG_LIST: {
- xmlRelaxNGDefinePtr list = define->content;
- xmlChar *oldvalue, *oldend, *val, *cur;
+ 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);
+ }
+ if (ret == 0)
+ xmlRelaxNGNextValue(ctxt);
+ break;
+ }
+ case XML_RELAXNG_LIST:{
+ xmlRelaxNGDefinePtr list = define->content;
+ xmlChar *oldvalue, *oldend, *val, *cur;
+
#ifdef DEBUG_LIST
- int nb_values = 0;
+ int nb_values = 0;
#endif
- oldvalue = ctxt->state->value;
- oldend = ctxt->state->endvalue;
+ 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(*cur)) {
- *cur = 0;
- cur++;
+ 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(*cur)) {
+ *cur = 0;
+ cur++;
#ifdef DEBUG_LIST
- nb_values++;
+ nb_values++;
#endif
- while (IS_BLANK(*cur))
- *cur++ = 0;
- } else
- cur++;
- }
+ while (IS_BLANK(*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);
+ xmlGenericError(xmlGenericErrorContext,
+ "list value: '%s' found %d items\n",
+ oldvalue, nb_values);
+ nb_values = 0;
#endif
- break;
- }
-#ifdef DEBUG_LIST
- nb_values++;
-#endif
- list = list->next;
- }
+ ctxt->state->endvalue = cur;
+ cur = val;
+ while ((*cur == 0) && (cur != ctxt->state->endvalue))
+ cur++;
- 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;
- }
+ 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;
+ ret = xmlRelaxNGValidateValueList(ctxt, define->content);
+ if (ret != 0) {
+ break;
+ }
+ /* no break on purpose */
+ case XML_RELAXNG_ZEROORMORE:{
+ xmlChar *cur, *temp;
- 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 (ret != 0) {
- if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
- xmlRelaxNGDumpValidError(ctxt);
- } else {
- if (ctxt->errNr > 0) xmlRelaxNGPopErrors(ctxt, 0);
- }
- break;
- }
- case XML_RELAXNG_EXCEPT: {
- xmlRelaxNGDefinePtr list;
+ 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 (ret != 0) {
+ if ((ctxt->flags & FLAGS_IGNORABLE) == 0)
+ xmlRelaxNGDumpValidError(ctxt);
+ } else {
+ 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;
- }
+ 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;
+ 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;
- }
+ 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:
- ret = xmlRelaxNGValidateValue(ctxt, define->content);
- break;
- default:
- TODO
- ret = -1;
+ ret = xmlRelaxNGValidateValue(ctxt, define->content);
+ break;
+ default:
+ TODO ret = -1;
}
- return(ret);
+ return (ret);
}
/**
@@ -8671,17 +8759,18 @@
* Returns 0 if the validation succeeded or an error code.
*/
static int
-xmlRelaxNGValidateValueContent(xmlRelaxNGValidCtxtPtr ctxt,
- xmlRelaxNGDefinePtr defines) {
+xmlRelaxNGValidateValueContent(xmlRelaxNGValidCtxtPtr ctxt,
+ xmlRelaxNGDefinePtr defines)
+{
int ret = 0;
while (defines != NULL) {
- ret = xmlRelaxNGValidateValue(ctxt, defines);
- if (ret != 0)
- break;
- defines = defines->next;
+ ret = xmlRelaxNGValidateValue(ctxt, defines);
+ if (ret != 0)
+ break;
+ defines = defines->next;
}
- return(ret);
+ return (ret);
}
/**
@@ -8695,44 +8784,43 @@
* Returns 1 if the attribute matches, 0 if no, or -1 in case of error
*/
static int
-xmlRelaxNGAttributeMatch(xmlRelaxNGValidCtxtPtr ctxt,
- xmlRelaxNGDefinePtr define,
- xmlAttrPtr prop) {
+xmlRelaxNGAttributeMatch(xmlRelaxNGValidCtxtPtr ctxt,
+ xmlRelaxNGDefinePtr define, xmlAttrPtr prop)
+{
int ret;
if (define->name != NULL) {
- if (!xmlStrEqual(define->name, prop->name))
- return(0);
+ 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->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);
+ return (1);
define = define->nameClass;
if (define->type == XML_RELAXNG_EXCEPT) {
- xmlRelaxNGDefinePtr list;
+ 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;
- }
+ 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 {
- TODO
- }
- return(1);
+ TODO}
+ return (1);
}
/**
@@ -8745,102 +8833,104 @@
* Returns 0 if the validation succeeded or an error code.
*/
static int
-xmlRelaxNGValidateAttribute(xmlRelaxNGValidCtxtPtr ctxt,
- xmlRelaxNGDefinePtr define) {
+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);
+ 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;
- }
+ 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);
+ 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;
- }
+ 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);
- }
+ 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);
+
+ return (ret);
}
/**
@@ -8853,8 +8943,9 @@
* Returns 0 if the validation succeeded or an error code.
*/
static int
-xmlRelaxNGValidateAttributeList(xmlRelaxNGValidCtxtPtr ctxt,
- xmlRelaxNGDefinePtr defines) {
+xmlRelaxNGValidateAttributeList(xmlRelaxNGValidCtxtPtr ctxt,
+ xmlRelaxNGDefinePtr defines)
+{
int ret = 0, res;
int needmore = 0;
xmlRelaxNGDefinePtr cur;
@@ -8862,32 +8953,32 @@
cur = defines;
while (cur != NULL) {
if (cur->type == XML_RELAXNG_ATTRIBUTE) {
- if (xmlRelaxNGValidateAttribute(ctxt, cur) != 0)
- ret = -1;
- } else
- needmore = 1;
+ if (xmlRelaxNGValidateAttribute(ctxt, cur) != 0)
+ ret = -1;
+ } else
+ needmore = 1;
cur = cur->next;
}
if (!needmore)
- return(ret);
+ 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;
- }
+ 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);
+
+ return (ret);
}
/**
@@ -8900,28 +8991,29 @@
* Returns 1 if matches 0 otherwise
*/
static int
-xmlRelaxNGNodeMatchesList(xmlNodePtr node, xmlRelaxNGDefinePtr *list) {
+xmlRelaxNGNodeMatchesList(xmlNodePtr node, xmlRelaxNGDefinePtr * list)
+{
xmlRelaxNGDefinePtr cur;
int i = 0, tmp;
if ((node == NULL) || (list == NULL))
- return(0);
+ 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++];
+ 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);
+ return (0);
}
/**
@@ -8934,8 +9026,9 @@
* Returns 0 if the validation succeeded or an error code.
*/
static int
-xmlRelaxNGValidateInterleave(xmlRelaxNGValidCtxtPtr ctxt,
- xmlRelaxNGDefinePtr define) {
+xmlRelaxNGValidateInterleave(xmlRelaxNGValidCtxtPtr ctxt,
+ xmlRelaxNGDefinePtr define)
+{
int ret = 0, i, nbgroups;
int errNr = ctxt->errNr;
int oldflags;
@@ -8947,39 +9040,42 @@
xmlNodePtr *list = NULL, *lasts = NULL;
if (define->data != NULL) {
- partitions = (xmlRelaxNGPartitionPtr) define->data;
- nbgroups = partitions->nbgroups;
+ partitions = (xmlRelaxNGPartitionPtr) define->data;
+ nbgroups = partitions->nbgroups;
} else {
- VALID_ERR(XML_RELAXNG_ERR_INTERNODATA);
- return(-1);
+ 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);
- }
+ 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);
+ }
}
/*
@@ -8988,14 +9084,14 @@
*/
list = (xmlNodePtr *) xmlMalloc(nbgroups * sizeof(xmlNodePtr));
if (list == NULL) {
- VALID_ERR(XML_RELAXNG_ERR_MEMORY);
- return(-1);
+ xmlRngVErrMemory(ctxt, "validating\n");
+ return (-1);
}
memset(list, 0, nbgroups * sizeof(xmlNodePtr));
lasts = (xmlNodePtr *) xmlMalloc(nbgroups * sizeof(xmlNodePtr));
if (lasts == NULL) {
- VALID_ERR(XML_RELAXNG_ERR_MEMORY);
- return(-1);
+ xmlRngVErrMemory(ctxt, "validating\n");
+ return (-1);
}
memset(lasts, 0, nbgroups * sizeof(xmlNodePtr));
@@ -9007,161 +9103,167 @@
cur = xmlRelaxNGSkipIgnored(ctxt, cur);
start = cur;
while (cur != NULL) {
- ctxt->state->seq = cur;
- if ((partitions->triage != NULL) &&
+ ctxt->state->seq = cur;
+ if ((partitions->triage != NULL) &&
(partitions->flags & IS_DETERMINIST)) {
- void *tmp = NULL;
+ 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 ((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 (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;
+ 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);
- 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;
+ for (i = 0; i < nbgroups; i++) {
+ ctxt->state = xmlRelaxNGCopyValidState(ctxt, oldstate);
+ 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;
- for (j = 0;j < ctxt->states->nbState;j++) {
- cur = ctxt->states->tabState[j]->seq;
- cur = xmlRelaxNGSkipIgnored(ctxt, cur);
- if (cur == NULL) {
- found = 1;
- break;
- }
- }
- if (ctxt->states->nbState > 0) {
- xmlRelaxNGFreeValidState(ctxt,oldstate);
- oldstate = ctxt->states->tabState[ctxt->states->nbState - 1];
- }
- for (j = 0;j < ctxt->states->nbState - 1;j++) {
- xmlRelaxNGFreeValidState(ctxt,ctxt->states->tabState[j]);
- }
- xmlRelaxNGFreeStates(ctxt, ctxt->states);
- ctxt->states = NULL;
- if (found == 0) {
- 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;
- }
+ for (j = 0; j < ctxt->states->nbState; j++) {
+ cur = ctxt->states->tabState[j]->seq;
+ cur = xmlRelaxNGSkipIgnored(ctxt, cur);
+ if (cur == NULL) {
+ found = 1;
+ break;
+ }
+ }
+ if (ctxt->states->nbState > 0) {
+ xmlRelaxNGFreeValidState(ctxt, oldstate);
+ oldstate =
+ ctxt->states->tabState[ctxt->states->nbState - 1];
+ }
+ for (j = 0; j < ctxt->states->nbState - 1; j++) {
+ xmlRelaxNGFreeValidState(ctxt, ctxt->states->tabState[j]);
+ }
+ xmlRelaxNGFreeStates(ctxt, ctxt->states);
+ ctxt->states = NULL;
+ if (found == 0) {
+ 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);
+ xmlRelaxNGFreeValidState(ctxt, ctxt->state);
ctxt->state = oldstate;
ctxt->state->seq = lastelem;
if (ret != 0) {
- VALID_ERR(XML_RELAXNG_ERR_INTERSEQ);
- ret = -1;
- goto done;
+ VALID_ERR(XML_RELAXNG_ERR_INTERSEQ);
+ ret = -1;
+ goto done;
}
-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 ((cur == start) || (cur->prev == NULL))
+ break;
+ cur->prev->next = cur;
+ cur = cur->prev;
}
if (ret == 0) {
- if (ctxt->errNr > errNr) xmlRelaxNGPopErrors(ctxt, errNr);
+ if (ctxt->errNr > errNr)
+ xmlRelaxNGPopErrors(ctxt, errNr);
}
xmlFree(list);
xmlFree(lasts);
- return(ret);
+ return (ret);
}
/**
@@ -9174,30 +9276,32 @@
* Returns 0 if the validation succeeded or an error code.
*/
static int
-xmlRelaxNGValidateDefinitionList(xmlRelaxNGValidCtxtPtr ctxt,
- xmlRelaxNGDefinePtr defines) {
+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);
+ 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;
+ 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);
+ return (ret);
}
/**
@@ -9211,108 +9315,106 @@
* Returns 1 if the element matches, 0 if no, or -1 in case of error
*/
static int
-xmlRelaxNGElementMatch(xmlRelaxNGValidCtxtPtr ctxt,
- xmlRelaxNGDefinePtr define,
- xmlNodePtr elem) {
+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 (!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);
- }
+ 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);
+ (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);
+ VALID_ERR2(XML_RELAXNG_ERR_ELEMEXTRANS, define->name);
+ return (0);
}
if (define->nameClass == NULL)
- return(1);
+ return (1);
define = define->nameClass;
if (define->type == XML_RELAXNG_EXCEPT) {
- xmlRelaxNGDefinePtr list;
- if (ctxt != NULL) {
- oldflags = ctxt->flags;
- ctxt->flags |= FLAGS_IGNORABLE;
- }
+ xmlRelaxNGDefinePtr list;
- 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;
- }
+ 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;
+ xmlRelaxNGDefinePtr list;
- if (ctxt != NULL) {
- oldflags = ctxt->flags;
- ctxt->flags |= FLAGS_IGNORABLE;
- }
+ 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;
- }
+ 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;
+ TODO ret = -1;
}
- return(ret);
+ return (ret);
}
/**
@@ -9327,7 +9429,8 @@
* Returns the index of the "best" state or -1 in case of error
*/
static int
-xmlRelaxNGBestState(xmlRelaxNGValidCtxtPtr ctxt) {
+xmlRelaxNGBestState(xmlRelaxNGValidCtxtPtr ctxt)
+{
xmlRelaxNGValidStatePtr state;
int i, tmp;
int best = -1;
@@ -9335,26 +9438,26 @@
if ((ctxt == NULL) || (ctxt->states == NULL) ||
(ctxt->states->nbState <= 0))
- return(-1);
+ return (-1);
- for (i = 0;i < ctxt->states->nbState;i++) {
+ 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;
- }
- }
+ 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);
+ return (best);
}
/**
@@ -9365,18 +9468,19 @@
* errors about and log it.
*/
static void
-xmlRelaxNGLogBestError(xmlRelaxNGValidCtxtPtr ctxt) {
+xmlRelaxNGLogBestError(xmlRelaxNGValidCtxtPtr ctxt)
+{
int best;
if ((ctxt == NULL) || (ctxt->states == NULL) ||
(ctxt->states->nbState <= 0))
- return;
+ return;
best = xmlRelaxNGBestState(ctxt);
if ((best >= 0) && (best < ctxt->states->nbState)) {
- ctxt->state = ctxt->states->tabState[best];
+ ctxt->state = ctxt->states->tabState[best];
- xmlRelaxNGValidateElementEnd(ctxt, 1);
+ xmlRelaxNGValidateElementEnd(ctxt, 1);
}
}
@@ -9392,31 +9496,32 @@
* Returns 0 if the validation succeeded or an error code.
*/
static int
-xmlRelaxNGValidateElementEnd(xmlRelaxNGValidCtxtPtr ctxt, int log) {
+xmlRelaxNGValidateElementEnd(xmlRelaxNGValidCtxtPtr ctxt, int log)
+{
int i;
xmlRelaxNGValidStatePtr state;
state = ctxt->state;
if (state->seq != NULL) {
- state->seq = xmlRelaxNGSkipIgnored(ctxt, state->seq);
- if (state->seq != NULL) {
- if (log) {
- VALID_ERR3(XML_RELAXNG_ERR_EXTRACONTENT,
- state->node->name, state->seq->name);
- }
- return(-1);
- }
+ state->seq = xmlRelaxNGSkipIgnored(ctxt, state->seq);
+ if (state->seq != NULL) {
+ if (log) {
+ 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 (log) {
- VALID_ERR3(XML_RELAXNG_ERR_INVALIDATTR,
- state->attrs[i]->name, state->node->name);
- }
- return(-1 -i);
- }
+ for (i = 0; i < state->nbAttrs; i++) {
+ if (state->attrs[i] != NULL) {
+ if (log) {
+ VALID_ERR3(XML_RELAXNG_ERR_INVALIDATTR,
+ state->attrs[i]->name, state->node->name);
+ }
+ return (-1 - i);
+ }
}
- return(0);
+ return (0);
}
/**
@@ -9561,28 +9666,29 @@
}
}
if (define->contModel != NULL) {
- xmlRelaxNGValidStatePtr nstate, tmpstate = ctxt->state;
- xmlRelaxNGStatesPtr tmpstates = ctxt->states;
- xmlNodePtr nseq;
+ xmlRelaxNGValidStatePtr nstate, tmpstate = ctxt->state;
+ xmlRelaxNGStatesPtr tmpstates = ctxt->states;
+ xmlNodePtr nseq;
- nstate = xmlRelaxNGNewValidState(ctxt, node);
- ctxt->state = nstate;
- ctxt->states = NULL;
+ 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);
+ 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);
+ xmlGenericError(xmlGenericErrorContext,
+ "Validating content of '%s' : %d\n",
+ define->name, tmp);
#endif
if (tmp != 0)
- ret = -1;
+ ret = -1;
if (ctxt->states != NULL) {
tmp = -1;
@@ -9590,23 +9696,24 @@
for (i = 0; i < ctxt->states->nbState; i++) {
state = ctxt->states->tabState[i];
ctxt->state = state;
- ctxt->state->seq = nseq;
+ ctxt->state->seq = nseq;
if (xmlRelaxNGValidateElementEnd(ctxt, 0) == 0) {
tmp = 0;
- break;
- }
+ break;
+ }
}
- if (tmp != 0) {
- /*
- * validation error, log the message for the "best" one
- */
- ctxt->flags |= FLAGS_IGNORABLE;
- xmlRelaxNGLogBestError(ctxt);
- }
+ 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]);
}
xmlRelaxNGFreeStates(ctxt, ctxt->states);
ctxt->flags = oldflags;
@@ -9615,7 +9722,7 @@
ret = -1;
} else {
state = ctxt->state;
- ctxt->state->seq = nseq;
+ ctxt->state->seq = nseq;
if (ret == 0)
ret = xmlRelaxNGValidateElementEnd(ctxt, 1);
xmlRelaxNGFreeValidState(ctxt, state);
@@ -9623,7 +9730,8 @@
} else {
if (define->content != NULL) {
tmp = xmlRelaxNGValidateDefinitionList(ctxt,
- define->content);
+ define->
+ content);
if (tmp != 0) {
ret = -1;
if (ctxt->state == NULL) {
@@ -9647,19 +9755,20 @@
if (xmlRelaxNGValidateElementEnd(ctxt, 0) == 0) {
tmp = 0;
- break;
- }
+ break;
+ }
}
- if (tmp != 0) {
- /*
- * validation error, log the message for the "best" one
- */
- ctxt->flags |= FLAGS_IGNORABLE;
- xmlRelaxNGLogBestError(ctxt);
- }
+ 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]);
}
xmlRelaxNGFreeStates(ctxt, ctxt->states);
ctxt->flags = oldflags;
@@ -9897,8 +10006,8 @@
ctxt->flags = oldflags;
#if 0
/*
- * errors may have to be propagated back...
- */
+ * errors may have to be propagated back...
+ */
if (ctxt->errNr > errNr)
xmlRelaxNGPopErrors(ctxt, errNr);
#endif
@@ -10045,7 +10154,7 @@
if (content == NULL) {
content = xmlStrdup(BAD_CAST "");
if (content == NULL) {
- VALID_ERR(XML_RELAXNG_ERR_MEMORY);
+ xmlRngVErrMemory(ctxt, "validating\n");
ret = -1;
break;
}
@@ -10088,7 +10197,7 @@
if (content == NULL) {
content = xmlStrdup(BAD_CAST "");
if (content == NULL) {
- VALID_ERR(XML_RELAXNG_ERR_MEMORY);
+ xmlRngVErrMemory(ctxt, "validating\n");
ret = -1;
break;
}
@@ -10139,7 +10248,7 @@
if (content == NULL) {
content = xmlStrdup(BAD_CAST "");
if (content == NULL) {
- VALID_ERR(XML_RELAXNG_ERR_MEMORY);
+ xmlRngVErrMemory(ctxt, "validating\n");
ret = -1;
break;
}
@@ -10192,8 +10301,9 @@
* Returns 0 if the validation succeeded or an error code.
*/
static int
-xmlRelaxNGValidateDefinition(xmlRelaxNGValidCtxtPtr ctxt,
- xmlRelaxNGDefinePtr define) {
+xmlRelaxNGValidateDefinition(xmlRelaxNGValidCtxtPtr ctxt,
+ xmlRelaxNGDefinePtr define)
+{
xmlRelaxNGStatesPtr states, res;
int i, j, k, ret, oldflags;
@@ -10201,29 +10311,27 @@
* 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;
+ 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);
+ 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;
@@ -10232,84 +10340,84 @@
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;
- }
- }
+ 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;
+ xmlRelaxNGFreeStates(ctxt, states);
+ ctxt->states = res;
+ ret = 0;
} else if (j > 1) {
- states->nbState = j;
- ctxt->states = states;
- ret =0;
+ states->nbState = j;
+ ctxt->states = states;
+ ret = 0;
} else if (j == 1) {
- ctxt->state = states->tabState[0];
- xmlRelaxNGFreeStates(ctxt, states);
- ret = 0;
+ 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;
- }
+ 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;
+ TODO xmlRelaxNGFreeValidState(ctxt, ctxt->state);
+ ctxt->state = NULL;
}
- return(ret);
+ return (ret);
}
/**
@@ -10322,7 +10430,8 @@
* Returns 0 if the validation succeeded or an error code.
*/
static int
-xmlRelaxNGValidateDocument(xmlRelaxNGValidCtxtPtr ctxt, xmlDocPtr doc) {
+xmlRelaxNGValidateDocument(xmlRelaxNGValidCtxtPtr ctxt, xmlDocPtr doc)
+{
int ret;
xmlRelaxNGPtr schema;
xmlRelaxNGGrammarPtr grammar;
@@ -10330,76 +10439,77 @@
xmlNodePtr node;
if ((ctxt == NULL) || (ctxt->schema == NULL) || (doc == NULL))
- return(-1);
+ return (-1);
ctxt->errNo = XML_RELAXNG_OK;
schema = ctxt->schema;
grammar = schema->topgrammar;
if (grammar == NULL) {
- VALID_ERR(XML_RELAXNG_ERR_NOGRAMMAR);
- return(-1);
+ 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;
- }
- }
+ 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;
+ 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;
- }
- }
+ 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;
+ ctxt->state = NULL;
}
- if (ret != 0)
- xmlRelaxNGDumpValidError(ctxt);
+ 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);
+ ctxt->error(ctxt->userData,
+ "%d Extra error messages left on stack !\n",
+ ctxt->errNr);
+ xmlRelaxNGDumpValidError(ctxt);
}
#endif
if (ctxt->idref == 1) {
- xmlValidCtxt vctxt;
+ xmlValidCtxt vctxt;
- memset(&vctxt, 0, sizeof(xmlValidCtxt));
- vctxt.valid = 1;
- vctxt.error = ctxt->error;
- vctxt.warning = ctxt->warning;
- vctxt.userData = ctxt->userData;
+ 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;
+ if (xmlValidateDocumentFinal(&vctxt, doc) != 1)
+ ret = -1;
}
if ((ret == 0) && (ctxt->errNo != XML_RELAXNG_OK))
- ret = -1;
+ ret = -1;
- return(ret);
+ return (ret);
}
/************************************************************************
@@ -10407,6 +10517,7 @@
* Validation interfaces *
* *
************************************************************************/
+
/**
* xmlRelaxNGNewValidCtxt:
* @schema: a precompiled XML RelaxNGs
@@ -10416,13 +10527,13 @@
* Returns the validation context or NULL in case of error
*/
xmlRelaxNGValidCtxtPtr
-xmlRelaxNGNewValidCtxt(xmlRelaxNGPtr schema) {
+xmlRelaxNGNewValidCtxt(xmlRelaxNGPtr schema)
+{
xmlRelaxNGValidCtxtPtr ret;
ret = (xmlRelaxNGValidCtxtPtr) xmlMalloc(sizeof(xmlRelaxNGValidCtxt));
if (ret == NULL) {
- xmlGenericError(xmlGenericErrorContext,
- "Failed to allocate new schema validation context\n");
+ xmlRngVErrMemory(NULL, "building context\n");
return (NULL);
}
memset(ret, 0, sizeof(xmlRelaxNGValidCtxt));
@@ -10448,36 +10559,37 @@
* Free the resources associated to the schema validation context
*/
void
-xmlRelaxNGFreeValidCtxt(xmlRelaxNGValidCtxtPtr ctxt) {
+xmlRelaxNGFreeValidCtxt(xmlRelaxNGValidCtxtPtr ctxt)
+{
int k;
if (ctxt == NULL)
- return;
+ return;
if (ctxt->states != NULL)
- xmlRelaxNGFreeStates(NULL, ctxt->states);
+ 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);
+ 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);
+ for (k = 0; k < ctxt->freeStatesNr; k++) {
+ xmlRelaxNGFreeStates(NULL, ctxt->freeStates[k]);
+ }
+ xmlFree(ctxt->freeStates);
}
if (ctxt->errTab != NULL)
- xmlFree(ctxt->errTab);
+ xmlFree(ctxt->errTab);
if (ctxt->elemTab != NULL) {
xmlRegExecCtxtPtr exec;
- exec = xmlRelaxNGElemPop(ctxt);
- while (exec != NULL) {
- xmlRegFreeExecCtxt(exec);
- exec = xmlRelaxNGElemPop(ctxt);
- }
- xmlFree(ctxt->elemTab);
+ exec = xmlRelaxNGElemPop(ctxt);
+ while (exec != NULL) {
+ xmlRegFreeExecCtxt(exec);
+ exec = xmlRelaxNGElemPop(ctxt);
+ }
+ xmlFree(ctxt->elemTab);
}
xmlFree(ctxt);
}
@@ -10493,10 +10605,11 @@
*/
void
xmlRelaxNGSetValidErrors(xmlRelaxNGValidCtxtPtr ctxt,
- xmlRelaxNGValidityErrorFunc err,
- xmlRelaxNGValidityWarningFunc warn, void *ctx) {
+ xmlRelaxNGValidityErrorFunc err,
+ xmlRelaxNGValidityWarningFunc warn, void *ctx)
+{
if (ctxt == NULL)
- return;
+ return;
ctxt->error = err;
ctxt->warning = warn;
ctxt->userData = ctx;
@@ -10515,14 +10628,18 @@
*/
int
xmlRelaxNGGetValidErrors(xmlRelaxNGValidCtxtPtr ctxt,
- xmlRelaxNGValidityErrorFunc *err,
- xmlRelaxNGValidityWarningFunc *warn, void **ctx) {
+ 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);
+ return (-1);
+ if (err != NULL)
+ *err = ctxt->error;
+ if (warn != NULL)
+ *warn = ctxt->warning;
+ if (ctx != NULL)
+ *ctx = ctxt->userData;
+ return (0);
}
/**
@@ -10536,11 +10653,12 @@
* number otherwise and -1 in case of internal or API error.
*/
int
-xmlRelaxNGValidateDoc(xmlRelaxNGValidCtxtPtr ctxt, xmlDocPtr doc) {
+xmlRelaxNGValidateDoc(xmlRelaxNGValidCtxtPtr ctxt, xmlDocPtr doc)
+{
int ret;
if ((ctxt == NULL) || (doc == NULL))
- return(-1);
+ return (-1);
ctxt->doc = doc;
@@ -10549,9 +10667,8 @@
* TODO: build error codes
*/
if (ret == -1)
- return(1);
- return(ret);
+ return (1);
+ return (ret);
}
#endif /* LIBXML_SCHEMAS_ENABLED */
-