Lines Matching full:base
470 * The abstract base type for schema components.
481 * The abstract base type for annotated schema components.
494 * The abstract base type for tree-like structured schema components.
511 * The abstract base type for tree-like structured schema components.
1794 * Use the whitespace type of the base type.
2990 * @baseType: the base type of type
4455 if (type->base != NULL) {
4456 fprintf(output, " base type: '%s'", type->base);
8850 * SPEC (Base type) (2) "If the <list> or <union> alternative is chosen,
8885 type->base = cur;
9018 * SPEC (Base type) (2) "If the <list> or <union> alternative is chosen,
9046 * REVAMP TODO: Use the "base" and "baseNs" fields, since we will remove
9050 node, "itemType", &(type->baseNs), &(type->base));
9066 if (type->base != NULL) {
9076 } else if (type->base == NULL) {
9088 if ((type->base == NULL) &&
9302 * base [attribute] must be the same as the ?actual value? of its own
10228 xmlChar *base, *URI;
10231 base = xmlNodeGetBase(ctxtNode->doc, ctxtNode);
10232 if (base == NULL) {
10235 URI = xmlBuildURI(location, base);
10236 xmlFree(base);
10856 * from the base.
10863 xmlChar *base = NULL;
10870 base = xmlNodeGetBase(node->doc, node);
10871 if (base == NULL) {
10874 uri = xmlBuildURI(*schemaLocation, base);
10875 xmlFree(base);
11465 (!xmlStrEqual(attr->name, BAD_CAST "base"))) {
11483 * Extract the base type. The "base" attribute is mandatory if inside
11489 * the ?actual value? of the base [attribute]"
11491 if (xmlSchemaPValAttrQName(ctxt, schema, NULL, node, "base",
11492 &(type->baseNs), &(type->base)) == 0)
11494 if ((type->base == NULL) && (type->type == XML_SCHEMA_TYPE_COMPLEX)) {
11497 NULL, node, "base", NULL);
11501 if (type->base == NULL) {
11504 NULL, node, "base", NULL);
11505 } else if ((! xmlStrEqual(type->base, type->name)) ||
11513 * whose base [attribute] must be the same as the ?actual value?
11518 "value '%s' of the 'base' attribute does not match the "
11520 xmlSchemaFormatQName(&str1, type->baseNs, type->base),
11526 type->base = NULL;
11548 if (type->base != NULL) {
11550 * src-restriction-base-or-simpleType
11551 * Either the base [attribute] or the simpleType [child] of the
11557 "The attribute 'base' and the <simpleType> child are "
11564 } else if (type->base == NULL) {
11568 "Either the attribute 'base' or a <simpleType> child "
11769 (!xmlStrEqual(attr->name, BAD_CAST "base"))) {
11783 * Attribute "base" - mandatory.
11786 "base", &(type->baseNs), &(type->base)) == 0) &&
11787 (type->base == NULL)) {
11790 NULL, node, "base", NULL);
12922 xmlAutomataStatePtr hop, base;
12935 base = xmlAutomataNewState(pctxt->am);
12939 pctxt->state = base;
12945 xmlAutomataNewEpsilon(pctxt->am, start, base);
12946 xmlAutomataNewCountedTrans(pctxt->am, hop, base, counter);
13998 ((a) == XML_SCHEMA_ACTION_DERIVE) ? (const xmlChar *) "base" : (const xmlChar *) "redefined"
14041 * uses} of the {base type definition} (call this B) whose
14151 * (2.2) "otherwise the {base type definition} must have an
14179 * (3) "For each attribute use in the {attribute uses} of the {base type
14232 * (4.1) "The {base type definition} must also have one."
14251 * {namespace constraint} must be a subset of the {base type
14267 /* 4.3 Unless the {base type definition} is the ?ur-type
14270 * stronger than the {base type definition}'s {attribute
14324 "no base type");
14365 * Inherit the attribute uses of the base type.
14454 * (3.2.2.1) "If the ?base wildcard? is non-?absent?, then
14459 * Union the complete wildcard with the base wildcard.
14465 * and of the ?base wildcard?, as defined in Attribute
14474 * then the ?base wildcard?."
14480 * (3.2.2.2) "otherwise (the ?base wildcard? is ?absent?) the
14692 * @baseType: the base type definition
14717 * of its own {base type definition};
14738 * 2.2.1 D's ?base type definition? is B.
14743 * 2.2.2 D's ?base type definition? is not the ?ur-type definition?
14931 * Resolve the base type.
14935 typeDef->base, typeDef->baseNs);
14940 "base", typeDef->base, typeDef->baseNs,
14956 if ((typeDef->subtypes == NULL) && (typeDef->base != NULL)) {
14959 typeDef->base, typeDef->baseNs);
14968 "itemType", typeDef->base, typeDef->baseNs,
15066 /* Base type: If the datatype has been ?derived? by ?restriction?
15078 "No base type existent", NULL);
15086 "The base type '%s' is not a simple type",
15098 "the simple ur-type definition as base type, not '%s'",
15117 * 3 The {final} of the {base type definition} must not contain restriction.
15124 "The 'final' of its base type '%s' must not contain "
15135 * ur-type definition? by repeatedly following the {base type definition}.
15171 * 1.1 The {base type definition} must be an atomic simple
15178 "The base type '%s' is not an atomic simple type",
15183 /* 1.2 The {final} of the {base type definition} must not contain
15192 "The final of its base type '%s' must not contain 'restriction'",
15228 * of the {base type definition} (call this BF),then the DF's {value}
15331 * 2.3.2.1 The {base type definition} must have a {variety} of list.
15337 "The base type '%s' must be a list type",
15343 * 2.3.2.2 The {final} of the {base type definition} must not
15351 "The 'final' of the base type '%s' must not contain 'restriction'",
15358 * from the {base type definition}'s {item type definition} given
15367 "failed to eval the item type of a base type");
15378 "the item type '%s' of the base type '%s'",
15459 * 3.3.1 If the {base type definition} is the ?simple ur-type
15493 * 3.3.2.1 The {base type definition} must have a {variety} of union.
15500 "The base type '%s' is not a union type",
15506 * 3.3.2.2 The {final} of the {base type definition} must not contain restriction.
15513 "The 'final' of its base type '%s' must not contain 'restriction'",
15520 * derived from the corresponding type definitions in the {base
15529 * member types and inherits the member types of the base type;
15535 * types of it's base type. This check seems not necessary with
15544 "different number of member types in base");
15549 "different number of member types in base");
15560 "type %s of the base type %s",
15633 * either it must have a base [attribute] or a <simpleType> among its
15798 * SPEC (2) "If the {base type definition} is a simple type definition,
15804 "If the base type is a simple type, the derivation method must be "
15811 * definition by repeatedly following the {base type definition}."
15918 * @baseType: the base complex type definition
15940 * B, for base) given a subset of {extension, restriction}
15958 * SPEC (2.2) "B must be D's {base
15963 * SPEC (2.3.1) "D's {base type definition} must not be the ?ur-type
15971 * SPEC (2.3.2.1) "If D's {base type definition} is complex, then it
15979 * SPEC (2.3.2.2) "If D's {base type definition} is simple, then it
15991 * @baseType: the base type definition
16033 xmlSchemaTypePtr base = type->baseType;
16039 * SPEC (1) "If the {base type definition} is a complex type definition,
16042 if (WXS_IS_COMPLEX(base)) {
16044 * SPEC (1.1) "The {final} of the {base type definition} must not
16047 if (base->flags & XML_SCHEMAS_TYPE_FINAL_EXTENSION) {
16051 "The 'final' of the base type definition "
16068 * use in the {attribute uses} of the {base type definition}, there
16074 if (base->attrUses != NULL) {
16078 for (i = 0; i < (WXS_LIST_CAST base->attrUses)->nbItems; i ++) {
16079 buse = (WXS_LIST_CAST base->attrUses)->items[i];
16108 "for its {base type}'s %s in its {attribute uses}",
16118 * definition must also have one, and the base type definition's
16128 if (base->attributeWildcard != NULL) {
16135 "The base %s has an attribute wildcard, "
16137 xmlSchemaGetComponentDesignation(&str, base));
16141 base->attributeWildcard, type->attributeWildcard))
16149 "superset of the one in the base %s",
16150 xmlSchemaGetComponentDesignation(&str, base));
16159 (type->contentTypeDef == base->contentTypeDef)) {
16161 * SPEC (1.4.1) "The {content type} of the {base type definition}
16167 (base->contentType == XML_SCHEMA_CONTENT_EMPTY) ) {
16169 * SPEC (1.4.2) "The {content type} of both the {base type
16192 if (base->contentType == XML_SCHEMA_CONTENT_EMPTY) {
16194 * SPEC (1.4.3.2.1) "The {content type} of the {base type
16202 if ((type->contentType != base->contentType) ||
16212 "The content type of both, the type and its base "
16219 * of the {base type definition}'s particle, as defined
16235 * SPEC (2) "If the {base type definition} is a simple type definition,
16238 if (type->contentTypeDef != base) {
16246 "The content type must be the simple base type", NULL);
16249 if (base->flags & XML_SCHEMAS_TYPE_FINAL_EXTENSION) {
16251 * SPEC (2.2) "The {final} of the {base type definition} must not
16258 "The 'final' of the base type definition "
16290 xmlSchemaTypePtr base;
16296 base = type->baseType;
16297 if (! WXS_IS_COMPLEX(base)) {
16301 "The base type must be a complex type", NULL, NULL);
16304 if (base->flags & XML_SCHEMAS_TYPE_FINAL_RESTRICTION) {
16306 * SPEC (1) "The {base type definition} must be a complex type
16312 "The 'final' of the base type definition "
16324 WXS_BASIC_CAST type, WXS_BASIC_CAST base,
16325 type->attrUses, base->attrUses,
16327 base->attributeWildcard) == -1)
16334 if (base->builtInType == XML_SCHEMAS_ANYTYPE) {
16336 * SPEC (5.1) "The {base type definition} must be the
16348 if ((base->contentType == XML_SCHEMA_CONTENT_SIMPLE) ||
16349 (base->contentType == XML_SCHEMA_CONTENT_BASIC))
16353 * SPEC (5.2.2.1) "The {content type} of the {base type
16359 * derived from the base type.
16363 type->contentTypeDef, base->contentTypeDef, 0);
16373 "base type's {content type} %s",
16377 base->contentTypeDef));
16382 } else if ((base->contentType == XML_SCHEMA_CONTENT_MIXED) &&
16384 (xmlSchemaParticlePtr) base->subtypes))) {
16386 * SPEC (5.2.2.2) "The {base type definition} must be mixed
16395 "The content type of the base type must be either "
16404 if (base->contentType == XML_SCHEMA_CONTENT_EMPTY) {
16406 * SPEC (5.3.2.1) "The {content type} of the {base type
16410 } else if (((base->contentType == XML_SCHEMA_CONTENT_ELEMENTS) ||
16411 (base->contentType == XML_SCHEMA_CONTENT_MIXED)) &&
16413 (xmlSchemaParticlePtr) base->subtypes)) {
16415 * SPEC (5.3.2.2) "The {content type} of the {base type
16424 "The content type of the base type must be either "
16435 if (WXS_HAS_MIXED_CONTENT(type) && (! WXS_HAS_MIXED_CONTENT(base))) {
16438 * definition itself and of the {base type definition} must be
16445 "base type must also be 'mixed'", NULL);
16451 * type} of the {base type definition} as defined in Particle Valid
16460 "The type is not a valid restriction of its base type", NULL);
16510 xmlSchemaTypePtr base;
16517 base = type->baseType;
16521 * ?resolved? to by the ?actual value? of the base [attribute]
16524 if (! WXS_IS_COMPLEX(base)) {
16529 "If using <complexContent>, the base type is expected to be "
16530 "a complex type. The base type '%s' is a simple type",
16531 xmlSchemaFormatQName(&str, base->targetNamespace,
16532 base->name));
16542 * base [attribute] must be one of the following:
16544 if (WXS_IS_SIMPLE(base)) {
16555 "If using <simpleContent> and <restriction>, the base "
16556 "type must be a complex type. The base type '%s' is "
16558 xmlSchemaFormatQName(&str, base->targetNamespace,
16559 base->name));
16564 /* Base type is a complex type. */
16565 if ((base->contentType == XML_SCHEMA_CONTENT_SIMPLE) ||
16566 (base->contentType == XML_SCHEMA_CONTENT_BASIC)) {
16572 if (base->contentTypeDef == NULL) {
16576 "'%s', base type has no content type",
16580 } else if ((base->contentType == XML_SCHEMA_CONTENT_MIXED) &&
16589 (xmlSchemaParticlePtr) base->subtypes)) {
16609 "the base type '%s' is a complex type",
16610 xmlSchemaFormatQName(&str, base->targetNamespace,
16611 base->name));
16626 "base type must be a simple type or a complex type with "
16627 "mixed content and particle emptiable. The base type "
16629 xmlSchemaFormatQName(&str, base->targetNamespace,
16630 base->name));
16636 "base type must be a simple type. The base type '%s' "
16638 xmlSchemaFormatQName(&str, base->targetNamespace,
16639 base->name));
16691 * @b: the base element declaration particle
16798 * @b: the base wildcard particle
16842 * @b: the base model group particle
16868 * @b: the base wildcard particle
16938 basePart = WXS_TYPE_PARTICLE(base);
16958 * @b: the base wildcard particle
17012 * @b: the base <all> or <sequence> model group particle
17072 "The base type's facet is 'fixed', thus the value must not " \
17100 msg = xmlStrcat(msg, BAD_CAST "' of the base type");
17123 xmlSchemaTypePtr base = type->baseType;
17131 bfmaxlen = NULL, bfminlen = NULL, /* facets of the base type */
17160 if ((type->facetSet == NULL) && (base->facetSet == NULL))
17193 for (cur = base->facetSet; cur != NULL; cur = cur->next) {
17260 * minLength >= BASE minLength
17274 * maxLength <= BASE minLength
17329 /* maxInclusive <= BASE maxInclusive */
17340 /* maxInclusive < BASE maxExclusive */
17349 /* maxInclusive >= BASE minInclusive */
17358 /* maxInclusive > BASE minExclusive */
17383 /* maxExclusive <= BASE maxExclusive */
17395 /* maxExclusive <= BASE maxInclusive */
17404 /* maxExclusive > BASE minInclusive */
17413 /* maxExclusive > BASE minExclusive */
17438 /* minExclusive >= BASE minExclusive */
17450 /* minExclusive <= BASE maxInclusive */
17459 /* minExclusive >= BASE minInclusive */
17468 /* minExclusive < BASE maxExclusive */
17493 /* minInclusive >= BASE minInclusive */
17505 /* minInclusive <= BASE maxInclusive */
17514 /* minInclusive > BASE minExclusive */
17522 /* minInclusive < BASE maxExclusive */
17533 * totalDigits <= BASE totalDigits
17548 * fractionDigits <= BASE fractionDigits
17578 * for validation, plus we need to use the base type of those
17583 * happed during validation by walking the base axis
17586 for (cur = base->facetSet; cur != NULL; cur = cur->next) {
17613 "the base type")
17629 * If no duplicate was found: add the base types's facet
17867 "type has no base-type assigned");
17876 * {variety} of the {base type definition}.
17889 * NOTE that we won't assign the memberTypes of the base,
18063 * Fixup the base type.
18069 * Skip fixup if the base type is invalid.
18075 * This basically checks if the base type can be derived.
18095 * SPEC (1) If <restriction> + base type is <complexType>,
18112 * is the {content type} of the ... base type."
18169 * SPEC (2) If <restriction> + base is a mixed <complexType> with
18189 * SPEC (3) If <extension> + base is <complexType> with
18202 "complex type '%s': the <extension>ed base type is "
18210 * SPEC (4) <extension> + base is <simpleType>
18312 * {content type} of the [...] base ..."
18318 * This is the case when the base type has a simple
18402 * the ... base ..."
18403 * Create a duplicate of the base type's particle
18426 * --> base-model,
18435 * Just add the base types's content type.
18451 * - inherit attribute uses of the base type
18558 xmlSchemaTypePtr base;
18563 * ?value space? of {base type definition}.
18567 * ?value space? of the ?base type?.
18576 * already* the base type.
18579 base = typeDecl->baseType;
18580 if (base == NULL) {
18582 "a type user derived type has no base type");
18586 base = typeDecl;
18604 ACTXT_CAST pctxt, facet->node, base,
18614 "facet '%s' against the base type",
18627 "against the base type '%s'",
18630 base->targetNamespace, base->name));
20438 * base type of the redefining type.
20579 * (?3.4.6) (where references to the base type definition are
20780 * - the base type definition
20860 * 1. the base axis of type definitions
24076 * *base types* need to be checked as well.
24187 * of the defining type's base type. This seems to be a bug in the
24188 * XML Schema 1.0 spec. Use the whitespace type of the base type.
24237 * and ANDed if derived. Walk the base type axis.
24422 * a literal in the ?lexical space? of {base type definition}"
