The of is the union of the value spaces of all the datatypes defined here, and of all sets of lists formed from the members of the datatypes.

The of is the set of all atomic values and of all finite-length lists of zero or more atomic values.

The of is the set of all finite-length sequences of zero or more characters (as defined in ) that the Char production from . This is equivalent to the union of the lexical spaces of all and all possible datatypes.

It is whether an implementation of this specification supports the Char production from , or that from , or both. See .

The of is the union of the lexical mappings of all datatypes and all list datatypes. It will be noted that this mapping is not a function: a given may map to one value or to several values of different datatypes, and it may be indeterminate which value is to be preferred in a particular context. When the datatypes defined here are used in the context of , the xsi:type attribute defined by that specification in section xsi:type can be used to indicate which value a which is the content of an element should map to. In other contexts, other rules (such as type coercion rules) may be employed to determine which value is to be used.

When a new datatype is defined by , must not be used as the . So no constraining facets are directly applicable to .

The of is the union of the value spaces of all the datatypes defined here or supplied as primitives.

The of is the set of all finite-length sequences of zero or more characters (as defined in ) that the Char production from . This is equivalent to the union of the lexical spaces of all datatypes.

It is whether an implementation of this specification supports the Char production from , or that from , or both. See .

The of is the union of the lexical mappings of all datatypes. It will be noted that this mapping is not a function: a given may map to one value or to several values of different datatypes, and it may be indeterminate which value is to be preferred in a particular context. When the datatypes defined here are used in the context of , the xsi:type attribute defined by that specification in section xsi:type can be used to indicate which value a which is the content of an element should map to. In other contexts, other rules (such as type coercion rules) may be employed to determine which value is to be used.

When a new datatype is defined by , must not be used as the . So no constraining facets are directly applicable to .

The of is the set of finite-length sequences of zero or more characters (as defined in ) that the Char production from . A character is an atomic unit of communication; it is not further specified except to note that every character has a corresponding Universal Character Set (UCS) code point, which is an integer.

It is whether an implementation of this specification supports the Char production from , or that from , or both. See .

Equality for is identity. No order is prescribed.

The of is the set of finite-length sequences of zero or more characters (as defined in ) that the Char production from . Lexical Space stringRep Char*  (as defined in )

It is whether an implementation of this specification supports the Char production from , or that from , or both. See .

The for is , and the is ; each is a subset of the identity function.

has the of two-valued logic:  {true, false}.

's lexical space is a set of four literals: Lexical Space booleanRep true | false | 1 | 0

The for is ; the is .

