Lines Matching defs:node
316 #define IS_SCHEMA(node, type) \
317 ((node != NULL) && (node->ns != NULL) && \
318 (xmlStrEqual(node->name, (const xmlChar *) type)) && \
319 (xmlStrEqual(node->ns->href, xmlSchemaNs)))
430 xmlDocPtr doc; /* The schema node-tree. */
527 xmlNodePtr node;
543 xmlNodePtr node;
650 xmlNodePtr node;
670 xmlNodePtr node;
686 xmlNodePtr node;
706 xmlNodePtr node;
740 xmlNodePtr node;
766 * The key sequence of a node table item.
778 * The node table item of a node table.
783 xmlNodePtr node;
798 xmlSchemaPSVIIDCBindingPtr next; /* next binding of a specific node */
801 int nbNodes; /* number of entries in the node table */
802 int sizeNodes; /* size of the node table */
853 xmlSchemaItemListPtr targets; /* list of target-node
877 * Holds information of an element node.
881 xmlNodePtr node;
889 int flags; /* combination of node info flags */
940 xmlNodePtr node;
947 int flags; /* combination of node info flags */
983 xmlNodePtr node;
1007 xmlSchemaPSVIIDCNodePtr *idcNodes; /* list of all IDC node-table entries*/
1011 xmlSchemaPSVIIDCKeyPtr *idcKeys; /* list of all IDC node-table entries */
1058 xmlNodePtr node);
1061 xmlNodePtr node);
1069 xmlNodePtr node);
1079 xmlNodePtr node, xmlSchemaTypeType type,
1102 xmlNodePtr node);
1190 * Returns node associated with the schema component.
1191 * NOTE that such a node need not be available; plus, a component's
1192 * node need not to reflect the component directly, since there is no
1201 return (((xmlSchemaElementPtr) item)->node);
1203 return (((xmlSchemaAttributePtr) item)->node);
1206 return (((xmlSchemaTypePtr) item)->node);
1209 return (((xmlSchemaWildcardPtr) item)->node);
1211 return (((xmlSchemaParticlePtr) item)->node);
1215 return (((xmlSchemaModelGroupPtr) item)->node);
1217 return (((xmlSchemaModelGroupDefPtr) item)->node);
1219 return (((xmlSchemaAttributeGroupPtr) item)->node);
1223 return (((xmlSchemaIDCPtr) item)->node);
1225 return(((xmlSchemaQNameRefPtr) item)->node);
1228 return (((xmlSchemaNotationPtr) item)->node);
1231 return (((xmlSchemaAttributeUsePtr) item)->node);
1549 * @itemNode: the node of the item
1564 * If the itemNode is an attribute node, the name of the attribute
1866 * @node: a context node
1873 const char *extra, xmlNodePtr node)
1877 __xmlSimpleError(XML_FROM_SCHEMASP, XML_ERR_NO_MEMORY, node, NULL,
1884 * @node: the context node
1893 xmlSchemaPErr(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node, int error,
1907 __xmlRaiseError(schannel, channel, data, ctxt, node, XML_FROM_SCHEMASP,
1916 * @node: the context node
1917 * @node: the current child
1926 xmlSchemaPErr2(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node,
1933 xmlSchemaPErr(ctxt, node, error, msg, str1, str2);
1940 * @node: the context node
1955 xmlSchemaPErrExt(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node, int error,
1973 __xmlRaiseError(schannel, channel, data, ctxt, node, XML_FROM_SCHEMASP,
1988 * @node: a context node
1995 const char *extra, xmlNodePtr node)
2001 __xmlSimpleError(XML_FROM_SCHEMASV, XML_ERR_NO_MEMORY, node, NULL,
2006 xmlSchemaPSimpleInternalErr(xmlNodePtr node,
2009 __xmlSimpleError(XML_FROM_SCHEMASP, XML_SCHEMAP_INTERNAL, node,
2018 * @node: the context node
2030 int error, xmlNodePtr node, int line, const char *msg,
2053 * Error node. If we specify a line number, then
2054 * do not channel any node to the error function.
2057 if ((node == NULL) &&
2060 node = vctxt->inode->node;
2063 * Get filename and line if no node-tree.
2065 if ((node == NULL) &&
2073 * Override the given node's (if any) position
2076 node = NULL;
2101 node, XML_FROM_SCHEMASV,
2118 node, XML_FROM_SCHEMASP, error,
2131 * @node: the context node
2142 int error, xmlNodePtr node, const char *msg,
2145 xmlSchemaErr4Line(actxt, XML_ERR_ERROR, error, node, 0,
2151 int error, xmlNodePtr node, const char *msg,
2155 xmlSchemaErr4Line(actxt, XML_ERR_ERROR, error, node, 0,
2161 int error, xmlNodePtr node, const char *msg,
2164 xmlSchemaErr4(actxt, error, node, msg, str1, str2, NULL, NULL);
2170 xmlNodePtr node)
2175 if ((node != NULL) &&
2176 (node->type != XML_ELEMENT_NODE) &&
2177 (node->type != XML_ATTRIBUTE_NODE))
2187 if (node != NULL) {
2191 if (node->type == XML_ATTRIBUTE_NODE) {
2192 xmlNodePtr elem = node->parent;
2207 if (node->ns != NULL)
2209 node->ns->href, node->name));
2212 NULL, node->name));
2218 * Work on node infos.
2239 * Hmm, no node while parsing?
2315 xmlNodePtr node,
2323 if ((node == NULL) && (item != NULL) &&
2325 node = WXS_ITEM_NODE(item);
2329 xmlSchemaFormatNodeForError(&msg, actxt, node);
2332 xmlSchemaErr4(actxt, error, node,
2340 xmlNodePtr node,
2346 xmlSchemaCustomErr4(actxt, error, node, item,
2355 xmlNodePtr node,
2364 xmlSchemaFormatNodeForError(&msg, actxt, node);
2369 xmlSchemaErr4Line(actxt, XML_ERR_WARNING, error, node, 0,
2403 xmlNodePtr node)
2405 if (node != NULL)
2406 return (node->type);
2444 xmlNodePtr node,
2451 xmlSchemaFormatNodeForError(&msg, actxt, node);
2453 if (displayValue || (xmlSchemaEvalErrorNodeType(actxt, node) ==
2486 if (displayValue || (xmlSchemaEvalErrorNodeType(actxt, node) ==
2488 xmlSchemaErr(actxt, error, node, (const char *) msg, value, NULL);
2490 xmlSchemaErr(actxt, error, node, (const char *) msg, NULL, NULL);
2497 xmlNodePtr node)
2499 if (node != NULL) {
2500 if (node->ns != NULL)
2501 return (xmlSchemaFormatQName(str, node->ns->href, node->name));
2503 return (xmlSchemaFormatQName(str, NULL, node->name));
2513 xmlNodePtr node)
2517 xmlSchemaFormatNodeForError(&msg, actxt, node);
2519 xmlSchemaErr(actxt, error, node, (const char *) msg,
2520 xmlSchemaFormatErrorNodeQName(&str, (xmlSchemaNodeInfoPtr) ni, node),
2529 xmlNodePtr node,
2541 xmlSchemaFormatNodeForError(&msg, actxt, node);
2622 xmlSchemaErr(actxt, error, node, (const char *) msg, NULL, NULL);
2629 xmlNodePtr node,
2640 int nodeType = xmlSchemaEvalErrorNodeType(actxt, node);
2642 xmlSchemaFormatNodeForError(&msg, actxt, node);
2687 xmlSchemaErr3(actxt, error, node, (const char *) msg,
2690 xmlSchemaErr(actxt, error, node, (const char *) msg,
2696 xmlSchemaErr(actxt, error, node, (const char *) msg, value,
2701 xmlSchemaErr(actxt, error, node, (const char *) msg, value,
2706 xmlSchemaErr(actxt, error, node, (const char *) msg, value,
2711 xmlSchemaErr(actxt, error, node, (const char *) msg, value,
2716 xmlSchemaErr(actxt, error, node, (const char *) msg, value,
2721 xmlSchemaErr(actxt, error, node, (const char *) msg, value,
2726 xmlSchemaErr(actxt, error, node, (const char*) msg, value,
2731 xmlSchemaErr(actxt, error, node, (const char*) msg, value,
2735 xmlSchemaErr(actxt, error, node, (const char *) msg, value, NULL);
2738 xmlSchemaErr(actxt, error, node, (const char *) msg, NULL, NULL);
2743 xmlSchemaErr(actxt, error, node, (const char *) msg, str1, str2);
2766 * @ownerElem: the owner as an element node
2767 * @node: the parent element node of the missing attribute node
2768 node
2800 * @ownerElem: the owner as an element node
2841 * @attr: the illegal attribute node
2882 * @attr: the illegal attribute node
2909 * @itemElem: the node of the schema item
2947 * @itemElem: the node of the schema item
2971 * @itemElem: the node of the schema type
2981 xmlNodePtr node,
2999 xmlSchemaErr4(ACTXT_CAST ctxt, error, node,
3023 xmlSchemaFormatItemForReport(&des, NULL, WXS_BASIC_CAST type, type->node);
3024 xmlSchemaPErrExt(ctxt, type->node, error, NULL, NULL, NULL,
3053 type->node);
3054 xmlSchemaPErr(ctxt, type->node, error,
3064 * @elemDes: the designation of the parent element node
3065 * @attr: the bad attribute node
3066 * @type: the corresponding type of the attribute node
3094 * @node: the validated node
3104 xmlNodePtr node,
3114 xmlSchemaFormatNodeForError(&msg, ACTXT_CAST ctxt, node);
3120 if (node->type == XML_ATTRIBUTE_NODE)
3151 if (node->type == XML_ATTRIBUTE_NODE)
3163 if (node->type == XML_ATTRIBUTE_NODE)
3164 xmlSchemaPErr(ctxt, node, error, (const char *) msg, value, NULL);
3166 xmlSchemaPErr(ctxt, node, error, (const char *) msg, NULL, NULL);
3170 xmlSchemaPErrExt(ctxt, node, error, NULL, NULL, NULL,
3183 * @ownerElem: the node of the holder of the content
3184 * @child: the invalid child node
3291 * @node: a node
3298 xmlSchemaNewAnnot(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node)
3304 xmlSchemaPErrMemory(ctxt, "allocating annotation", node);
3308 ret->content = node;
4615 * @node: the element node
4624 xmlSchemaGetPropNode(xmlNodePtr node, const char *name)
4628 if ((node == NULL) || (name == NULL))
4630 prop = node->properties;
4641 * @node: the element node
4651 xmlSchemaGetPropNodeNs(xmlNodePtr node, const char *uri, const char *name)
4655 if ((node == NULL) || (name == NULL))
4657 prop = node->properties;
4669 xmlSchemaGetNodeContent(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node)
4674 val = xmlNodeGetContent(node);
4683 xmlSchemaGetNodeContentNoDict(xmlNodePtr node)
4685 return((const xmlChar*) xmlNodeGetContent(node));
4691 * @node: the node
4699 xmlSchemaGetProp(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node,
4705 val = xmlGetNoNsProp(node, BAD_CAST name);
5127 xmlNodePtr node ATTRIBUTE_UNUSED)
5143 /* TODO: do we need the node to be set?
5144 * ret->node = node;*/
5164 xmlNodePtr node, int topLevel)
5178 ret->node = node;
5204 xmlNodePtr node)
5218 ret->node = node;
5266 * @nodenode
5277 xmlNodePtr node)
5294 ret->node = node;
5327 xmlNodePtr node, int topLevel)
5343 ret->node = node;
5369 xmlNodePtr node, int topLevel)
5385 ret->node = node;
5418 ret->node = NULL;
5455 * @node: the node in the schema doc
5466 xmlNodePtr node)
5482 ret->node = node;
5495 * @node: the corresponding node in the schema doc
5506 xmlNodePtr node, int min, int max)
5524 ret->node = node;
5555 xmlNodePtr node)
5571 ret->node = node;
5615 int category, xmlNodePtr node)
5633 ret->node = node;
5656 xmlSchemaTypeType type, xmlNodePtr node)
5670 ret->node = node;
5857 * @attr: the attribute node
5889 * @ownerElem: the parent node of the attribute
5926 * @ownerElem: the parent node of the attribute
6006 * @node: a subtree containing XML Schema informations
6013 xmlGetMaxOccurs(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node,
6020 attr = xmlSchemaGetPropNode(node, "maxOccurs");
6071 * @node: a subtree containing XML Schema informations
6078 xmlGetMinOccurs(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node,
6085 attr = xmlSchemaGetPropNode(node, "minOccurs");
6125 * @node: the node holding the value
6134 xmlNodePtr node)
6139 value = xmlNodeGetContent(node);
6156 ownerItem, node,
6169 * @node: a subtree containing XML Schema informations
6180 xmlNodePtr node,
6185 val = xmlSchemaGetProp(ctxt, node, name);
6205 (xmlNodePtr) xmlSchemaGetPropNode(node, name),
6219 xmlNodePtr node,
6224 xmlNodePtr node,
6229 xmlNodePtr node,
6234 xmlNodePtr node,
6239 xmlNodePtr node);
6242 xmlSchemaPtr schema, xmlNodePtr node);
6250 * @attr: the schema attribute node being validated
6323 * @attr: the schema attribute node being validated
6358 * @node: the element node of the attribute
6361 * @ownerElem: the owner element node
6362 * @name: the name of the schema attribute node
6411 xmlNodePtr node,
6438 xmlNodePtr n = (attr != NULL) ? (xmlNodePtr) attr : node;
6460 * @node: a subtree containing XML Schema informations
6502 * @node: a subtree containing XML Schema informations
6511 xmlSchemaParseAnnotation(xmlSchemaParserCtxtPtr ctxt, xmlNodePtr node, int needed)
6526 if ((ctxt == NULL) || (node == NULL))
6529 ret = xmlSchemaNewAnnot(ctxt, node);
6532 attr = node->properties;
6544 xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
6548 child = node->children;
6609 NULL, node, child, NULL, "(appinfo | documentation)*");
6622 * @node: a subtree containing XML Schema informations
6631 xmlNodePtr node)
6637 if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
6642 xmlSchemaPErrMemory(ctxt, "allocating facet", node);
6645 facet->node = node;
6646 value = xmlSchemaGetProp(ctxt, node, "value");
6648 xmlSchemaPErr2(ctxt, node, child, XML_SCHEMAP_FACET_NO_VALUE,
6649 "Facet %s has no value\n", node->name, NULL);
6653 if (IS_SCHEMA(node, "minInclusive")) {
6655 } else if (IS_SCHEMA(node, "minExclusive")) {
6657 } else if (IS_SCHEMA(node, "maxInclusive")) {
6659 } else if (IS_SCHEMA(node, "maxExclusive")) {
6661 } else if (IS_SCHEMA(node, "totalDigits")) {
6663 } else if (IS_SCHEMA(node, "fractionDigits")) {
6665 } else if (IS_SCHEMA(node, "pattern")) {
6667 } else if (IS_SCHEMA(node, "enumeration")) {
6669 } else if (IS_SCHEMA(node, "whiteSpace")) {
6671 } else if (IS_SCHEMA(node, "length")) {
6673 } else if (IS_SCHEMA(node, "maxLength")) {
6675 } else if (IS_SCHEMA(node, "minLength")) {
6678 xmlSchemaPErr2(ctxt, node, child, XML_SCHEMAP_UNKNOWN_FACET_TYPE,
6679 "Unknown facet type %s\n", node->name, NULL);
6683 xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
6689 fixed = xmlSchemaGetProp(ctxt, node, "fixed");
6695 child = node->children;
6702 xmlSchemaPErr2(ctxt, node, child, XML_SCHEMAP_UNKNOWN_FACET_CHILD,
6704 node->name, NULL);
6713 * @node: a subtree containing XML Schema informations
6726 xmlNodePtr node)
6734 pc = xmlSchemaGetProp(ctxt, node, "processContents");
6745 NULL, node,
6754 attr = xmlSchemaGetPropNode(node, "namespace");
6835 xmlNodePtr node,
6858 xmlSchemaGetPropNode(node, "maxOccurs"),
6868 xmlSchemaGetPropNode(node, "minOccurs"),
6880 * @node: a subtree containing XML Schema informations
6891 xmlNodePtr node)
6900 if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
6905 attr = node->properties;
6922 xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
6926 max = xmlGetMaxOccurs(ctxt, node, 0, UNBOUNDED, 1,
6928 min = xmlGetMinOccurs(ctxt, node, 0, -1, 1,
6930 xmlSchemaPCheckParticleCorrect_2(ctxt, NULL, node, min, max);
6934 wild = xmlSchemaAddWildcard(ctxt, schema, XML_SCHEMA_TYPE_ANY, node);
6937 xmlSchemaParseWildcardNs(ctxt, schema, wild, node);
6941 child = node->children;
6949 NULL, node, child,
6962 particle = xmlSchemaAddParticle(ctxt, node, min, max);
6975 * @node: a subtree containing XML Schema informations
6983 xmlNodePtr node)
6989 if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
6991 name = xmlSchemaGetProp(ctxt, node, "name");
6993 xmlSchemaPErr2(ctxt, node, child, XML_SCHEMAP_NOTATION_NO_NAME,
6998 ctxt->targetNamespace, node);
7001 xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
7003 child = node->children;
7011 NULL, node, child,
7022 * @node: a subtree containing XML Schema informations
7031 xmlSchemaPtr schema, xmlNodePtr node)
7037 if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
7041 node);
7048 attr = node->properties;
7063 xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
7067 if (xmlSchemaParseWildcardNs(ctxt, schema, ret, node) != 0)
7072 child = node->children;
7080 NULL, node, child,
7092 * @node: a subtree containing XML Schema informations
7102 xmlNodePtr node,
7121 if ((pctxt == NULL) || (schema == NULL) || (node == NULL))
7123 attr = xmlSchemaGetPropNode(node, "ref");
7129 if (xmlSchemaCheckReference(pctxt, schema, node, attr, tmpNs) != 0)
7137 attr = node->properties;
7242 NULL, node, NULL,
7266 node, NULL,
7270 attr = xmlSchemaGetPropNode(node, "name");
7273 NULL, node, "name", NULL);
7298 use = xmlSchemaAddAttributeUse(pctxt, node);
7305 attrDecl = xmlSchemaAddAttribute(pctxt, schema, name, ns, node, 0);
7327 use = xmlSchemaAddAttributeUse(pctxt, node);
7360 child = node->children;
7371 NULL, node, child, NULL,
7380 node, NULL,
7388 node, NULL,
7414 node, NULL,
7429 prohib->node = node;
7457 NULL, node, child, NULL,
7462 NULL, node, child, NULL,
7473 NULL, node, child,
7483 NULL, node, child, NULL,
7494 xmlNodePtr node)
7507 if ((pctxt == NULL) || (schema == NULL) || (node == NULL))
7513 attr = xmlSchemaGetPropNode(node, "name");
7516 NULL, node, "name", NULL);
7544 XML_SCHEMAP_NO_XSI, node, NULL,
7550 pctxt->targetNamespace, node, 1);
7558 attr = node->properties;
7577 node, "type", &ret->typeNs, &ret->typeName);
7579 xmlSchemaPValAttrID(pctxt, node, BAD_CAST "id");
7583 ret->defValue = xmlSchemaGetProp(pctxt, node, "fixed");
7589 attr = xmlSchemaGetPropNode(node, "default");
7604 child = node->children;
7616 NULL, node, child,
7625 NULL, node, child, NULL,
7635 * @node: a subtree containing XML Schema informations
7647 xmlNodePtr node)
7654 if ((pctxt == NULL) || (schema == NULL) || (node == NULL))
7657 attr = xmlSchemaGetPropNode(node, "ref");
7661 NULL, node, "ref", NULL);
7666 if (xmlSchemaCheckReference(pctxt, schema, node, attr, refNs) != 0)
7672 attr = node->properties;
7688 xmlSchemaPValAttrID(pctxt, node, BAD_CAST "id");
7693 child = node->children;
7704 NULL, node, child, NULL,
7728 XML_SCHEMAP_SRC_REDEFINE, node, NULL,
7745 ret->node = node;
7757 ret->node = node;
7768 * @node: a subtree containing XML Schema informations
7778 xmlNodePtr node)
7786 if ((pctxt == NULL) || (schema == NULL) || (node == NULL))
7789 attr = xmlSchemaGetPropNode(node, "name");
7793 NULL, node, "name", NULL);
7805 name, pctxt->targetNamespace, node);
7811 attr = node->properties;
7827 xmlSchemaPValAttrID(pctxt, node, BAD_CAST "id");
7831 child = node->children;
7856 NULL, node, child, NULL,
7996 xmlNodePtr node;
8006 xmlSchemaPErr(ctxt, idc->node,
8013 node = idc->node;
8015 node = (xmlNodePtr) attr;
8020 NULL, node,
8078 NULL, node,
8199 * @node: a subtree containing XML Schema informations
8209 xmlNodePtr node,
8219 attr = node->properties;
8247 attr = xmlSchemaGetPropNode(node, "xpath");
8251 NULL, node,
8270 xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
8274 child = node->children;
8286 NULL, node, child,
8297 * @node: a subtree containing XML Schema informations
8306 xmlNodePtr node,
8319 attr = node->properties;
8338 attr = xmlSchemaGetPropNode(node, "name");
8342 NULL, node,
8352 idcCategory, node);
8356 xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
8361 attr = xmlSchemaGetPropNode(node, "refer");
8365 NULL, node,
8379 xmlSchemaCheckReference(ctxt, schema, node, attr,
8386 child = node->children;
8394 NULL, node, child,
8426 NULL, node, child,
8433 NULL, node, child,
8444 * @node: a subtree containing XML Schema informations
8455 xmlNodePtr node, int *isElemRef, int topLevel)
8468 if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
8478 nameAttr = xmlSchemaGetPropNode(node, "name");
8479 attr = xmlSchemaGetPropNode(node, "ref");
8484 NULL, node, "name", NULL);
8490 xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
8491 child = node->children;
8504 min = xmlGetMinOccurs(ctxt, node, 0, -1, 1, "xs:nonNegativeInteger");
8505 max = xmlGetMaxOccurs(ctxt, node, 0, UNBOUNDED, 1, "(xs:nonNegativeInteger | unbounded)");
8506 xmlSchemaPCheckParticleCorrect_2(ctxt, NULL, node, min, max);
8507 particle = xmlSchemaAddParticle(ctxt, node, min, max);
8524 xmlSchemaCheckReference(ctxt, schema, node, attr, refNs);
8535 attr = node->properties;
8566 NULL, node, child, NULL, "(annotation?)");
8603 attr = xmlSchemaGetPropNode(node, "form");
8618 decl = xmlSchemaAddElement(ctxt, name, ns, node, topLevel);
8625 attr = node->properties;
8669 NULL, node, "substitutionGroup",
8671 if (xmlGetBooleanProp(ctxt, node, "abstract", 0))
8676 attr = xmlSchemaGetPropNode(node, "final");
8699 attr = xmlSchemaGetPropNode(node, "block");
8725 if (xmlGetBooleanProp(ctxt, node, "nillable", 0))
8728 attr = xmlSchemaGetPropNode(node, "type");
8733 xmlSchemaCheckReference(ctxt, schema, node,
8736 decl->value = xmlSchemaGetProp(ctxt, node, "default");
8737 attr = xmlSchemaGetPropNode(node, "fixed");
8765 NULL, node, child,
8780 NULL, node, child,
8809 NULL, node, child,
8843 * @node: a subtree containing XML Schema informations
8853 xmlNodePtr node)
8860 if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
8876 attr = node->properties;
8890 xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
8895 attr = xmlSchemaGetPropNode(node, "memberTypes");
8956 child = node->children;
8991 NULL, node, child, NULL, "(annotation?, simpleType*)");
9001 NULL, node,
9012 * @node: a subtree containing XML Schema informations
9022 xmlNodePtr node)
9028 if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
9044 attr = node->properties;
9059 xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
9069 node, "itemType", &(type->baseNs), &(type->base));
9073 child = node->children;
9088 NULL, node,
9098 NULL, node,
9105 NULL, node, child, NULL, "(annotation?, simpleType?)");
9109 (xmlSchemaGetPropNode(node, "itemType") == NULL)) {
9112 NULL, node,
9123 * @node: a subtree containing XML Schema informations
9133 xmlNodePtr node, int topLevel)
9141 if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
9145 attr = xmlSchemaGetPropNode(node, "name");
9149 NULL, node,
9170 NULL, node,
9199 ctxt->targetNamespace, node, 0);
9203 NULL, ctxt->targetNamespace, node, 0);
9212 attr = node->properties;
9232 attrValue, ctxt->targetNamespace, node, 1);
9241 attr = node->properties;
9259 attr = xmlSchemaGetPropNode(node, "final");
9268 attrValue = xmlSchemaGetProp(ctxt, node, "final");
9283 xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
9291 child = node->children;
9298 NULL, node, child, NULL,
9314 NULL, node, child, NULL,
9326 NULL, node, "This is a redefinition, thus the "
9338 * @node: the node
9348 xmlNodePtr node)
9356 if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
9359 attr = xmlSchemaGetPropNode(node, "ref");
9363 NULL, node, "ref", NULL);
9369 xmlSchemaCheckReference(ctxt, schema, node, attr, refNs);
9370 min = xmlGetMinOccurs(ctxt, node, 0, -1, 1, "xs:nonNegativeInteger");
9371 max = xmlGetMaxOccurs(ctxt, node, 0, UNBOUNDED, 1,
9376 attr = node->properties;
9392 xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
9393 item = xmlSchemaAddParticle(ctxt, node, min, max);
9402 xmlSchemaPCheckParticleCorrect_2(ctxt, item, node, min, max);
9406 child = node->children;
9418 NULL, node, child, NULL,
9434 * @node: a subtree containing XML Schema informations
9450 xmlNodePtr node)
9457 if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
9460 attr = xmlSchemaGetPropNode(node, "name");
9464 NULL, node,
9472 ctxt->targetNamespace, node);
9478 attr = node->properties;
9492 xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
9496 child = node->children;
9520 NULL, node, child, NULL,
9529 * @node: the root of the document.
9564 * Skip to next node
9631 xmlNodePtr node)
9642 res = xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
9650 attr = xmlSchemaGetPropNode(node, "version");
9657 attr = xmlSchemaGetPropNode(node, "targetNamespace");
9667 attr = xmlSchemaGetPropNode(node, "elementFormDefault");
9680 attr = xmlSchemaGetPropNode(node, "attributeFormDefault");
9693 attr = xmlSchemaGetPropNode(node, "finalDefault");
9711 attr = xmlSchemaGetPropNode(node, "blockDefault");
10101 xmlNodePtr node;
10134 node = xmlDocGetRootElement(bucket->doc);
10135 ret = xmlSchemaParseSchemaElement(pctxt, schema, node);
10139 if (node->children == NULL)
10142 ret = xmlSchemaParseSchemaTopLevel(pctxt, schema, node->children);
10273 * @node: a subtree containing XML Schema informations
10697 * @node: a subtree containing XML Schema informations
10707 xmlNodePtr node)
10716 if ((pctxt == NULL) || (schema == NULL) || (node == NULL))
10722 attr = node->properties;
10740 if (xmlSchemaPValAttr(pctxt, NULL, node,
10745 NULL, node,
10751 if (xmlSchemaPValAttr(pctxt, NULL, node,
10756 NULL, node,
10764 child = node->children;
10775 NULL, node, child, NULL,
10796 NULL, node,
10810 NULL, node,
10822 schemaLocation, node);
10824 schemaLocation, NULL, NULL, 0, node, thisTargetNamespace,
10840 node, NULL,
10855 xmlNodePtr node,
10861 if ((pctxt == NULL) || (schema == NULL) || (node == NULL) ||
10870 attr = node->properties;
10884 xmlSchemaPValAttrID(pctxt, node, BAD_CAST "id");
10892 attr = xmlSchemaGetPropNode(node, "schemaLocation");
10901 base = xmlNodeGetBase(node->doc, node);
10903 uri = xmlBuildURI(*schemaLocation, node->doc->URL);
10918 NULL, node, "schemaLocation", NULL);
10928 NULL, node,
10934 NULL, node,
10951 xmlNodePtr node,
10960 if ((pctxt == NULL) || (schema == NULL) || (node == NULL))
10968 node, (xmlChar **) (&schemaLocation), type);
10975 NULL, 0, node, pctxt->targetNamespace, NULL, &bucket);
10998 node, NULL,
11015 node, NULL,
11035 node, NULL,
11046 NULL, node,
11064 node, NULL,
11093 child = node->children;
11142 NULL, node, child, NULL,
11146 NULL, node, child, NULL,
11158 xmlNodePtr node)
11165 res = xmlSchemaParseIncludeOrRedefine(pctxt, schema, node,
11174 xmlNodePtr node)
11178 res = xmlSchemaParseIncludeOrRedefine(pctxt, schema, node,
11189 * @node: a subtree containing XML Schema informations
11212 xmlNodePtr node, xmlSchemaTypeType type,
11221 if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
11226 item = xmlSchemaAddModelGroup(ctxt, schema, type, node);
11232 min = xmlGetMinOccurs(ctxt, node, 0, 1, 1, "(0 | 1)");
11233 max = xmlGetMaxOccurs(ctxt, node, 1, 1, 1, "1");
11236 min = xmlGetMinOccurs(ctxt, node, 0, -1, 1, "xs:nonNegativeInteger");
11237 max = xmlGetMaxOccurs(ctxt, node, 0, UNBOUNDED, 1,
11240 xmlSchemaPCheckParticleCorrect_2(ctxt, NULL, node, min, max);
11244 particle = xmlSchemaAddParticle(ctxt, node, min, max);
11251 attr = node->properties;
11270 attr = node->properties;
11288 xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
11292 child = node->children;
11340 NULL, node, child, NULL,
11447 NULL, node, child, NULL,
11469 * @node: a subtree containing XML Schema informations
11478 xmlNodePtr node, xmlSchemaTypeType parentType)
11484 if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
11493 attr = node->properties;
11510 xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
11523 if (xmlSchemaPValAttrQName(ctxt, schema, NULL, node, "base",
11529 NULL, node, "base", NULL);
11536 NULL, node, "base", NULL);
11549 NULL, node, "This is a redefinition, but the QName "
11566 child = node->children;
11588 NULL, node, child,
11599 NULL, node, child,
11743 NULL, node, child, NULL,
11749 NULL, node, child, NULL,
11758 NULL, node, child, NULL,
11772 * @node: a subtree containing XML Schema informations
11782 xmlNodePtr node, xmlSchemaTypeType parentType)
11788 if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
11797 attr = node->properties;
11812 xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
11817 if ((xmlSchemaPValAttrQName(ctxt, schema, NULL, node,
11822 NULL, node, "base", NULL);
11827 child = node->children;
11889 NULL, node, child, NULL,
11896 NULL, node, child, NULL,
11908 * @node: a subtree containing XML Schema informations
11917 xmlSchemaPtr schema, xmlNodePtr node,
11924 if ((ctxt == NULL) || (schema == NULL) || (node == NULL) ||
11934 attr = node->properties;
11948 xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
11953 child = node->children;
11965 NULL, node, NULL, NULL,
11971 NULL, node, NULL, NULL,
11988 NULL, node, child, NULL,
11998 * @node: a subtree containing XML Schema informations
12007 xmlSchemaPtr schema, xmlNodePtr node,
12014 if ((ctxt == NULL) || (schema == NULL) || (node == NULL) ||
12023 attr = node->properties;
12039 xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
12044 if (xmlGetBooleanProp(ctxt, node, "mixed", 0)) {
12048 child = node->children;
12060 NULL, node, NULL,
12066 NULL, node, NULL,
12083 NULL, node, child,
12093 * @node: a subtree containing XML Schema informations
12102 xmlNodePtr node, int topLevel)
12115 if ((ctxt == NULL) || (schema == NULL) || (node == NULL))
12121 attr = xmlSchemaGetPropNode(node, "name");
12124 XML_SCHEMAP_S4S_ATTR_MISSING, NULL, node, "name", NULL);
12141 ctxt->targetNamespace, node, 0);
12145 NULL, ctxt->targetNamespace, node, 0);
12150 type->node = node;
12161 name, ctxt->targetNamespace, node, 1);
12164 type->node = node;
12172 attr = node->properties;
12179 xmlSchemaPValAttrID(ctxt, node, BAD_CAST "id");
12273 child = node->children;
12356 NULL, node, child,
12366 NULL, node, "This is a redefinition, thus the "
13172 WXS_BASIC_CAST type, type->node,
13178 WXS_BASIC_CAST type, type->node,
13222 WXS_BASIC_CAST elemDecl, elemDecl->node,
13310 WXS_BASIC_CAST type, type->node, "memberTypes",
13695 xmlSchemaPErr(ctxt, completeWild->node,
13933 xmlSchemaPErr(ctxt, completeWild->node, XML_SCHEMAP_INTERSECTION_NOT_EXPRESSIBLE,
15035 WXS_BASIC_CAST typeDef, typeDef->node,
15063 WXS_BASIC_CAST typeDef, typeDef->node,
15778 xmlNodePtr node,
15791 * @node: an optional node (the holder of the value)
15804 xmlNodePtr node,
15832 WXS_BASIC_CAST type, type->node,
15851 ret = xmlSchemaVCheckCVCSimpleType(ACTXT_CAST pctxt, node,
15854 ret = xmlSchemaVCheckCVCSimpleType(ACTXT_CAST pctxt, node,
16398 type->node, WXS_BASIC_CAST type,
16409 type->node, WXS_BASIC_CAST type,
16626 WXS_BASIC_CAST type, type->node,
17154 WXS_BASIC_CAST fac1, fac1->node, \
17163 WXS_BASIC_CAST fac1, fac1->node, \
17169 WXS_BASIC_CAST fac, fac->node, \
18001 if (type->node != NULL) {
18004 type->node->doc->URL,
18005 xmlGetLineNo(type->node));
18106 * xmlSchemaPErr(ctxt, type->node,
18228 type->node, 0);
18232 type->node, 0);
18237 * We will use the same node as for the <complexType>
18352 * NOTE that we sill assign it the <complexType> node to
18361 type->node, 1, 1);
18369 XML_SCHEMA_TYPE_SEQUENCE, type->node);
18486 type->node, 1, 1);
18494 XML_SCHEMA_TYPE_SEQUENCE, type->node);
18506 type->node,
18697 * facet->node is just the node holding the facet
18702 ACTXT_CAST pctxt, facet->node, base,
18709 XML_SCHEMAP_INTERNAL, facet->node, NULL,
18723 ret, facet->node, WXS_BASIC_CAST facet,
18748 ret, facet->node, WXS_BASIC_CAST typeDecl,
18784 ret, facet->node, WXS_BASIC_CAST typeDecl,
18809 ret, facet->node, WXS_BASIC_CAST typeDecl,
19144 * @node: the node of the component holding the attribute uses
19227 * to any node in the schema, we will anchor it on
19228 * the node of the owner component.
19292 prohib->node, NULL,
19390 attrGr->node, WXS_BASIC_CAST attrGr,
19420 attrGr->node, WXS_BASIC_CAST attrGr,
19462 NULL, ref->node,
19529 attr->node, WXS_ATTR_TYPEDEF(attr),
19706 xmlNodePtr node = NULL;
19715 xmlSchemaPErr(pctxt, elemDecl->node,
19722 if (elemDecl->node != NULL) {
19724 node = (xmlNodePtr) xmlHasProp(elemDecl->node,
19727 node = (xmlNodePtr) xmlHasProp(elemDecl->node,
19730 vcret = xmlSchemaParseCheckCOSValidDefault(pctxt, node,
20185 WXS_BASIC_CAST ause, ause->node,
20259 use->node, WXS_ATTRUSE_TYPEDEF(use),
20335 WXS_BASIC_CAST item, item->node,
20378 WXS_BASIC_CAST idc, idc->node,
20432 NULL, prohib->node,
20480 xmlNodePtr node;
20498 node = WXS_ITEM_NODE(redef->reference);
20500 node = WXS_ITEM_NODE(item);
20507 XML_SCHEMAP_SRC_REDEFINE, node, NULL,
20598 xmlNodePtr node;
20601 node = WXS_ITEM_NODE(redef->reference);
20603 node = WXS_ITEM_NODE(redef->item);
20608 node, NULL,
21581 * @node: the node that fired the assembling
21593 xmlNodePtr node,
21619 location, node);
21626 location, NULL, NULL, 0, node, NULL, nsName,
21635 node, NULL,
21789 iattr->node, NULL,
21799 iattr->node, nsname, location);
21853 if ((vctxt->inode->node == NULL) ||
21854 (vctxt->inode->node->doc == NULL)) {
21856 "no node or node's doc avaliable");
21859 ns = xmlSearchNs(vctxt->inode->node->doc,
21860 vctxt->inode->node, prefix);
21873 xmlNodePtr node,
21898 else if (node != NULL) {
21899 xmlNsPtr ns = xmlSearchNs(node->doc, node, prefix);
22052 * @item: the IDC node table item
22054 * The validation context is used to store IDC node table items.
22055 * They are stored to avoid copying them if IDC node-tables are merged
22056 * with corresponding parent IDC node-tables (bubbling).
22072 "allocating the IDC node table item list", NULL);
22083 "re-allocating the IDC node table item list", NULL);
22136 * @ntItem: the node-table item
22138 * Appends the IDC node-table item to the binding.
22152 "allocating an array of IDC node-table items", NULL);
22162 "re-allocating an array of IDC node-table items", NULL);
22239 * Frees an IDC binding. Note that the node table-items
22295 * Node-table items for keyrefs are not stored globally
22344 * Node-table items for keyrefs are not stored globally
22450 * @nodeType: the nodeType of the current node
22455 * this node, 0 if none resolved and -1 on internal errors.
22561 * An IDC key node was found by the IDC field.
22568 * Notify that the character value of this node is
22581 * Evaluate field state objects created on this node as well.
22656 * @type: the simple/complex type of the current node if any at all
22740 * Not qualified if the field resolves to a node of non
22746 "The XPath '%s' of a field of %s does evaluate to a node of "
22774 * by the target node's depth relative to the matcher's
22844 * 3 For each node in the ?target node set? all
22845 * of the {fields}, with that node as the context
22846 * node, evaluate to either an empty node-set or
22847 * a node-set with exactly one member, which must
22856 "node-set with more than one member",
22882 * Create a key once per node only.
22921 * An IDC 'selector' state object resolved to a target node,
22922 * during the time this target node was in the
22925 * target node. Now we are back to this target node and need
22926 * to put the key-sequence, together with the target node
22927 * itself, into the node-table of the corresponding IDC
22936 * if it has a key-sequence for the current target node.
22974 * then no two members of the ?qualified node set? have
23037 * Add a node-table item to the IDC binding.
23043 "allocating an IDC node-table item", NULL);
23051 * Store the node-table item in a global list.
23063 * Save a cached QName for this node on the IDC node, to be
23064 * able to report it, even if the node is not saved.
23076 * Init the node-table item: Save the node, position and
23079 ntItem->node = vctxt->node;
23103 * 4.2.1 (KEY) The ?target node set? and the
23104 * ?qualified node set? are equal, that is, every
23105 * member of the ?target node set? is also a member
23106 * of the ?qualified node set? and vice versa.
23111 "Not all fields of %s evaluate to a node",
23207 * Remember that we have keyrefs on this node.
23311 * If we _want_ the IDC node-table to be created in any case
23341 * Transfer all IDC target-nodes to the IDC node-table.
23353 * Compare the key-sequences and add to the IDC node-table.
23444 * Remove the duplicate entry from the IDC node-table.
23456 * If everything is fine, then add the IDC target-node to
23457 * the IDC node-table.
23480 * both, the parent node-table entry and child entry are discarded from the
23481 * node-table of the parent.
23488 xmlSchemaPSVIIDCBindingPtr bind; /* IDC bindings of the current node. */
23490 xmlSchemaPSVIIDCNodePtr node, parNode = NULL, *dupls, *parNodes; /* node-table entries. */
23540 * Compare every node-table entry of the child node,
23557 node = bind->nodeTable[i];
23558 if (node == NULL)
23561 * ...with every key-sequence of the parent node, already
23569 node->keys[0]->val,
23581 node->keys[k]->val,
23600 * ... and with every key-sequence of the parent node.
23608 node->keys[0]->val,
23619 node->keys[k]->val,
23635 * the parent's node-table to the list of
23661 * Add the node-table entry (node and key-sequence) of
23662 * the child node to the node table of the parent node.
23669 "allocating IDC list of node-table items", NULL);
23680 "re-allocating IDC list of node-table items", NULL);
23686 * Append the new node-table entry to the 'new node-table
23689 parNodes[parBind->nbNodes++] = node;
23698 * copy all node-tables.
23710 * Add all IDC node-table entries.
23734 "allocating an array of IDC node-table "
23802 * Find the IDC node-table for the referenced IDC key/unique.
23972 attr->node = attrNode;
24151 xmlNodePtr node,
24236 xmlSchemaFacetErr(actxt, ret, node,
24272 xmlSchemaFacetErr(actxt, ret, node,
24324 xmlSchemaFacetErr(actxt, ret, node,
24369 xmlSchemaFacetErr(actxt, ret, node,
24466 xmlNodePtr node,
24564 value, &val, node);
24567 value, NULL, node);
24574 ((xmlSchemaParserCtxtPtr) actxt)->schema, node,
24581 value, &val, node);
24584 value, NULL, node);
24609 ret = xmlSchemaValidateFacets(actxt, node, type,
24625 xmlSchemaSimpleTypeErr(actxt, ret, node, value, type, 1);
24660 ret = xmlSchemaVCheckCVCSimpleType(actxt, node, itemType,
24663 ret = xmlSchemaVCheckCVCSimpleType(actxt, node, itemType,
24693 ret = xmlSchemaValidateFacets(actxt, node, type,
24711 xmlSchemaSimpleTypeErr(actxt, ret, node, value, type, 1);
24745 ret = xmlSchemaVCheckCVCSimpleType(actxt, node,
24748 ret = xmlSchemaVCheckCVCSimpleType(actxt, node,
24772 ret = xmlSchemaValidateFacets(actxt, node, type,
24785 xmlSchemaSimpleTypeErr(actxt, ret, node, value, type, 1);
25452 if (ielem && ielem->node && ielem->node->doc)
25453 defAttrOwnerElem = ielem->node;
25563 * root node if no namespace declaration is in scope.
25634 iattr->node, iattr->typeDef, iattr->value, &(iattr->val),
25639 iattr->node, iattr->typeDef, iattr->value, NULL,
26068 * Do not check further content if the node has been nilled
26222 * PSVI: Create a text node on the instance element.
26225 (inode->node != NULL)) {
26243 xmlAddChild(inode->node, textChild);
26388 * PSVI TODO: If we expose IDC node-tables via PSVI then the tables
26390 * We will currently build IDC node-tables and bubble them only if
26395 * Add the current IDC target-nodes to the IDC node-tables.
26423 * Merge the IDC node table with the table of the parent node.
27084 * node tree, to be able to pass a node here?
27200 * Read next node.
27388 * TODO: Set the node line.
27862 xmlNodePtr node, valRoot;
27877 node = valRoot;
27878 while (node != NULL) {
27881 if (node->type == XML_ELEMENT_NODE) {
27884 * Init the node-info.
27890 ielem->node = node;
27891 ielem->nodeLine = node->line;
27892 ielem->localName = node->name;
27893 if (node->ns != NULL)
27894 ielem->nsName = node->ns->href;
27902 if (node->properties != NULL) {
27903 attr = node->properties;
27945 } else if ((node->type == XML_TEXT_NODE) ||
27946 (node->type == XML_CDATA_SECTION_NODE)) {
27952 ret = xmlSchemaVPushText(vctxt, node->type, node->content,
27963 } else if ((node->type == XML_ENTITY_NODE) ||
27964 (node->type == XML_ENTITY_REF_NODE)) {
27969 "there is at least one entity reference in the node-tree "
27983 if (node->children != NULL) {
27984 node = node->children;
27988 if (node->type == XML_ELEMENT_NODE) {
27992 if (node != vctxt->inode->node) {
28005 if (node == valRoot)
28009 if (node->next != NULL)
28010 node = node->next;
28012 node = node->parent;
28137 * @elem: an element node
28154 ctxt->node = elem;
28176 ctxt->node = xmlDocGetRootElement(doc);
28177 if (ctxt->node == NULL) {
28184 ctxt->validationRoot = ctxt->node;
