Lines Matching +defs:child +defs:name
16 * need to validate all schema attributes (ref, type, name)
173 #define WXS_ATTRUSE_DECL_NAME(au) (WXS_ATTRUSE_DECL(au))->name
318 (xmlStrEqual(node->name, (const xmlChar *) type)) && \
544 const xmlChar *name;
559 const xmlChar *refName; /* The name of the to-be-redefined component. */
648 const xmlChar *name;
704 const xmlChar *name;
741 const xmlChar *name;
1114 * Returns the component name of a schema item.
1170 * Returns the component name of a schema item.
1282 * @namespaceName: the namespace name
1283 * @localName: the local name
1326 return (((xmlSchemaElementPtr) item)->name);
1328 return (((xmlSchemaAttributePtr) item)->name);
1330 return (((xmlSchemaAttributeGroupPtr) item)->name);
1334 return (((xmlSchemaTypePtr) item)->name);
1336 return (((xmlSchemaModelGroupDefPtr) item)->name);
1340 return (((xmlSchemaIDCPtr) item)->name);
1348 return (((xmlSchemaQNameRefPtr) item)->name);
1350 return (((xmlSchemaNotationPtr) item)->name);
1360 #define xmlSchemaGetQNameRefName(r) (WXS_QNAME_CAST (r))->name
1366 return(((xmlSchemaQNameRefPtr) ref)->name);
1547 * @itemName: the name of the item
1550 * @local: the local name
1564 * If the itemNode is an attribute node, the name of the attribute
1598 *buf = xmlStrcat(*buf, type->name);
1620 *buf = xmlStrcat(*buf, type->name);
1635 *buf = xmlStrcat(*buf, type->name);
1663 attr->targetNamespace, attr->name));
1678 elem->targetNamespace, elem->name));
1691 *buf = xmlStrcat(*buf, ((xmlSchemaIDCPtr) item)->name);
1753 xmlSchemaFormatQName(&str, elem->ns->href, elem->name));
1756 *buf = xmlStrcat(*buf, elem->name);
1764 itemNode->ns->href, itemNode->name));
1767 *buf = xmlStrcat(*buf, itemNode->name);
1917 * @node: the current child
1927 xmlNodePtr child, int error,
1930 if (child != NULL)
1931 xmlSchemaPErr(ctxt, child, error, msg, str1, str2);
2197 elem->ns->href, elem->name));
2200 NULL, elem->name));
2209 node->ns->href, node->name));
2212 NULL, node->name));
2477 msg = xmlStrcat(msg, type->name);
2481 type->targetNamespace, type->name));
2501 return (xmlSchemaFormatQName(str, node->ns->href, node->name));
2503 return (xmlSchemaFormatQName(str, NULL, node->name));
2566 * Get the local name.
2587 * Get the namespace name.
2764 * @ownerName: the name of the owner
2777 const char *name,
2789 BAD_CAST des, BAD_CAST name);
2801 * @name: the name of the attribute holding the QName
2802 * @refName: the referenced local name
2814 const char *name,
2828 "%s.\n", BAD_CAST des, BAD_CAST name,
2870 BAD_CAST des, attr->name, (const xmlChar *) msg, NULL, NULL);
2897 xmlSchemaFormatQNameNs(&strB, attr->ns, attr->name),
3142 msg = xmlStrcat(msg, type->name);
3146 type->targetNamespace, type->name));
3184 * @child: the invalid child node
3195 xmlNodePtr child,
3203 xmlSchemaPErr2(ctxt, ownerElem, child, error,
3208 xmlSchemaPErr2(ctxt, ownerElem, child, error,
3212 xmlSchemaPErr2(ctxt, ownerElem, child, error,
4176 const xmlChar * name ATTRIBUTE_UNUSED,
4187 fprintf(output, ": '%s' ", elem->name);
4309 ((xmlSchemaElementPtr)term)->name));
4362 const xmlChar *name, *tns;
4375 name = prohib->name;
4380 name = ref->name;
4384 name = WXS_ATTRUSE_DECL_NAME(use);
4388 (const char *) xmlSchemaFormatQName(&str, tns, name));
4408 if (type->name != NULL)
4409 fprintf(output, "'%s' ", type->name);
4411 fprintf(output, "(no name) ");
4511 if (schema->name != NULL)
4512 fprintf(output, "%s, ", schema->name);
4514 fprintf(output, "no name, ");
4616 * @name: the name of the attribute
4618 * Seeks an attribute with a name of @name in
4624 xmlSchemaGetPropNode(xmlNodePtr node, const char *name)
4628 if ((node == NULL) || (name == NULL))
4632 if ((prop->ns == NULL) && xmlStrEqual(prop->name, BAD_CAST name))
4643 * @name: the name of the attribute
4645 * Seeks an attribute with a local name of @name and
4651 xmlSchemaGetPropNodeNs(xmlNodePtr node, const char *uri, const char *name)
4655 if ((node == NULL) || (name == NULL))
4660 xmlStrEqual(prop->name, BAD_CAST name) &&
4692 * @name: the property name
4700 const char *name)
4705 val = xmlGetNoNsProp(node, BAD_CAST name);
4721 ret = xmlHashLookup(schema->slot, name); \
4733 ret = xmlHashLookup(import->schema->slot, name); \
4739 * @name: the element name
4747 xmlSchemaGetElem(xmlSchemaPtr schema, const xmlChar * name,
4752 if ((name == NULL) || (schema == NULL))
4761 fprintf(stderr, "Unable to lookup element decl. %s", name);
4763 fprintf(stderr, "Unable to lookup element decl. %s:%s", name,
4773 * @name: the type's name
4781 xmlSchemaGetType(xmlSchemaPtr schema, const xmlChar * name,
4786 if (name == NULL)
4790 ret = xmlSchemaGetPredefinedType(name, nsName);
4808 fprintf(stderr, "Unable to lookup type %s", name);
4810 fprintf(stderr, "Unable to lookup type %s:%s", name,
4820 * @name: the name of the attribute
4828 xmlSchemaGetAttributeDecl(xmlSchemaPtr schema, const xmlChar * name,
4833 if ((name == NULL) || (schema == NULL))
4842 fprintf(stderr, "Unable to lookup attribute %s", name);
4844 fprintf(stderr, "Unable to lookup attribute %s:%s", name,
4854 * @name: the name of the attribute group
4862 xmlSchemaGetAttributeGroup(xmlSchemaPtr schema, const xmlChar * name,
4867 if ((name == NULL) || (schema == NULL))
4882 fprintf(stderr, "Unable to lookup attribute group %s", name);
4884 fprintf(stderr, "Unable to lookup attribute group %s:%s", name,
4894 * @name: the name of the group
4902 xmlSchemaGetGroup(xmlSchemaPtr schema, const xmlChar * name,
4907 if ((name == NULL) || (schema == NULL))
4917 fprintf(stderr, "Unable to lookup group %s", name);
4919 fprintf(stderr, "Unable to lookup group %s:%s", name,
4928 const xmlChar *name,
4933 if ((name == NULL) || (schema == NULL))
4944 const xmlChar *name,
4949 if ((name == NULL) || (schema == NULL))
4961 * @name: the name of the group
4971 const xmlChar *name,
4977 name, targetNs));
4980 name, targetNs));
5026 #define WXS_COMP_NAME(c, t) ((t) (c))->name
5035 const xmlChar *name,
5041 if ((bucket == NULL) || (name == NULL))
5055 if ((WXS_COMP_NAME(ret, xmlSchemaTypePtr) == name) &&
5064 xmlSchemaModelGroupDefPtr) == name) &&
5073 xmlSchemaAttributeGroupPtr) == name) &&
5102 type, name, nsName);
5117 * @name: the item name
5126 const xmlChar *name, const xmlChar *nsName,
5131 if ((ctxt == NULL) || (schema == NULL) || (name == NULL))
5141 ret->name = name;
5153 * @name: the item name
5163 const xmlChar * name, const xmlChar * nsName,
5179 ret->name = name;
5194 * @name: the item name
5264 * @name: the item name
5275 const xmlChar *name,
5281 if ((pctxt == NULL) || (name == NULL))
5292 ret->name = name;
5300 ret, name, nsName);
5316 * @name: the type name
5326 const xmlChar * name, const xmlChar * nsName,
5331 if ((ctxt == NULL) || (name == NULL))
5341 ret->name = name;
5357 * @name: the item name
5368 const xmlChar * name, const xmlChar * nsName,
5383 ret->name = name;
5389 ret, name, nsName);
5420 ret->name = refName;
5544 * @name: the group name
5553 const xmlChar *name,
5559 if ((ctxt == NULL) || (schema == NULL) || (name == NULL))
5569 ret->name = name;
5576 ret, name, nsName);
5614 const xmlChar *name, const xmlChar *nsName,
5619 if ((ctxt == NULL) || (schema == NULL) || (name == NULL))
5631 ret->name = name;
5714 head->name, head->targetNamespace, ret) != 0) {
5730 head->name, head->targetNamespace));
5780 * Extracts the local name and the URI of a QName value and validates it.
5831 * At this point xmlSplitQName3 has to return a local name.
5890 * @name: the name of the attribute
5904 const char *name,
5910 attr = xmlSchemaGetPropNode(ownerElem, name);
5927 * @name: the name of the attribute
5992 const xmlChar *name)
5996 attr = xmlSchemaGetPropNode(ownerElem, (const char *) name);
6170 * @name: the attribute name
6181 const char *name, int def)
6185 val = xmlSchemaGetProp(ctxt, node, name);
6205 (xmlNodePtr) xmlSchemaGetPropNode(node, name),
6362 * @name: the name of the schema attribute node
6377 const char *name,
6395 type->name, NULL);
6398 attr = xmlSchemaGetPropNode(ownerElem, name);
6468 xmlNodePtr *child, xmlSchemaItemListPtr *list,
6473 while ((IS_SCHEMA((*child), "attribute")) ||
6474 (IS_SCHEMA((*child), "attributeGroup"))) {
6475 if (IS_SCHEMA((*child), "attribute")) {
6476 item = xmlSchemaParseLocalAttribute(ctxt, schema, *child,
6479 item = xmlSchemaParseAttributeGroupRef(ctxt, schema, *child);
6493 *child = (*child)->next;
6514 xmlNodePtr child = NULL;
6535 (!xmlStrEqual(attr->name, BAD_CAST "id"))) ||
6548 child = node->children;
6549 while (child != NULL) {
6550 if (IS_SCHEMA(child, "appinfo")) {
6557 attr = child->properties;
6560 (!xmlStrEqual(attr->name, BAD_CAST "source"))) ||
6569 xmlSchemaPValAttr(ctxt, NULL, child, "source",
6571 child = child->next;
6572 } else if (IS_SCHEMA(child, "documentation")) {
6579 attr = child->properties;
6582 if (!xmlStrEqual(attr->name, BAD_CAST "source")) {
6588 (xmlStrEqual(attr->name, BAD_CAST "lang") &&
6600 attr = xmlSchemaGetPropNodeNs(child, (const char *) XML_XML_NAMESPACE, "lang");
6604 child = child->next;
6609 NULL, node, child, NULL, "(appinfo | documentation)*");
6611 child = child->next;
6634 xmlNodePtr child = NULL;
6648 xmlSchemaPErr2(ctxt, node, child, XML_SCHEMAP_FACET_NO_VALUE,
6649 "Facet %s has no value\n", node->name, NULL);
6678 xmlSchemaPErr2(ctxt, node, child, XML_SCHEMAP_UNKNOWN_FACET_TYPE,
6679 "Unknown facet type %s\n", node->name, NULL);
6695 child = node->children;
6697 if (IS_SCHEMA(child, "annotation")) {
6698 facet->annot = xmlSchemaParseAnnotation(ctxt, child, 1);
6699 child = child->next;
6701 if (child != NULL) {
6702 xmlSchemaPErr2(ctxt, node, child, XML_SCHEMAP_UNKNOWN_FACET_CHILD,
6703 "Facet %s has unexpected child content\n",
6704 node->name, NULL);
6894 xmlNodePtr child = NULL;
6908 if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
6909 (!xmlStrEqual(attr->name, BAD_CAST "minOccurs")) &&
6910 (!xmlStrEqual(attr->name, BAD_CAST "maxOccurs")) &&
6911 (!xmlStrEqual(attr->name, BAD_CAST "namespace")) &&
6912 (!xmlStrEqual(attr->name, BAD_CAST "processContents"))) {
6941 child = node->children;
6942 if (IS_SCHEMA(child, "annotation")) {
6943 annot = xmlSchemaParseAnnotation(ctxt, child, 1);
6944 child = child->next;
6946 if (child != NULL) {
6949 NULL, node, child,
6985 const xmlChar *name;
6987 xmlNodePtr child = NULL;
6991 name = xmlSchemaGetProp(ctxt, node, "name");
6992 if (name == NULL) {
6993 xmlSchemaPErr2(ctxt, node, child, XML_SCHEMAP_NOTATION_NO_NAME,
6994 "Notation has no name\n", NULL, NULL);
6997 ret = xmlSchemaAddNotation(ctxt, schema, name,
7003 child = node->children;
7004 if (IS_SCHEMA(child, "annotation")) {
7005 ret->annot = xmlSchemaParseAnnotation(ctxt, child, 1);
7006 child = child->next;
7008 if (child != NULL) {
7011 NULL, node, child,
7034 xmlNodePtr child = NULL;
7051 if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
7052 (!xmlStrEqual(attr->name, BAD_CAST "namespace")) &&
7053 (!xmlStrEqual(attr->name, BAD_CAST "processContents"))) {
7072 child = node->children;
7073 if (IS_SCHEMA(child, "annotation")) {
7074 ret->annot = xmlSchemaParseAnnotation(ctxt, child, 1);
7075 child = child->next;
7077 if (child != NULL) {
7080 NULL, node, child,
7106 const xmlChar *attrValue, *name = NULL, *ns = NULL;
7108 xmlNodePtr child = NULL;
7141 if (xmlStrEqual(attr->name, BAD_CAST "id")) {
7144 } else if (xmlStrEqual(attr->name, BAD_CAST "ref")) {
7148 if (xmlStrEqual(attr->name, BAD_CAST "name")) {
7150 } else if (xmlStrEqual(attr->name, BAD_CAST "id")) {
7153 } else if (xmlStrEqual(attr->name, BAD_CAST "type")) {
7157 } else if (xmlStrEqual(attr->name, BAD_CAST "form")) {
7177 if (xmlStrEqual(attr->name, BAD_CAST "use")) {
7195 } else if (xmlStrEqual(attr->name, BAD_CAST "default")) {
7209 } else if (xmlStrEqual(attr->name, BAD_CAST "fixed")) {
7270 attr = xmlSchemaGetPropNode(node, "name");
7273 NULL, node, "name", NULL);
7277 xmlSchemaGetBuiltInType(XML_SCHEMAS_NCNAME), &name) != 0) {
7284 if (xmlStrEqual(name, BAD_CAST "xmlns")) {
7305 attrDecl = xmlSchemaAddAttribute(pctxt, schema, name, ns, node, 0);
7360 child = node->children;
7364 if (IS_SCHEMA(child, "annotation")) {
7365 xmlSchemaParseAnnotation(pctxt, child, 0);
7366 child = child->next;
7368 if (child != NULL) {
7371 NULL, node, child, NULL,
7395 tmpName = name;
7407 (tmpName == (WXS_ATTR_PROHIB_CAST use)->name) &&
7430 prohib->name = tmpName;
7440 if (IS_SCHEMA(child, "annotation")) {
7444 use->annot = xmlSchemaParseAnnotation(pctxt, child, 1);
7445 child = child->next;
7448 if (child != NULL) {
7449 if (IS_SCHEMA(child, "simpleType"))
7457 NULL, node, child, NULL,
7462 NULL, node, child, NULL,
7466 if (IS_SCHEMA(child, "simpleType")) {
7473 NULL, node, child,
7474 "The attribute 'type' and the <simpleType> child "
7478 xmlSchemaParseSimpleType(pctxt, schema, child, 0);
7479 child = child->next;
7481 if (child != NULL)
7483 NULL, node, child, NULL,
7498 xmlNodePtr child = NULL;
7511 * One of ref or name must be present, but not both
7513 attr = xmlSchemaGetPropNode(node, "name");
7516 NULL, node, "name", NULL);
7561 if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
7562 (!xmlStrEqual(attr->name, BAD_CAST "default")) &&
7563 (!xmlStrEqual(attr->name, BAD_CAST "fixed")) &&
7564 (!xmlStrEqual(attr->name, BAD_CAST "name")) &&
7565 (!xmlStrEqual(attr->name, BAD_CAST "type")))
7604 child = node->children;
7605 if (IS_SCHEMA(child, "annotation")) {
7606 ret->annot = xmlSchemaParseAnnotation(pctxt, child, 1);
7607 child = child->next;
7609 if (IS_SCHEMA(child, "simpleType")) {
7616 NULL, node, child,
7617 "The attribute 'type' and the <simpleType> child "
7620 ret->subtypes = xmlSchemaParseSimpleType(pctxt, schema, child, 0);
7621 child = child->next;
7623 if (child != NULL)
7625 NULL, node, child, NULL,
7650 xmlNodePtr child = NULL;
7675 if ((!xmlStrEqual(attr->name, BAD_CAST "ref")) &&
7676 (!xmlStrEqual(attr->name, BAD_CAST "id")))
7693 child = node->children;
7694 if (IS_SCHEMA(child, "annotation")) {
7698 xmlSchemaParseAnnotation(pctxt, child, 0);
7699 child = child->next;
7701 if (child != NULL) {
7704 NULL, node, child, NULL,
7721 * as the ���actual value��� of its own name attribute plus
7780 const xmlChar *name;
7782 xmlNodePtr child = NULL;
7789 attr = xmlSchemaGetPropNode(node, "name");
7793 NULL, node, "name", NULL);
7797 * The name is crucial, exit if invalid.
7801 xmlSchemaGetBuiltInType(XML_SCHEMAS_NCNAME), &name) != 0) {
7805 name, pctxt->targetNamespace, node);
7814 if ((!xmlStrEqual(attr->name, BAD_CAST "name")) &&
7815 (!xmlStrEqual(attr->name, BAD_CAST "id")))
7831 child = node->children;
7832 if (IS_SCHEMA(child, "annotation")) {
7833 ret->annot = xmlSchemaParseAnnotation(pctxt, child, 1);
7834 child = child->next;
7839 if (xmlSchemaParseLocalAttributes(pctxt, schema, &child,
7848 if (IS_SCHEMA(child, "anyAttribute")) {
7850 schema, child);
7851 child = child->next;
7853 if (child != NULL) {
7856 NULL, node, child, NULL,
8213 xmlNodePtr child = NULL;
8222 if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
8223 (!xmlStrEqual(attr->name, BAD_CAST "xpath"))) {
8252 "name", NULL);
8274 child = node->children;
8275 if (IS_SCHEMA(child, "annotation")) {
8280 xmlSchemaParseAnnotation(ctxt, child, 1));
8281 child = child->next;
8283 if (child != NULL) {
8286 NULL, node, child,
8311 xmlNodePtr child = NULL;
8313 const xmlChar *name = NULL;
8322 if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
8323 (!xmlStrEqual(attr->name, BAD_CAST "name")) &&
8325 (!xmlStrEqual(attr->name, BAD_CAST "refer")))) {
8336 * Attribute "name" (mandatory).
8338 attr = xmlSchemaGetPropNode(node, "name");
8343 "name", NULL);
8347 xmlSchemaGetBuiltInType(XML_SCHEMAS_NCNAME), &name) != 0) {
8351 item = xmlSchemaAddIDC(ctxt, schema, name, targetNamespace,
8378 &(item->ref->name));
8386 child = node->children;
8387 if (IS_SCHEMA(child, "annotation")) {
8388 item->annot = xmlSchemaParseAnnotation(ctxt, child, 1);
8389 child = child->next;
8391 if (child == NULL) {
8394 NULL, node, child,
8395 "A child element is missing",
8401 if (IS_SCHEMA(child, "selector")) {
8403 item, child, 0);
8404 child = child->next;
8408 if (IS_SCHEMA(child, "field")) {
8411 item, child, 1);
8421 child = child->next;
8422 } while (IS_SCHEMA(child, "field"));
8426 NULL, node, child,
8430 if (child != NULL) {
8433 NULL, node, child,
8460 xmlNodePtr child = NULL;
8475 * a reference - even if there's a "name" attribute; this seems to be more
8478 nameAttr = xmlSchemaGetPropNode(node, "name");
8484 NULL, node, "name", NULL);
8491 child = node->children;
8492 if (IS_SCHEMA(child, "annotation")) {
8493 annot = xmlSchemaParseAnnotation(ctxt, child, 1);
8494 child = child->next;
8526 * SPEC (3.3.3 : 2.1) "One of ref or name must be present, but not both"
8530 XML_SCHEMAP_SRC_ELEMENT_2_1, NULL, nameAttr, "ref", "name");
8538 if (xmlStrEqual(attr->name, BAD_CAST "ref") ||
8539 xmlStrEqual(attr->name, BAD_CAST "name") ||
8540 xmlStrEqual(attr->name, BAD_CAST "id") ||
8541 xmlStrEqual(attr->name, BAD_CAST "maxOccurs") ||
8542 xmlStrEqual(attr->name, BAD_CAST "minOccurs"))
8564 if (child != NULL) {
8566 NULL, node, child, NULL, "(annotation?)");
8591 const xmlChar *ns = NULL, *fixed, *name, *attrValue;
8595 xmlSchemaGetBuiltInType(XML_SCHEMAS_NCNAME), &name) != 0)
8618 decl = xmlSchemaAddElement(ctxt, name, ns, node, topLevel);
8628 if ((!xmlStrEqual(attr->name, BAD_CAST "name")) &&
8629 (!xmlStrEqual(attr->name, BAD_CAST "type")) &&
8630 (!xmlStrEqual(attr->name, BAD_CAST "id")) &&
8631 (!xmlStrEqual(attr->name, BAD_CAST "default")) &&
8632 (!xmlStrEqual(attr->name, BAD_CAST "fixed")) &&
8633 (!xmlStrEqual(attr->name, BAD_CAST "block")) &&
8634 (!xmlStrEqual(attr->name, BAD_CAST "nillable")))
8637 if ((!xmlStrEqual(attr->name, BAD_CAST "maxOccurs")) &&
8638 (!xmlStrEqual(attr->name, BAD_CAST "minOccurs")) &&
8639 (!xmlStrEqual(attr->name, BAD_CAST "form")))
8644 } else if ((!xmlStrEqual(attr->name, BAD_CAST "final")) &&
8645 (!xmlStrEqual(attr->name, BAD_CAST "abstract")) &&
8646 (!xmlStrEqual(attr->name, BAD_CAST "substitutionGroup"))) {
8756 if (IS_SCHEMA(child, "complexType")) {
8765 NULL, node, child,
8766 "The attribute 'type' and the <complexType> child are "
8769 WXS_ELEM_TYPEDEF(decl) = xmlSchemaParseComplexType(ctxt, schema, child, 0);
8770 child = child->next;
8771 } else if (IS_SCHEMA(child, "simpleType")) {
8780 NULL, node, child,
8781 "The attribute 'type' and the <simpleType> child are "
8784 WXS_ELEM_TYPEDEF(decl) = xmlSchemaParseSimpleType(ctxt, schema, child, 0);
8785 child = child->next;
8787 while ((IS_SCHEMA(child, "unique")) ||
8788 (IS_SCHEMA(child, "key")) || (IS_SCHEMA(child, "keyref"))) {
8789 if (IS_SCHEMA(child, "unique")) {
8790 curIDC = xmlSchemaParseIDC(ctxt, schema, child,
8792 } else if (IS_SCHEMA(child, "key")) {
8793 curIDC = xmlSchemaParseIDC(ctxt, schema, child,
8795 } else if (IS_SCHEMA(child, "keyref")) {
8796 curIDC = xmlSchemaParseIDC(ctxt, schema, child,
8804 child = child->next;
8806 if (child != NULL) {
8809 NULL, node, child,
8856 xmlNodePtr child = NULL;
8879 if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
8880 (!xmlStrEqual(attr->name, BAD_CAST "memberTypes"))) {
8956 child = node->children;
8957 if (IS_SCHEMA(child, "annotation")) {
8962 xmlSchemaParseAnnotation(ctxt, child, 1));
8963 child = child->next;
8965 if (IS_SCHEMA(child, "simpleType")) {
8972 while (IS_SCHEMA(child, "simpleType")) {
8974 xmlSchemaParseSimpleType(ctxt, schema, child, 0);
8985 child = child->next;
8988 if (child != NULL) {
8991 NULL, node, child, NULL, "(annotation?, simpleType*)");
8997 * be non-empty or there must be at least one simpleType [child].
9003 "at least one <simpleType> child must be present", NULL);
9025 xmlNodePtr child = NULL;
9047 if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
9048 (!xmlStrEqual(attr->name, BAD_CAST "itemType"))) {
9073 child = node->children;
9074 if (IS_SCHEMA(child, "annotation")) {
9076 xmlSchemaParseAnnotation(ctxt, child, 1));
9077 child = child->next;
9079 if (IS_SCHEMA(child, "simpleType")) {
9082 * Either the itemType [attribute] or the <simpleType> [child] of
9089 "The attribute 'itemType' and the <simpleType> child "
9092 type->subtypes = xmlSchemaParseSimpleType(ctxt, schema, child, 0);
9094 child = child->next;
9099 "Either the attribute 'itemType' or the <simpleType> child "
9102 if (child != NULL) {
9105 NULL, node, child, NULL, "(annotation?, simpleType?)");
9113 "Either the attribute 'itemType' or the <simpleType> child "
9136 xmlNodePtr child = NULL;
9145 attr = xmlSchemaGetPropNode(node, "name");
9150 "name", NULL);
9215 if (!xmlStrEqual(attr->name, BAD_CAST "id")) {
9229 * Note that attrValue is the value of the attribute "name" here.
9244 if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
9245 (!xmlStrEqual(attr->name, BAD_CAST "name")) &&
9246 (!xmlStrEqual(attr->name, BAD_CAST "final"))) {
9291 child = node->children;
9292 if (IS_SCHEMA(child, "annotation")) {
9293 type->annot = xmlSchemaParseAnnotation(ctxt, child, 1);
9294 child = child->next;
9296 if (child == NULL) {
9298 NULL, node, child, NULL,
9300 } else if (IS_SCHEMA(child, "restriction")) {
9301 xmlSchemaParseRestriction(ctxt, schema, child,
9304 child = child->next;
9305 } else if (IS_SCHEMA(child, "list")) {
9306 xmlSchemaParseList(ctxt, schema, child);
9307 child = child->next;
9308 } else if (IS_SCHEMA(child, "union")) {
9309 xmlSchemaParseUnion(ctxt, schema, child);
9310 child = child->next;
9312 if (child != NULL) {
9314 NULL, node, child, NULL,
9322 * name attribute plus target namespace;"
9327 "<simpleType> must have a <restriction> child", NULL);
9351 xmlNodePtr child = NULL;
9379 if ((!xmlStrEqual(attr->name, BAD_CAST "ref")) &&
9380 (!xmlStrEqual(attr->name, BAD_CAST "id")) &&
9381 (!xmlStrEqual(attr->name, BAD_CAST "minOccurs")) &&
9382 (!xmlStrEqual(attr->name, BAD_CAST "maxOccurs"))) {
9406 child = node->children;
9408 if (IS_SCHEMA(child, "annotation")) {
9412 item->annot = xmlSchemaParseAnnotation(ctxt, child, 1);
9413 child = child->next;
9415 if (child != NULL) {
9418 NULL, node, child, NULL,
9453 xmlNodePtr child = NULL;
9455 const xmlChar *name;
9460 attr = xmlSchemaGetPropNode(node, "name");
9465 "name", NULL);
9468 xmlSchemaGetBuiltInType(XML_SCHEMAS_NCNAME), &name) != 0) {
9471 item = xmlSchemaAddModelGroupDefinition(ctxt, schema, name,
9481 if ((!xmlStrEqual(attr->name, BAD_CAST "name")) &&
9482 (!xmlStrEqual(attr->name, BAD_CAST "id"))) {
9496 child = node->children;
9497 if (IS_SCHEMA(child, "annotation")) {
9498 item->annot = xmlSchemaParseAnnotation(ctxt, child, 1);
9499 child = child->next;
9501 if (IS_SCHEMA(child, "all")) {
9502 item->children = xmlSchemaParseModelGroup(ctxt, schema, child,
9504 child = child->next;
9505 } else if (IS_SCHEMA(child, "choice")) {
9506 item->children = xmlSchemaParseModelGroup(ctxt, schema, child,
9508 child = child->next;
9509 } else if (IS_SCHEMA(child, "sequence")) {
9510 item->children = xmlSchemaParseModelGroup(ctxt, schema, child,
9512 child = child->next;
9517 if (child != NULL) {
9520 NULL, node, child, NULL,
9749 xmlNodePtr child;
9757 child = nodes;
9758 while ((IS_SCHEMA(child, "include")) ||
9759 (IS_SCHEMA(child, "import")) ||
9760 (IS_SCHEMA(child, "redefine")) ||
9761 (IS_SCHEMA(child, "annotation"))) {
9762 if (IS_SCHEMA(child, "annotation")) {
9763 annot = xmlSchemaParseAnnotation(ctxt, child, 1);
9768 } else if (IS_SCHEMA(child, "import")) {
9770 res = xmlSchemaParseImport(ctxt, schema, child);
9775 } else if (IS_SCHEMA(child, "include")) {
9777 res = xmlSchemaParseInclude(ctxt, schema, child);
9782 } else if (IS_SCHEMA(child, "redefine")) {
9784 res = xmlSchemaParseRedefine(ctxt, schema, child);
9790 child = child->next;
9796 while (child != NULL) {
9797 if (IS_SCHEMA(child, "complexType")) {
9798 xmlSchemaParseComplexType(ctxt, schema, child, 1);
9799 child = child->next;
9800 } else if (IS_SCHEMA(child, "simpleType")) {
9801 xmlSchemaParseSimpleType(ctxt, schema, child, 1);
9802 child = child->next;
9803 } else if (IS_SCHEMA(child, "element")) {
9804 xmlSchemaParseElement(ctxt, schema, child, NULL, 1);
9805 child = child->next;
9806 } else if (IS_SCHEMA(child, "attribute")) {
9807 xmlSchemaParseGlobalAttribute(ctxt, schema, child);
9808 child = child->next;
9809 } else if (IS_SCHEMA(child, "attributeGroup")) {
9810 xmlSchemaParseAttributeGroupDefinition(ctxt, schema, child);
9811 child = child->next;
9812 } else if (IS_SCHEMA(child, "group")) {
9813 xmlSchemaParseModelGroupDefinition(ctxt, schema, child);
9814 child = child->next;
9815 } else if (IS_SCHEMA(child, "notation")) {
9816 xmlSchemaParseNotation(ctxt, schema, child);
9817 child = child->next;
9821 NULL, child->parent, child,
9825 child = child->next;
9827 while (IS_SCHEMA(child, "annotation")) {
9831 annot = xmlSchemaParseAnnotation(ctxt, child, 1);
9836 child = child->next;
10415 * 3 Based on the namespace name, identify an existing schema document,
10418 * 5 Attempt to resolve the namespace name to locate such a resource.
10709 xmlNodePtr child;
10725 if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
10726 (!xmlStrEqual(attr->name, BAD_CAST "namespace")) &&
10727 (!xmlStrEqual(attr->name, BAD_CAST "schemaLocation"))) {
10764 child = node->children;
10765 if (IS_SCHEMA(child, "annotation")) {
10770 child = child->next;
10772 if (child != NULL) {
10775 NULL, node, child, NULL,
10873 if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
10874 (!xmlStrEqual(attr->name, BAD_CAST "schemaLocation"))) {
10954 xmlNodePtr child = NULL;
11093 child = node->children;
11103 while (IS_SCHEMA(child, "annotation") ||
11104 IS_SCHEMA(child, "simpleType") ||
11105 IS_SCHEMA(child, "complexType") ||
11106 IS_SCHEMA(child, "group") ||
11107 IS_SCHEMA(child, "attributeGroup")) {
11108 if (IS_SCHEMA(child, "annotation")) {
11112 } else if (IS_SCHEMA(child, "simpleType")) {
11113 xmlSchemaParseSimpleType(pctxt, schema, child, 1);
11114 } else if (IS_SCHEMA(child, "complexType")) {
11115 xmlSchemaParseComplexType(pctxt, schema, child, 1);
11117 } else if (IS_SCHEMA(child, "group")) {
11120 schema, child);
11121 } else if (IS_SCHEMA(child, "attributeGroup")) {
11124 child);
11126 child = child->next;
11131 if (IS_SCHEMA(child, "annotation")) {
11135 child = child->next;
11138 if (child != NULL) {
11142 NULL, node, child, NULL,
11146 NULL, node, child, NULL,
11217 xmlNodePtr child = NULL;
11254 if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
11255 (!xmlStrEqual(attr->name, BAD_CAST "maxOccurs")) &&
11256 (!xmlStrEqual(attr->name, BAD_CAST "minOccurs"))) {
11273 if (!xmlStrEqual(attr->name, BAD_CAST "id")) {
11292 child = node->children;
11293 if (IS_SCHEMA(child, "annotation")) {
11294 item->annot = xmlSchemaParseAnnotation(ctxt, child, 1);
11295 child = child->next;
11300 while (IS_SCHEMA(child, "element")) {
11302 schema, child, &isElemRef, 0);
11314 NULL, child,
11323 NULL, child,
11335 child = child->next;
11337 if (child != NULL) {
11340 NULL, node, child, NULL,
11347 while ((IS_SCHEMA(child, "element")) ||
11348 (IS_SCHEMA(child, "group")) ||
11349 (IS_SCHEMA(child, "any")) ||
11350 (IS_SCHEMA(child, "choice")) ||
11351 (IS_SCHEMA(child, "sequence"))) {
11353 if (IS_SCHEMA(child, "element")) {
11355 xmlSchemaParseElement(ctxt, schema, child, &isElemRef, 0);
11358 } else if (IS_SCHEMA(child, "group")) {
11360 xmlSchemaParseModelGroupDefRef(ctxt, schema, child);
11380 * its own name attribute plus target namespace, then
11388 XML_SCHEMAP_SRC_REDEFINE, child, NULL,
11409 XML_SCHEMAP_SRC_REDEFINE, child, NULL,
11425 } else if (IS_SCHEMA(child, "any")) {
11427 xmlSchemaParseAny(ctxt, schema, child);
11428 } else if (IS_SCHEMA(child, "choice")) {
11429 part = xmlSchemaParseModelGroup(ctxt, schema, child,
11431 } else if (IS_SCHEMA(child, "sequence")) {
11432 part = xmlSchemaParseModelGroup(ctxt, schema, child,
11442 child = child->next;
11444 if (child != NULL) {
11447 NULL, node, child, NULL,
11481 xmlNodePtr child = NULL;
11496 if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
11497 (!xmlStrEqual(attr->name, BAD_CAST "base"))) {
11537 } else if ((! xmlStrEqual(type->base, type->name)) ||
11546 * of its own name attribute plus target namespace;"
11554 type->name), NULL);
11566 child = node->children;
11567 if (IS_SCHEMA(child, "annotation")) {
11572 xmlSchemaParseAnnotation(ctxt, child, 1));
11573 child = child->next;
11579 if (IS_SCHEMA(child, "simpleType")) {
11583 * Either the base [attribute] or the simpleType [child] of the
11588 NULL, node, child,
11589 "The attribute 'base' and the <simpleType> child are "
11593 xmlSchemaParseSimpleType(ctxt, schema, child, 0);
11595 child = child->next;
11599 NULL, node, child,
11600 "Either the attribute 'base' or a <simpleType> child "
11610 if (IS_SCHEMA(child, "all")) {
11612 xmlSchemaParseModelGroup(ctxt, schema, child,
11614 child = child->next;
11615 } else if (IS_SCHEMA(child, "choice")) {
11618 schema, child, XML_SCHEMA_TYPE_CHOICE, 1);
11619 child = child->next;
11620 } else if (IS_SCHEMA(child, "sequence")) {
11622 xmlSchemaParseModelGroup(ctxt, schema, child,
11624 child = child->next;
11628 } else if (IS_SCHEMA(child, "group")) {
11630 xmlSchemaParseModelGroupDefRef(ctxt, schema, child);
11635 child = child->next;
11644 if (IS_SCHEMA(child, "simpleType")) {
11650 xmlSchemaParseSimpleType(ctxt, schema, child, 0);
11653 child = child->next;
11673 while ((IS_SCHEMA(child, "minInclusive")) ||
11674 (IS_SCHEMA(child, "minExclusive")) ||
11675 (IS_SCHEMA(child, "maxInclusive")) ||
11676 (IS_SCHEMA(child, "maxExclusive")) ||
11677 (IS_SCHEMA(child, "totalDigits")) ||
11678 (IS_SCHEMA(child, "fractionDigits")) ||
11679 (IS_SCHEMA(child, "pattern")) ||
11680 (IS_SCHEMA(child, "enumeration")) ||
11681 (IS_SCHEMA(child, "whiteSpace")) ||
11682 (IS_SCHEMA(child, "length")) ||
11683 (IS_SCHEMA(child, "maxLength")) ||
11684 (IS_SCHEMA(child, "minLength"))) {
11685 facet = xmlSchemaParseFacet(ctxt, schema, child);
11694 child = child->next;
11726 if (xmlSchemaParseLocalAttributes(ctxt, schema, &child,
11733 if (IS_SCHEMA(child, "anyAttribute")) {
11735 xmlSchemaParseAnyAttribute(ctxt, schema, child);
11736 child = child->next;
11739 if (child != NULL) {
11743 NULL, node, child, NULL,
11749 NULL, node, child, NULL,
11758 NULL, node, child, NULL,
11785 xmlNodePtr child = NULL;
11800 if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
11801 (!xmlStrEqual(attr->name, BAD_CAST "base"))) {
11827 child = node->children;
11828 if (IS_SCHEMA(child, "annotation")) {
11833 xmlSchemaParseAnnotation(ctxt, child, 1));
11834 child = child->next;
11842 if (IS_SCHEMA(child, "all")) {
11845 child, XML_SCHEMA_TYPE_ALL, 1);
11846 child = child->next;
11847 } else if (IS_SCHEMA(child, "choice")) {
11850 child, XML_SCHEMA_TYPE_CHOICE, 1);
11851 child = child->next;
11852 } else if (IS_SCHEMA(child, "sequence")) {
11855 child, XML_SCHEMA_TYPE_SEQUENCE, 1);
11856 child = child->next;
11857 } else if (IS_SCHEMA(child, "group")) {
11859 xmlSchemaParseModelGroupDefRef(ctxt, schema, child);
11864 child = child->next;
11867 if (child != NULL) {
11871 if (xmlSchemaParseLocalAttributes(ctxt, schema, &child,
11878 if (IS_SCHEMA(child, "anyAttribute")) {
11880 xmlSchemaParseAnyAttribute(ctxt, schema, child);
11881 child = child->next;
11884 if (child != NULL) {
11889 NULL, node, child, NULL,
11896 NULL, node, child, NULL,
11921 xmlNodePtr child = NULL;
11937 if ((!xmlStrEqual(attr->name, BAD_CAST "id"))) {
11953 child = node->children;
11954 if (IS_SCHEMA(child, "annotation")) {
11959 xmlSchemaParseAnnotation(ctxt, child, 1));
11960 child = child->next;
11962 if (child == NULL) {
11968 if (child == NULL) {
11974 if (IS_SCHEMA(child, "restriction")) {
11975 xmlSchemaParseRestriction(ctxt, schema, child,
11978 child = child->next;
11979 } else if (IS_SCHEMA(child, "extension")) {
11980 xmlSchemaParseExtension(ctxt, schema, child,
11983 child = child->next;
11985 if (child != NULL) {
11988 NULL, node, child, NULL,
12011 xmlNodePtr child = NULL;
12026 if ((!xmlStrEqual(attr->name, BAD_CAST "id")) &&
12027 (!xmlStrEqual(attr->name, BAD_CAST "mixed")))
12048 child = node->children;
12049 if (IS_SCHEMA(child, "annotation")) {
12054 xmlSchemaParseAnnotation(ctxt, child, 1));
12055 child = child->next;
12057 if (child == NULL) {
12063 if (child == NULL) {
12069 if (IS_SCHEMA(child, "restriction")) {
12070 xmlSchemaParseRestriction(ctxt, schema, child,
12073 child = child->next;
12074 } else if (IS_SCHEMA(child, "extension")) {
12075 xmlSchemaParseExtension(ctxt, schema, child,
12078 child = child->next;
12080 if (child != NULL) {
12083 NULL, node, child,
12105 xmlNodePtr child = NULL;
12106 const xmlChar *name = NULL;
12121 attr = xmlSchemaGetPropNode(node, "name");
12124 XML_SCHEMAP_S4S_ATTR_MISSING, NULL, node, "name", NULL);
12127 xmlSchemaGetBuiltInType(XML_SCHEMAS_NCNAME), &name) != 0) {
12149 name = type->name;
12161 name, ctxt->targetNamespace, node, 1);
12175 if (xmlStrEqual(attr->name, BAD_CAST "id")) {
12180 } else if (xmlStrEqual(attr->name, BAD_CAST "mixed")) {
12191 if (xmlStrEqual(attr->name, BAD_CAST "name")) {
12193 } else if (xmlStrEqual(attr->name, BAD_CAST "abstract")) {
12200 } else if (xmlStrEqual(attr->name, BAD_CAST "final")) {
12220 } else if (xmlStrEqual(attr->name, BAD_CAST "block")) {
12273 child = node->children;
12274 if (IS_SCHEMA(child, "annotation")) {
12275 type->annot = xmlSchemaParseAnnotation(ctxt, child, 1);
12276 child = child->next;
12279 if (IS_SCHEMA(child, "simpleContent")) {
12288 xmlSchemaParseSimpleContent(ctxt, schema, child,
12290 child = child->next;
12291 } else if (IS_SCHEMA(child, "complexContent")) {
12296 xmlSchemaParseComplexContent(ctxt, schema, child,
12298 child = child->next;
12314 if (IS_SCHEMA(child, "all")) {
12316 xmlSchemaParseModelGroup(ctxt, schema, child,
12318 child = child->next;
12319 } else if (IS_SCHEMA(child, "choice")) {
12321 xmlSchemaParseModelGroup(ctxt, schema, child,
12323 child = child->next;
12324 } else if (IS_SCHEMA(child, "sequence")) {
12326 xmlSchemaParseModelGroup(ctxt, schema, child,
12328 child = child->next;
12329 } else if (IS_SCHEMA(child, "group")) {
12331 xmlSchemaParseModelGroupDefRef(ctxt, schema, child);
12336 child = child->next;
12341 if (xmlSchemaParseLocalAttributes(ctxt, schema, &child,
12348 if (IS_SCHEMA(child, "anyAttribute")) {
12349 type->attributeWildcard = xmlSchemaParseAnyAttribute(ctxt, schema, child);
12350 child = child->next;
12353 if (child != NULL) {
12356 NULL, node, child,
12368 "grand-child", NULL);
12575 "available.\n", elemDecl->name, NULL);
12587 elemDecl->name, elemDecl->targetNamespace, elemDecl);
12594 member->name, member->targetNamespace, member);
12603 elemDecl->name, elemDecl->targetNamespace, elemDecl), end);
12619 * member->name, member->targetNamespace,
12623 member->name, member->targetNamespace, member);
12640 elemDecl->name, elemDecl->targetNamespace, elemDecl),
12650 member->name, member->targetNamespace, member),
12692 elemDecl->name, elemDecl->targetNamespace, elemDecl);
12698 elemDecl->name, elemDecl->targetNamespace, elemDecl);
12700 elemDecl->name, elemDecl->targetNamespace, elemDecl);
12711 elemDecl->name, elemDecl->targetNamespace, elemDecl);
12728 * @name: the complex type's name whose content is being built
13088 elemDecl->name,
13096 elemDecl->name,
13137 * @name: the element name
13153 "Building content model for %s\n", name);
13159 "Cannot create automata for complex type %s\n", type->name);
13183 "Content model of %s:\n", type->name);
13302 const xmlChar *name, *nsName;
13304 name = ((xmlSchemaQNameRefPtr) link->type)->name;
13307 memberType = xmlSchemaGetType(ctxt->schema, name, nsName);
13311 name, nsName, XML_SCHEMA_TYPE_SIMPLE, NULL);
13663 * name and ���absent���, then any must be the value.
13676 * 5.2 If the set S includes the negated namespace name
13693 * namespace name, then the union is not expressible.
13703 * name or ���absent���, then whichever of O1 or O2 is a pair of not
13704 * and a namespace name must be the value.
13839 * name or ���absent���) and the other is a set of (namespace names or
13939 * 6 If the one is a negation of a namespace name and the other
13941 * of a namespace name must be the value.
13972 * 2.1 sub must be a pair of not and a namespace name or ���absent���.
14010 * 3.2.2 super must be a pair of not and a namespace name or
14138 * {attribute declaration} has the same {name} and {target
14277 * use with an {attribute declaration} with the same {name} and
14485 if ((WXS_ATTRUSE_DECL_NAME(use) == pro->name) &&
14933 * @name: the name
15015 * @name: the name
15096 ref->itemType, ref->name, ref->targetNamespace);
15100 "ref", ref->name, ref->targetNamespace, ref->itemType,
15932 * {attribute uses} must not have identical {name}s and
16169 * {name}, {target namespace} and {type definition} as its attribute
16630 base->name));
16657 base->name));
16675 type->name);
16691 * Attention: at this point the <simpleType> child is in
16709 base->name));
16728 base->name));
16737 base->name));
16814 * SPEC (1) "The declarations' {name}s and {target namespace}s are
16818 ((! xmlStrEqual(elemR->name, elemB->name)) ||
18003 "Type of %s : %s:%d :", name,
18007 xmlGenericError(xmlGenericErrorContext, "Type of %s :", name);
18110 * type->name, NULL);
18269 * restricts the <restriction>'s <simpleType> child.
18281 "is missing a <simpleType> child, but was not catched "
18282 "by xmlSchemaCheckSRCCT()", type->name);
18302 type->name);
18321 "derivation case", type->name);
18620 * @name: the optional name of the type
18631 const xmlChar * name ATTRIBUTE_UNUSED)
18728 base->targetNamespace, base->name));
18840 const xmlChar *name = typeDecl->name;
18858 res = xmlSchemaCheckFacet(facet, typeDecl, pctxt, name);
18933 * @name: the name
18969 item->targetNamespace, item->name));
19083 * @name: the name
19285 if ((prohib->name == WXS_ATTRUSE_DECL_NAME(use)) &&
19297 prohib->targetNamespace, prohib->name),
19375 * {attribute declaration}s both of whose {name}s match and whose
19444 * @name: the attribute name
19457 ref->name,
19463 "ref", ref->name, ref->targetNamespace,
19475 * @name: the name of the attribute
19575 * @name: the name of the attribute
19750 * @name: the name of the attribute
19915 * the same {name} and {target namespace}, then
19919 if (xmlStrEqual(WXS_PARTICLE_TERM_AS_ELEM(cur)->name,
19920 WXS_PARTICLE_TERM_AS_ELEM(searchParticle)->name) &&
19937 WXS_PARTICLE_TERM_AS_ELEM(cur)->name));
19985 * @name: the name of the attribute
20042 ref->itemType, ref->name, ref->targetNamespace);
20045 NULL, WXS_ITEM_NODE(particle), "ref", ref->name,
20181 ref->name, ref->targetNamespace);
20186 "ref", ref->name, ref->targetNamespace,
20355 * @name: the attribute name
20367 if (idc->ref->name != NULL) {
20369 xmlSchemaGetIDC(pctxt->schema, idc->ref->name,
20379 "refer", idc->ref->name,
20413 refer->name),
20427 if (xmlSchemaGetAttributeDecl(pctxt->schema, prohib->name,
20433 "ref", prohib->name, prohib->targetNamespace,
20484 * (6.2.1) "The ���actual value��� of its own name attribute plus
20487 * (7.2.1) "The ���actual value��� of its own name attribute plus
20645 * Since the spec wants the {name} of the redefined
20648 (WXS_TYPE_CAST redef->target)->name = NULL;
20707 const xmlChar *name;
20742 name = (WXS_TYPE_CAST item)->name;
20746 name = (WXS_ELEM_CAST item)->name;
20750 name = (WXS_ATTR_CAST item)->name;
20756 name = (WXS_MODEL_GROUPDEF_CAST item)->name;
20762 name = (WXS_ATTR_GROUP_CAST item)->name;
20768 name = (WXS_IDC_CAST item)->name;
20772 name = ((xmlSchemaNotationPtr) item)->name;
20788 err = xmlHashAddEntry(*table, name, item);
21582 * @nsName: the namespace name of the new schema
21759 * Get the namespace name.
21786 * I.e. the namespace name *and* the document's URI.
21791 "name and the document's URI", NULL, NULL, NULL);
22488 sto->matcher->aidc->def->name, sto->sel->xpath);
22491 sto->matcher->aidc->def->name, sto->sel->xpath);
23480 * both, the parent node-table entry and child entry are discarded from the
23540 * Compare every node-table entry of the child node,
23662 * the child node to the node table of the parent node.
24503 * the string must be a ���declared entity name���.
24509 * entity name���.
24979 (*localType)->name),
25132 * name is identical to http://www.w3.org/2001/XMLSchema-instance and
25133 * whose local name is one of type, nil, schemaLocation or
25217 * item's [attributes] excepting those whose [namespace name] is
25219 * [local name] is one of type, nil, schemaLocation or
25245 if (iattr->localName[0] != attrDecl->name[0])
25247 if (!xmlStrEqual(iattr->localName, attrDecl->name))
25255 * use with an {attribute declaration} whose {name} matches
25256 * the attribute information item's [local name] and whose
25258 * item's [namespace name] (where an ���absent��� {target namespace}
25259 * is taken to be identical to a [namespace name] with no value),
25318 tmpiattr->localName = attrDecl->name;
25347 * "... its [namespace name] must be ���valid��� with respect to
25388 * [local name] and [namespace name] resolve (as
25750 iattr->decl->name),
25946 const xmlChar * name ATTRIBUTE_UNUSED,
26017 * we will not validate child elements of broken parents.
26096 "Missing child element(s)",
26885 "the child element was valid but neither the "
27270 const xmlChar * name ATTRIBUTE_UNUSED)
27333 * Store prefix and namespace name.
27500 * @filename: the file name
27892 ielem->localName = node->name;
27916 attr->name, nsName, 0,
28222 internalSubsetSplit(void *ctx, const xmlChar *name,
28228 ctxt->user_sax->internalSubset(ctxt->user_data, name, ExternalID,
28263 externalSubsetSplit(void *ctx, const xmlChar *name,
28269 ctxt->user_sax->externalSubset(ctxt->user_data, name, ExternalID,
28285 getEntitySplit(void *ctx, const xmlChar *name)
28290 return(ctxt->user_sax->getEntity(ctxt->user_data, name));
28295 getParameterEntitySplit(void *ctx, const xmlChar *name)
28300 return(ctxt->user_sax->getParameterEntity(ctxt->user_data, name));
28306 entityDeclSplit(void *ctx, const xmlChar *name, int type,
28312 ctxt->user_sax->entityDecl(ctxt->user_data, name, type, publicId,
28318 const xmlChar * name, int type, int def,
28324 ctxt->user_sax->attributeDecl(ctxt->user_data, elem, name, type,
28332 elementDeclSplit(void *ctx, const xmlChar *name, int type,
28338 ctxt->user_sax->elementDecl(ctxt->user_data, name, type, content);
28342 notationDeclSplit(void *ctx, const xmlChar *name,
28348 ctxt->user_sax->notationDecl(ctxt->user_data, name, publicId,
28353 unparsedEntityDeclSplit(void *ctx, const xmlChar *name,
28360 ctxt->user_sax->unparsedEntityDecl(ctxt->user_data, name, publicId,
28482 referenceSplit(void *ctx, const xmlChar *name)
28489 ctxt->user_sax->reference(ctxt->user_data, name);
28491 xmlSchemaSAXHandleReference(ctxt->user_data, name);