decimal has a lexical representation consisting of a non-empty finite-length sequence of decimal digits (#x30–#x39) separated by a period as a decimal indicator.  An optional leading sign is allowed.  If the sign is omitted, "+" is assumed.  Leading and trailing zeroes are optional.  If the fractional part is zero, the period and following zero(es) can be omitted. For example:  -1.23, 12678967.543233, +100000.00, 210-1.23, 12678967.543233, +100000.00, 210.

The Lexical Representation decimalLexicalRep  |

The lexical space of decimal is the set of lexical representations which match the grammar given above, or (equivalently) the regular expression -?(([0-9]+(.[0-9]*)?)|(.[0-9]+)). (\+|-)?([0-9]+(\.[0-9]*)?|\.[0-9]+)

The mapping from lexical representations to values is the usual one for decimal numerals; it is given formally in .

The mapping from values to canonical representations is given formally in .

The definition of the has the effect of prohibiting certain options from the .  Specifically, for integers, the decimal point and fractional part are prohibited. For other values, the preceding optional "+" sign is prohibited.  The decimal point is required.  In all cases, leading and trailing zeroes are prohibited subject to the following:  there must be at least one digit to the right and to the left of the decimal point which may be a zero.

The mapping from values to canonical representations is given formally in .

The for decimal is defined by prohibiting certain options from the .  Specifically, the preceding optional "+" sign is prohibited.  The decimal point is required.  Leading and trailing zeroes are prohibited subject to the following:  there must be at least one digit to the right and to the left of the decimal point which may be a zero.

The mapping from values to canonical representations is given formally in .

Equality and order for are defined as follows:

Two numerical values are ordered (or equal) as their values are ordered (or equal).  (This means that two zeroes with different s are equal; negative zeroes are not ordered less than positive zeroes.)

's lexical space is the set of all decimal numerals with or without a decimal point, numerals in scientific (exponential) notation, and the character strings INF, +INF, -INF, and NaN. Lexical Space pDecimalRep  |  |  |

The production is equivalent (after whitespace is removed) to the following regular expression: (\+|-)?([0-9]+(\.[0-9]*)?|\.[0-9]+)([Ee](\+|-)?[0-9]+)?
|(\+|-)?INF|NaN

The for is . The is .

The of contains the non-zero numbers  m × 2^e , where m is an integer whose absolute value is less than 2²⁴, and e is an integer between −149 and 104, inclusive.  In addition to these values, the of also contains the following special valuesspecial values:  positiveZero, negativeZero, positiveInfinity, negativeInfinity, and notANumber.

Equality and order for are defined as follows:

Equality is identity, except that  0 = −0  (although they are not identical) and  NaN ≠ NaN  (although NaN is of course identical to itself).

0 and −0 are thus distinctequivalent for purposes of enumerations and identity constraints, but equal for purposes ofas well as for minimum and maximum values.

The of is the set of all decimal numerals with or without a decimal point, numerals in scientific (exponential) notation, and the literals INF, -INF, and NaN Lexical Space floatRep  |  |  | The production is equivalent to this regular expression (after whitespace is removed from the regular expression): (-|+)?(([0-9]+(.[0-9]*)?)|(.[0-9]+))((e|E)(-|+)?[0-9]+)?|-?INF|NaN (\+|-)?([0-9]+(\.[0-9]*)?|\.[0-9]+)([Ee](\+|-)?[0-9]+)?
|(\+|-)?INF|NaN

The datatype is designed to implement for schema processing the single-precision floating-point datatype of .  That specification does not specify specific lexical representations, but does prescribe requirements on any used.  Any that maps the just described onto the , is a function, satisfies the requirements of , and correctly handles the mapping of the literals INF, NaN, etc., to the special valuesspecial values ( literals), satisfies the conformance requirements of this specification.

Since IEEE allows some variation in rounding of values, processors conforming to this specification may exhibit some variation in their lexical mappings.

The is provided as an example of a simple algorithm that yields a conformant mapping, and that provides the most accurate rounding possible—and is thus useful for insuring inter-implementation reproducibility and inter-implementation round-tripping.  The simple rounding algorithm used in may be more efficiently implemented using the algorithms of .

The is provided as an example of a mapping that does not produce unnecessarily long canonical representations.  Other algorithms which do not yield identical results for mapping from float values to character strings are permitted by .

The of contains the non-zero numbers  m × 2^e , where m is an integer whose absolute value is less than 2⁵³, and e is an integer between −1074 and 971, inclusive.  In addition to these values, the of also contains the following special valuesspecial values:  positiveZero, negativeZero, positiveInfinity, negativeInfinity, and notANumber.

Equality and order for are defined as follows:

Equality is identity, except that  0 = −0  (although they are not identical) and  NaN ≠ NaN  (although NaN is of course identical to itself).

0 and −0 are thus distinct for purposes of enumerations and identity constraints, but equal for purposes of minimum and maximum values.0 and −0 are thus equivalent for purposes of enumerations, identity constraints, and minimum and maximum values.

The of is the set of all decimal numerals with or without a decimal point, numerals in scientific (exponential) notation, and the literals INF, -INF, and NaN Lexical Space doubleRep  |  |  | The production is equivalent to this regular expression (after whitespace is eliminated from the expression): (-|+)?(([0-9]+(.[0-9]*)?)|(.[0-9]+))((e|E)(-|+)?[0-9]+)?|-?INF|NaN (\+|-)?([0-9]+(\.[0-9]*)?|\.[0-9]+)([Ee](\+|-)?[0-9]+)? |(\+|-)?INF|NaN

The datatype is designed to implement for schema processing the double-precision floating-point datatype of .  That specification does not specify specific lexical representations, but does prescribe requirements on any used.  Any that maps the just described onto the , is a function, satisfies the requirements of , and correctly handles the mapping of the literals INF, NaN, etc., to the special valuesspecial values ( literals), satisfies the conformance requirements of this specification.

Since IEEE allows some variation in rounding of values, processors conforming to this specification may exhibit some variation in their lexical mappings.

The is provided as an example of a simple algorithm that yields a conformant mapping, and that provides the most accurate rounding possible—and is thus useful for insuring inter-implementation reproducibility and inter-implementation round-tripping.  The simple rounding algorithm used in may be more efficiently implemented using the algorithms of .

The is provided as an example of a mapping that does not produce unnecessarily long canonical representations.  Other algorithms which do not yield identical results for mapping from float values to character strings are permitted by .

Duration values can be modelled as two-property tuples. Each value consists of an integer number of months and a decimal number of seconds. The value must not be negative if the value is positive and must not be positive if the is negative. Properties of Values months seconds a value; must not be negative if is positive, and must not be positive if is negative. is partially ordered.  Equality of is defined in terms of equality of ; order for is defined in terms of the order of . Specifically, the equality or order of two values is determined by adding each in the pair to each of the following four values:

1696-09-01T00:00:00Z

The lexical representations of are more or less based on the pattern: PnYnMnDTnHnMnS

More precisely, the of is the set of character strings that satisfy as defined by the following productions: Lexical Representation Fragments duYearFrag  Y duMonthFrag  M duDayFrag  D duHourFrag  H duMinuteFrag  M duSecondFrag ( | ) S duYearMonthFrag ( ?) | duTimeFrag T (( ? ?) | ( ?) | ) duDayTimeFrag ( ?) | Lexical Representation durationLexicalRep -? P (( ?) | )

Thus, a consists of one or more of a , , , , , and/or , in order, with letters P and T (and perhaps a -) where appropriate.

The language accepted by the production is the set of strings which satisfy all of the following three regular expressions:

The expression -?P([0-9]+Y)?([0-9]+M)?([0-9]+D)?(T([0-9]+H)?([0-9]+M)?((([0-9]+(.[0-9]*)?)|(.[0-9]+))S)?)? -?P([0-9]+Y)?([0-9]+M)?([0-9]+D)?(T([0-9]+H)?([0-9]+M)?([0-9]+(\.[0-9]+)?S)?)? matches only strings in which the fields occur in the proper order.

The for is .

The canonical mapping for is .

uses the , with no properties except permitted to be absent. The property remains .

Equality and order are as prescribed in .  values are ordered by their value.

The lexical representations for are as follows: Lexical Space dateTimeLexicalRep  -  -  T (( :  : ) | ) ? Day-of-month Representations

Within a , a must not begin with the digit 3 or be 29 unless the value to which it would map would satisfy the value constraint on values (Constraint: Day-of-month Values) given above.

The production is equivalent to this regular expression once whitespace is removed. \-?([1-9][0-9][0-9][0-9]+)|(0[0-9][0-9][0-9])\-(0[1-9])|(1[0-2])\-(0[1-9])([12][0-9])|(3[01])
 T(([01][0-9])|(2[0-3]):[0-5][0-9]:([0-5][0-9])(\.[0-9]+)?)|(24:00:00(\.0+)?)
   ([+\-](0[0-9])|(1[0-4]):[0-5][0-9])? -?([1-9][0-9]{3,}|0[0-9]{3})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])T(([01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9](\.[0-9]+)?|(24:00:00(\.0+)?))(Z|(\+|-)((0[0-9]|1[0-3]):[0-5][0-9]|14:00))? -?([1-9][0-9]{3,}|0[0-9]{3}) -(0[1-9]|1[0-2]) -(0[1-9]|[12][0-9]|3[01]) T(([01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9](\.[0-9]+)?|(24:00:00(\.0+)?)) (Z|(\+|-)((0[0-9]|1[0-3]):[0-5][0-9]|14:00))? Note that neither the production nor this regular expression alone enforce the constraint on given above.

The for is . The is .

uses the , with , , and required to be absent.  remains .

Equality and order are as prescribed in .  values (points in time in an arbitrary day) are ordered taking into account their .

A calendar ( or local time) day with an early timezone begins earlier than the same calendar day with a later timezone.  Since the timezones allowed spread over 28 hours, there are timezone pairs for which a given calendar day in the two timezones are totally disjoint—the earlier day ends before the same day starts in the later timezone.  The moments in time represented by a single calendar day are spread over a 52-hour interval, from the beginning of the day in the +14:00 timezone to the end of that day in the −14:00 timezone.

The lexical representations for are projections of those of , as follows: Lexical Space timeLexicalRep (( :  : ) | ) ? The production is equivalent to this regular expression, once whitespace is removed: (((([01][0-9])|(2[0-3])):([0-5][0-9]):(([0-5][0-9])(\.[0-9]+)?))
  |(24:00:00(\.0+)?))
(Z|((+|-)(0[0-9]|1[0-4]):[0-5][0-9]))?
(([01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9](\.[0-9]+)?|(24:00:00(\.0+)?))(Z|(\+|-)((0[0-9]|1[0-3]):[0-5][0-9]|14:00))? Note that neither the production nor this regular expression alone enforce the constraint on given above.

The for is ; the is .

uses the , with , , and required to be absent.  remains .

Equality and order are as prescribed in .

The lexical representations for are projections of those of , as follows: Lexical Space dateLexicalRep  -  -  ? Day-of-month Representations

Within a , a must not begin with the digit 3 or be 29 unless the value to which it would map would satisfy the value constraint on values (Constraint: Day-of-month Values) given above.

uses the , with , , , and required to be absent.  remains .

Equality and order are as prescribed in .

The lexical representations for are projections of those of , as follows: Lexical Space gYearMonthLexicalRep -  ? The is equivalent to this regular expression: \-?([1-9][0-9][0-9][0-9]+)|(0[0-9][0-9][0-9])\-(0[1-9])|(1[0-2])((+|\-)(0[0-9]|1[0-4]):[0-5][0-9])? -?([1-9][0-9]{3,}|0[0-9]{3})-(0[1-9]|1[0-2])(Z|(\+|-)((0[0-9]|1[0-3]):[0-5][0-9]|14:00))?

The for is . The is .

uses the , with , , , , and required to be absent.  remains .

Equality and order are as prescribed in .

The lexical representations for are projections of those of , as follows: Lexical Space gYearLexicalRep -  ? The is equivalent to this regular expression: \-?([1-9][0-9][0-9][0-9]+)|(0[0-9][0-9][0-9])((+|\-)(0[0-9]|1[0-4]):[0-5][0-9])? -?([1-9][0-9]{3,}|0[0-9]{3})(Z|(\+|-)((0[0-9]|1[0-3]):[0-5][0-9]|14:00))?

The for is . The is .

uses the , with , , , and required to be absent.  remains .

Equality and order are as prescribed in .

The lexical representations for are projections of those of , as follows: Lexical Space gMonthDayLexicalRep --  -  ? Day-of-month Representations

Within a , a must not begin with the digit 3 or be 29 unless the value to which it would map would satisfy the value constraint on values (Constraint: Day-of-month Values) given above.

uses the , with , , , , and required to be absent.  remains and must be between 1 and 31 inclusive.

Equality and order are as prescribed in .  Since values (days) are ordered by their first moments, it is possible for apparent anomalies to appear in the order when values differ by at least 24 hours.  (It is possible for values to differ by up to 28 hours.)

Examples that may appear anomalous (see for the notations):

---15 < ---16 , but  ---15−13:00 > ---16+13:00

The lexical representations for are projections of those of , as follows: Lexical Space gDayLexicalRep ---  ? The is equivalent to this regular expression: \-\-\-([0-2][0-9]|3[01])((+|\-)(0[0-9]|1[0-4]):[0-5][0-9])? ---(0[1-9]|[12][0-9]|3[01])(Z|(\+|-)((0[0-9]|1[0-3]):[0-5][0-9]|14:00))?

The for is . The is .

uses the , with , , , , and required to be absent.  remains .

Equality and order are as prescribed in .

The lexical representations for are projections of those of , as follows: Lexical Space gMonthLexicalRep --  ? The is equivalent to this regular expression: \-\-(0[1-9])|(1[0-2])((+|\-)(0[0-9]|1[0-4]):[0-5][0-9])? --(0[1-9]|1[0-2])(Z|(\+|-)((0[0-9]|1[0-3]):[0-5][0-9]|14:00))?

The for is . The is .

The of hexBinary is the set of possibly empty finite-length sequences of binary octets.  The length of a value is the number of octets.

hexBinary has a where each binary octet is encoded as a character tuple, consisting of two hexadecimal digits ([0-9a-fA-F]) representing the octet code. For example, 0FB7 is a hex encoding for the 16-bit integer 4023 (whose binary representation is 111110110111).

's consists of strings of hex (hexadecimal) digits, two consecutive digits representing each octet in the corresponding value (treating the octet as the binary representation of a number between 0 and 255).  For example, 0FB7 is a of the two-octet value 00001111 10110111.

More formally, the of is the set of literals matching the production. Lexical space of hexBinary hexDigit 0-9a-fA-F hexOctet hexBinary *

The set recognized by is the same as that recognized by the regular expression ([0-9a-fA-F]{2})*.

The of is .

The for hexBinary is defined by prohibiting certain options from the .  Specifically, the lower case hexadecimal digits ([a-f]) are not allowed.

The of is given formally in .

The for hexBinary is defined by prohibiting certain options from the .  Specifically, the lower case hexadecimal digits ([a-f]) are not allowed.

The of is given formally in .

The of is the set of possibly empty finite-length sequences of binary octets.  The length of a value is the number of octets.

The lexical representations of base64Binary values are limited to the 65 characters of the Base64 Alphabet defined in , i.e., a-z, A-Z, 0-9, the plus sign (+), the forward slash (/) and the equal sign (=), together with the space character (#x20). No other characters are allowed.

For compatibility with older mail gateways, suggests that Base64 data should have lines limited to at most 76 characters in length.  This line-length limitation is not required by and is not mandated in the lexical representations of base64Binary data. It must not be enforced by XML Schema processors.

The of base64Binary is the set of literals which the Base64Binary production.

Lexical space of base64Binary Base64Binary (* )? B64quad ( ) B64quad represents three octets of binary data. B64final | | B64finalquad ( ) B64finalquad represents three octets of binary data without trailing space. Padded16 = Padded16 represents a two-octet at the end of the data. Padded8 = #x20? = Padded8 represents a single octet at the end of the data. B64 #x20? B64char[A-Za-z0-9+/] B16 #x20? B16char[AEIMQUYcgkosw048] Base64 characters whose bit-string value ends in '00' B04 #x20? B04char[AQgw] Base64 characters whose bit-string value ends in '0000'

The production is equivalent to the following regular expression. ((([A-Za-z0-9+/] ?){4})*(([A-Za-z0-9+/] ?){3}[A-Za-z0-9+/]|([A-Za-z0-9+/] ?){2}[AEIMQUYcgkosw048] ?=|[A-Za-z0-9+/] ?[AQgw] ?= ?=))? Note that each ? except the last is preceded by a single space character.

Note that this grammar requires the number of non-whitespace characters in the to be a multiple of four, and for equals signs to appear only at the end of the ; literals which do not meet these constraints are not legal lexical representations of base64Binary because they cannot successfully be decoded by Base64 decoders.

The for is as given in and .

The canonical of a base64Binary data value is the Base64 encoding of the value which matches the Canonical-base64Binary production in the following grammar:

Canonical representation of base64Binary Canonical-base64Binary * ? CanonicalQuad CanonicalPadded = | ==

That is, the of a value is the which maps to that value and contains no whitespace. The for is thus the encoding algorithm for Base64 data given in and , with the proviso that no characters except those in the Base64 Alphabet are to be written out.

The length of a base64Binary value is the number of octets it contains.  This may be calculated from the by removing whitespace and padding characters and performing the calculation shown in the pseudo-code below:

lex2   := killwhitespace(lexform)    -- remove whitespace characters
lex3   := strip_equals(lex2)         -- strip padding characters at end
length := floor (length(lex3) * 3 / 4)         -- calculate length

Note on encoding: and explicitly reference US-ASCII encoding.  However, decoding of base64Binary data in an XML entity is to be performed on the Unicode characters obtained after character encoding processing as specified by .

The of anyURI is the set of possibly empty finite-length character sequences.

The for is the identity mapping.

integer has a lexical representation consisting of a finite-length sequence of one or more decimal digits (#x30-#x39) with an optional leading sign.  If the sign is omitted, "+" is assumed.  For example: -1, 0, 12678967543233, +100000.

The for integer is defined by prohibiting certain options from the .  Specifically, the preceding optional "+" sign is prohibited and leading zeroes are prohibited.

nonPositiveInteger has a lexical representation consisting of an optional preceding sign followed by a non-empty finite-length sequence of decimal digits (#x30-#x39). The sign may be "+" or may be omitted only for lexical forms denoting zero; in all other lexical forms, the negative sign (-) must be present. For example: -1, 0, -12678967543233, -100000.

The for nonPositiveInteger is defined by prohibiting certain options from the . In the canonical form for zero, the sign must be omitted.  Leading zeroes are prohibited.

negativeInteger has a lexical representation consisting of a negative sign (-) followed by a non-empty finite-length sequence of decimal digits (#x30-#x39).  For example: -1, -12678967543233, -100000.

The for negativeInteger is defined by prohibiting certain options from the .  Specifically, leading zeroes are prohibited.

long has a lexical representation consisting of an optional sign followed by a non-empty finite-length sequence of decimal digits (#x30-#x39).  If the sign is omitted, "+" is assumed. For example: -1, 0, 12678967543233, +100000.

The for long is defined by prohibiting certain options from the .  Specifically, the the optional "+" sign is prohibited and leading zeroes are prohibited.

int has a lexical representation consisting of an optional sign followed by a non-empty finite-length sequence of decimal digits (#x30-#x39).  If the sign is omitted, "+" is assumed. For example: -1, 0, 126789675, +100000.

The for int is defined by prohibiting certain options from the .  Specifically, the the optional "+" sign is prohibited and leading zeroes are prohibited.

short has a lexical representation consisting of an optional sign followed by a non-empty finite-length sequence of decimal digits (#x30-#x39).  If the sign is omitted, "+" is assumed. For example: -1, 0, 12678, +10000.

The for short is defined by prohibiting certain options from the .  Specifically, the the optional "+" sign is prohibited and leading zeroes are prohibited.

byte has a lexical representation consisting of an optional sign followed by a non-empty finite-length sequence of decimal digits (#x30-#x39).  If the sign is omitted, "+" is assumed. For example: -1, 0, 126, +100.

The for byte is defined by prohibiting certain options from the .  Specifically, the the optional "+" sign is prohibited and leading zeroes are prohibited.

nonNegativeInteger has a lexical representation consisting of an optional sign followed by a non-empty finite-length sequence of decimal digits (#x30-#x39).  If the sign is omitted, the positive sign (+) is assumed. If the sign is present, it must be "+" except for lexical forms denoting zero, which may be preceded by a positive (+) or a negative (-) sign. For example: 1, 0, 12678967543233, +100000.

The for nonNegativeInteger is defined by prohibiting certain options from the .  Specifically, the the optional "+" sign is prohibited and leading zeroes are prohibited.

unsignedLong has a lexical representation consisting of an optional sign followed by a non-empty finite-length sequence of decimal digits (#x30-#x39). If the sign is omitted, the positive sign (+) is assumed. If the sign is present, it must be + except for lexical forms denoting zero, which may be preceded by a positive (+) or a negative (-) sign. For example: 0, 12678967543233, 100000.

The for unsignedLong is defined by prohibiting certain options from the .  Specifically, leading zeroes are prohibited.

unsignedInt has a lexical representation consisting of an optional sign followed by a non-empty finite-length sequence of decimal digits (#x30-#x39). If the sign is omitted, the positive sign (+) is assumed. If the sign is present, it must be + except for lexical forms denoting zero, which may be preceded by a positive (+) or a negative (-) sign. For example: 0, 1267896754, 100000.

The for unsignedInt is defined by prohibiting certain options from the .  Specifically, leading zeroes are prohibited.

unsignedShort has a lexical representation consisting of an optional sign followed by a non-empty finite-length sequence of decimal digits (#x30-#x39). If the sign is omitted, the positive sign (+) is assumed. If the sign is present, it must be + except for lexical forms denoting zero, which may be preceded by a positive (+) or a negative (-) sign. For example: 0, 12678, 10000.

The for unsignedShort is defined by prohibiting certain options from the .  Specifically, the leading zeroes are prohibited.

unsignedByte has a lexical representation consisting of an optional sign followed by a non-empty finite-length sequence of decimal digits (#x30-#x39). If the sign is omitted, the positive sign (+) is assumed. If the sign is present, it must be + except for lexical forms denoting zero, which may be preceded by a positive (+) or a negative (-) sign. For example: 0, 126, 100.

The for unsignedByte is defined by prohibiting certain options from the .  Specifically, leading zeroes are prohibited.

positiveInteger has a lexical representation consisting of an optional positive sign (+) followed by a non-empty finite-length sequence of decimal digits (#x30-#x39). For example: 1, 12678967543233, +100000.

The for positiveInteger is defined by prohibiting certain options from the .  Specifically, the optional "+" sign is prohibited and leading zeroes are prohibited.