HOME


sh-3ll 1.0
DIR:/usr/share/emacs/26.1/lisp/nxml/
Upload File :
Current File : //usr/share/emacs/26.1/lisp/nxml/rng-xsd.elc
;ELC
;;; Compiled
;;; in Emacs version 26.1
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(byte-code "\300\301!\210\300\302!\210\300\303!\210\304\305\306\307#\207" [require rng-dt rng-util xsd-regexp put http://www\.w3\.org/2001/XMLSchema-datatypes rng-dt-compile rng-xsd-compile] 4)
#@1042 Provides W3C XML Schema as a RELAX NG datatypes library.
NAME is a symbol giving the local name of the datatype.  PARAMS is a
list of pairs (PARAM-NAME . PARAM-VALUE) where PARAM-NAME is a symbol
giving the name of the parameter and PARAM-VALUE is a string giving
its value.  If NAME or PARAMS are invalid, it calls `rng-dt-error'
passing it arguments in the same style as format; the value from
`rng-dt-error' will be returned.  Otherwise, it returns a list.  The
first member of the list is t if any string is a legal value for the
datatype and nil otherwise.  The second argument is a symbol; this
symbol will be called as a function passing it a string followed by
the remaining members of the list.  The function must return an object
representing the value of the datatype that was represented by the
string, or nil if the string is not a representation of any value.
The object returned can be any convenient non-nil value, provided
that, if two strings represent the same value, the returned objects
must be equal.

(fn NAME PARAMS)
(defalias 'rng-xsd-compile #[514 "\300N\211\204\301\302\"\202\303#\207" [rng-xsd-convert rng-dt-error "There is no XSD datatype named %s" rng-xsd-compile1] 7 (#$ . 604)])
#@28 

(fn NAME PARAMS CONVERT)
(defalias 'rng-xsd-compile1 #[771 "\204>\211\300\232\301=\203\202<\302=\203\303B\202<\301=\204;\304>\2045\305>\2045\306>\203;\307B\202<B\207@\211@A\310>\203\205\311@AB\"\312N\204b\313\314\"\202\200\211\204m\313\315\"\202\200\316A\317NBBB#\266\202\202%\320>\203\300\321!\322N\204\235\313\323\"\202\273\211\204\250\313\324\"\202\273\316A\317NBBB#\266\202\202%\325>\203\350\321!\211\204\324\313\326\"\202\343\316A\317N	BB#\262\202%\327=\203\3301	\316A\306\331\332!\333QBB#0\202%\313\334A@\"\262\202%\335>\203!\313\336\"\202%\313\337\"\207" [(identity) string normalizedString rng-xsd-replace-space identity rng-xsd-convert-any-uri rng-xsd-check-pattern rng-xsd-collapse-space (minExclusive maxExclusive minInclusive maxInclusive) apply rng-xsd-less-than rng-dt-error "Minimum value %s is not valid" "Values of type %s are not ordered" rng-xsd-compile1 rng-xsd-check (length minLength maxLength) rng-xsd-string-to-non-negative-integer rng-xsd-length "Length %s is not valid" "Values of type %s do not have a length" (fractionDigits totalDigits) "Number of digits %s is not valid" pattern (xsdre-invalid-regexp) "\\`" xsdre-translate "\\'" "Invalid regular expression (%s)" (enumeration whiteSpace) "Facet %s cannot be used in RELAX NG" "Unknown facet %s"] 15 (#$ . 1831)])
#@12 

(fn STR)
(defalias 'rng-xsd-string-to-non-negative-integer #[257 "\300!\205\301!\211\250\205\211\302Y\205\211\262\207" [rng-xsd-convert-integer string-to-number 0] 4 (#$ . 3245)])
#@31 

(fn STR CONVERT &rest ARGS)
(defalias 'rng-xsd-collapse-space #[642 "\300\301\302\303\304\"\305#B\"\207" [apply mapconcat identity split-string "[ 	\n
]+" " "] 10 (#$ . 3442)])
#@31 

(fn STR CONVERT &rest ARGS)
(defalias 'rng-xsd-replace-space #[642 "\300\301\302\303\304#\211\262\203-\211\204\305!\211\262\203-\211\306I\203-T\211\262\204\211\2063\266\202B\"\207" [apply 0 nil string-match "[
\n	]" copy-sequence 32] 11 (#$ . 3631)])
(byte-code "\300\301\302\303#\210\300\304\302\305#\210\300\306\302\307#\210\300\310\302\311#\210\300\312\302\313#\210\300\314\302\315#\210\300\316\302\317#\210\300\320\302\321#\210\300\322\302\323#\207" [put minExclusive rng-xsd-check rng-xsd-check-min-exclusive minInclusive rng-xsd-check-min-inclusive maxExclusive rng-xsd-check-max-exclusive maxInclusive rng-xsd-check-max-inclusive length rng-xsd-check-length minLength rng-xsd-check-min-length maxLength rng-xsd-check-max-length fractionDigits rng-xsd-check-fraction-digits totalDigits rng-xsd-check-total-digits] 4)
#@51 

(fn STR LESS-THAN-FUN LIMIT CONVERT &rest ARGS)
(defalias 'rng-xsd-check-min-exclusive #[1156 "\300B\"\211\205\"\205\211\207" [apply] 9 (#$ . 4484)])
#@51 

(fn STR LESS-THAN-FUN LIMIT CONVERT &rest ARGS)
(defalias 'rng-xsd-check-min-inclusive #[1156 "\300B\"\211\205\"\204\232\205\211\207" [apply] 9 (#$ . 4653)])
#@51 

(fn STR LESS-THAN-FUN LIMIT CONVERT &rest ARGS)
(defalias 'rng-xsd-check-max-exclusive #[1156 "\300B\"\211\205\"\205\211\207" [apply] 9 (#$ . 4834)])
#@51 

(fn STR LESS-THAN-FUN LIMIT CONVERT &rest ARGS)
(defalias 'rng-xsd-check-max-inclusive #[1156 "\300B\"\211\205\"\204\211\232\205\211\207" [apply] 9 (#$ . 5003)])
#@48 

(fn STR LENGTH-FUN LIMIT CONVERT &rest ARGS)
(defalias 'rng-xsd-check-min-length #[1156 "\300B\"\211\205!Y\205\211\207" [apply] 9 (#$ . 5187)])
#@48 

(fn STR LENGTH-FUN LIMIT CONVERT &rest ARGS)
(defalias 'rng-xsd-check-max-length #[1156 "\300B\"\211\205!X\205\211\207" [apply] 9 (#$ . 5350)])
#@46 

(fn STR LENGTH-FUN LEN CONVERT &rest ARGS)
(defalias 'rng-xsd-check-length #[1156 "\300B\"\211\205!U\205\211\207" [apply] 9 (#$ . 5513)])
#@33 

(fn STR N CONVERT &rest ARGS)
(defalias 'rng-xsd-check-fraction-digits #[899 "\300B\"\211\205\211\301HGX\205\211\207" [apply 2] 8 (#$ . 5670)])
#@33 

(fn STR N CONVERT &rest ARGS)
(defalias 'rng-xsd-check-total-digits #[899 "\300B\"\211\205\211\301HG\302HG\\X\205\211\207" [apply 1 2] 8 (#$ . 5830)])
#@38 

(fn STR REGEXP CONVERT &rest ARGS)
(defalias 'rng-xsd-check-pattern #[899 "\301\302\")\205\303B\"\207" [case-fold-search nil string-match apply] 8 (#$ . 5998)])
#@15 

(fn STRING)
(defalias 'rng-xsd-convert-boolean #[257 "\300\301\"\205\302\224\203\303\207\304\207" [string-match "\\`[ 	\n
]*\\(?:\\(true\\|1\\)\\|false\\|0\\)[ 	\n
]*\\'" 1 true false] 4 (#$ . 6175)])
#@430 Convert a string representing a decimal to an object representing it values.
A decimal value is represented by a vector [SIGN INTEGER-DIGITS
FRACTION-DIGITS] where SIGN is 1 or -1, INTEGER-DIGITS is a string
containing zero or more digits, with no leading zero, and
FRACTION-DIGITS is a string containing zero or more digits with no
trailing digits.  For example, -0021.0430 would be represented by [-1
"21" "043"].

(fn STRING)
(defalias 'rng-xsd-convert-decimal #[257 "\300\301\"\205C\302\303\"\211\304\230?\205\211\305\230?\262\205C\302\306\"\307\302\310\"\311\232\2031\2031\312\2022\310\2067\305\302\313\"\206@\305#\262\207" [string-match "\\`[ 	\n
]*\\([-+]\\)?\\(0*\\([1-9][0-9]*\\)?\\(\\.\\([0-9]*[1-9]\\)?0*\\)?\\)[ 	\n
]*\\'" match-string 2 "." "" 3 vector 1 "-" -1 5] 8 (#$ . 6390)])
#@15 

(fn STRING)
(defalias 'rng-xsd-convert-integer #[257 "\300\301\"\205'\302\303\"\304\302\305\"\306\232\203\203\307\202\305\206#\310\310#\262\207" [string-match "\\`[ 	\n
]*\\([-+]\\)?\\(?:0*\\([1-9][0-9]*\\)\\|0+\\)[ 	\n
]*\\'" match-string 2 vector 1 "-" -1 ""] 6 (#$ . 7209)])
#@14 

(fn N1 N2)
(defalias 'rng-xsd-decimal< #[514 "\300\"\301W\207" [rng-xsd-compare-decimal 0] 5 (#$ . 7509)])
#@76 Return a < 0, 0, > 0 according as n1 < n2, n1 = n2 or n1 > n2.

(fn N1 N2)
(defalias 'rng-xsd-compare-decimal #[514 "\300H\300HZ\211\300U\203D\301H\301HGGZ\211\300=\203=\230\2036\302\303H\303H\"\202>\302\"\202>\211\266\205_\202E\211\207" [0 1 rng-xsd-strcmp 2] 15 (#$ . 7626)])
(defconst rng-xsd-float-regexp "\\`[ 
\n	]*\\(?:\\([-+]?\\(?:[0-9]+\\(?:\\.[0-9]*\\)?\\|\\.[0-9]+\\)\\(?:[eE][-+]?[0-9]+\\)?\\)\\|\\(INF\\)\\|\\(-INF\\)\\|\\(NaN\\)\\)[ 
\n	]*\\'")
#@15 

(fn STRING)
(defalias 'rng-xsd-convert-float #[257 "\301\"\204	\302\207\303\224\203\304\305\306\303\"!!\207\307\224\203\310\207\311\224\203%\312\207\313\224\205+\314\207" [rng-xsd-float-regexp string-match nil 1 float string-to-number match-string 2 1.0e+INF 3 -1.0e+INF 4 NaN] 6 (#$ . 8116)])
#@14 

(fn F1 F2)
(defalias 'rng-xsd-float< #[514 "\300=?\205\211\300=?\205W\207" [NaN] 4 (#$ . 8428)])
#@22 

(fn STRING REGEXP)
(defalias 'rng-xsd-convert-token #[514 "\300\"\205\301\302\"\207" [string-match match-string 1] 5 (#$ . 8540)])
#@15 

(fn STRING)
(defalias 'rng-xsd-convert-hex-binary #[257 "\300\301\"\205\f\302\303\"\227\207" [string-match "\\`[ 
\n	]*\\(\\(?:[0-9A-Fa-f][0-9A-Fa-f]\\)*\\)[ 
\n	]*\\'" match-string 1] 4 (#$ . 8684)])
#@12 

(fn OBJ)
(defalias 'rng-xsd-hex-binary-length #[257 "\211G\300\245\207" [2] 3 (#$ . 8896)])
(defconst rng-xsd-base64-binary-regexp (byte-code "\300\301\302\303\304\305\306\307	
\f\310\311\310\310\312\260\207" ["[ 	
\n]*" "[AQgw]" "[AEIMQUYcgkosw048]" "[A-Za-z0-9+/]" "\\`" "\\(?:\\(?:" "\\)\\{4\\}\\)*" "\\(?:" "=" "\\|" "\\)?\\'"] 29))
#@15 

(fn STRING)
(defalias 'rng-xsd-convert-base64-binary #[257 "\301\"\205\302\303\304\305\211%\207" [rng-xsd-base64-binary-regexp string-match replace-regexp-in-string "[ 	
\n]+" "" t] 7 (#$ . 9269)])
#@12 

(fn OBJ)
(defalias 'rng-xsd-base64-binary-length #[257 "\211G\300\245\301_\211\302V\203(\303\304O\305\230\203(\211\306\304O\307\230\203#\310\202$\311Z\202)\211\207" [4 3 0 -1 nil "=" -2 "==" 2 1] 6 (#$ . 9480)])
#@15 

(fn STRING)
(defalias 'rng-xsd-convert-any-uri #[257 "\300\301\"\205\300\302\"\205\300\303\"\205\211\207" [string-match "\\`\\(?:[^%]\\|%[0-9a-fA-F][0-9a-fA-F]\\)?*\\'" "\\`[^#]*\\(?:#[^#]*\\)?\\'" "\\`\\(?:[a-zA-Z][-+.A-Za-z0-9]*:.+\\|[^:]*\\(?:[#/?].*\\)?\\)\\'"] 4 (#$ . 9707)])
#@608 Returns a regular expression matching a ISO 8601 date/time.
The template is a string with Y standing for years field, M standing
for months, D standing for day of month, T standing for a literal T, t
standing for time and - standing for a literal hyphen.  A time zone is
always allowed at the end.  Regardless of the fields appearing in the
template, the regular expression will have twelve groups matching the
year sign, year, month, day of month, hours, minutes, integer seconds,
fractional seconds (including leading period), time zone, time zone
sign, time zone hours, time zone minutes.

(fn TEMPLATE)
(defalias 'rng-xsd-make-date-time-regexp #[257 "\300G\301\211\211\211W\203\\H\262\211\302\267\202N\300\262\303\262\304\202Q\204+\305\262\305\262\306\202Q\2049\307\262\307\262\306\202Q\204G\310\262\311\262\312\202Q\313!B\262T\262\202\311W\203nT\262\314B\262\202\\\315B\262\316\237B\262\300V\203\213S\262\317B\262\202y\320\321\"\207" [0 nil #s(hash-table size 4 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (89 26 77 36 68 50 116 64)) 1 "\\(-\\)?\\(\\(?:[1-9][0-9]*\\)?[0-9]\\{4\\}\\)" 2 "\\([0-9][0-9]\\)" 3 4 7 "\\([0-9][0-9]\\):\\([0-9][0-9]\\):\\([0-9][0-9]\\)\\(\\.[0-9]*\\)?" string "\\(\\'X\\)?" "\\(Z\\|\\([-+]\\)\\([0-9][0-9]\\):\\([0-5][0-9]\\)\\)?[ 	\n
]*\\'" "\\`[ 	\n
]*" "\\(X\\)?" apply concat] 10 (#$ . 10007)])
(defconst rng-xsd-seconds-per-day 86400)
(defconst rng-xsd-days-in-month [31 28 31 30 31 30 31 31 30 31 30 31])
#@19 

(fn YEAR MONTH)
(defalias 'rng-xsd-days-in-month #[514 "\211\301U\203\302!\203\303\207SH\207" [rng-xsd-days-in-month 2 rng-xsd-leap-year-p 29] 4 (#$ . 11531)])
(defconst rng-xsd-months-to-days (byte-code "\301\302\303\"\304\211\211\302W\203H\\\262I\210\211T\262\202\207" [rng-xsd-days-in-month make-vector 12 nil 0] 6))
#@510 Converts an XML Schema date/time to a list.
Returns nil if invalid.  REGEXP is a regexp for parsing the date time
as returned by `rng-xsd-make-date-time-regexp'.  The list has 4 members
(HAS-TIME-ZONE DAY SECOND SECOND-FRACTION), where HAS-TIME-ZONE is t
or nil depending on whether a time zone was specified, DAY is an
integer giving a day number (with Jan 1 1AD being day 1), SECOND is the
second within that day, and SECOND-FRACTION is a float giving the
fractional part of the second.

(fn STRING REGEXP)
(defalias 'rng-xsd-convert-date-time #[514 "\300\"\205I\301\302\"\301\303\"\301\304\"\301\305\"\301\306\"\301\307\"\301\310	\"\301\311\n\"\301\312\"\301\313\f\"\301\314
\"\301\315\"\203I\316\202J\302\262\f\n\203[\317\f!_\202\\\320\262	\203j\317\n!\202k\302\262\n\203y\317	!\202z\302\262	\203\210\317!\202\211\321\262\203\227\317!\202\230\321\262\203\245\317!\202\246\321\262\203\265\322\317!!\202\266\323\262\205\275\324\262\325\232\203\311\316\202\312\302\262\203\326\317!\202\327\321\262\211\203\343\317!\202\344\321\262	\302Y\205G	\315X\205G\302Y\205G\326\f\f\"X\205G\327X\205G\330X\205G\331X\205G\327X\205G\211\330X\205G\332\333


#\334#E\334\321#[_\"B\266\214\207" [string-match match-string 1 2 3 4 5 6 7 8 9 10 11 12 -1 string-to-number 2000 0 float 0.0 t "-" rng-xsd-days-in-month 23 59 60 rng-xsd-add-seconds rng-xsd-date-to-days rng-xsd-time-to-seconds] 21 (#$ . 11880)])
#@13 

(fn YEAR)
(defalias 'rng-xsd-leap-year-p #[257 "\211\300\246\301U\205\211\302\246\301U?\206\211\303\246\301U\207" [4 0 100 400] 3 (#$ . 13398)])
#@27 

(fn HOUR MINUTE SECOND)
(defalias 'rng-xsd-time-to-seconds #[771 "\300_\\\300_\\\207" [60] 5 (#$ . 13555)])
(defconst rng-xsd-max-tz (byte-code "\300\301\302\211#\207" [rng-xsd-time-to-seconds 14 0] 4))
#@16 

(fn DT1 DT2)
(defalias 'rng-xsd-date-time< #[514 "@@=\203\301AA\"\207@\203\301A\302A[\"\"\207\301\302A\"A\"\207" [rng-xsd-max-tz rng-xsd-number-list< rng-xsd-add-seconds] 7 (#$ . 13769)])
#@20 

(fn DATE OFFSET)
(defalias 'rng-xsd-add-seconds #[514 "@A@\\\3018\302W\203S\\E\202.Y\203*TZE\202.E\207" [rng-xsd-seconds-per-day 2 0] 8 (#$ . 13980)])
#@26 

(fn NUMBERS1 NUMBERS2)
(defalias 'rng-xsd-number-list< #[514 "\203@@U\203A\262\211A\262\202\205 @@W\207" [] 4 (#$ . 14162)])
#@75 Return a unique day number where Jan 1 1 AD is day 1

(fn YEAR MONTH DAY)
(defalias 'rng-xsd-date-to-days #[771 "\300V\203\301S!\302#\\\207\301\303Z!\301\303!Z\304!\203$\305\202%\306\302#Z\\[\207" [0 rng-xsd-days-in-years rng-xsd-day-number-in-year 3 rng-xsd-leap-year-p 366 365] 9 (#$ . 14311)])
#@76 The number of days in YEARS years where the first year is 1AD.

(fn YEARS)
(defalias 'rng-xsd-days-in-years #[257 "\300\301_\302\245\303\245[\304\245$\207" [+ 365 4 100 400] 7 (#$ . 14628)])
#@23 

(fn YEAR MONTH DAY)
(defalias 'rng-xsd-day-number-in-year #[771 "\301\302U\203\303\202\304ZH\304V\203\"\305!\203\"\302\202#\303#\207" [rng-xsd-months-to-days + 1 0 2 rng-xsd-leap-year-p] 8 (#$ . 14829)])
(defconst rng-xsd-duration-regexp "\\`[ 	
\n]*\\(-\\)?P\\([0-9]+Y\\)?\\([0-9]+M\\)?\\([0-9]+D\\)?\\(?:T\\([0-9]+H\\)?\\([0-9]+M\\)?\\(\\([0-9]+\\(?:\\.[0-9]*\\)?\\|\\.[0-9]+\\)S\\)?\\)?[ 	
\n]*\\'")
#@15 

(fn STRING)
(defalias 'rng-xsd-convert-duration #[257 "\301\"\205]\211\302\303O\211\304\230\206\211\305\230?\262\205]\306\307\310\"\311\224\203'\302\202(\311\310\211\307W\203Q\211\312\\\224\211\203I\313\312\\\225SO!_I\210\210\211T\262\202)\314\315\314H!I\210\266\203\207" [rng-xsd-duration-regexp string-match -1 nil "P" "T" make-vector 6 0 1 2 string-to-number 5 float] 13 (#$ . 15254)])
(defconst rng-xsd-min-seconds-per-month (* rng-xsd-seconds-per-day 28))
#@14 

(fn D1 D2)
(defalias 'rng-xsd-duration< #[514 "\301!\301!\302!\302!W\203'ZW\203\303\202B\304$\202BV\203?\211ZW?\205B\304$\202BW\207" [rng-xsd-min-seconds-per-month rng-xsd-duration-months rng-xsd-duration-seconds t rng-xsd-months-seconds<] 11 (#$ . 15747)])
(defconst xsd-duration-reference-dates '((1696 . 9) (1697 . 2) (1903 . 3) (1903 . 7)))
#@42 

(fn MONTHS1 SECONDS1 MONTHS2 SECONDS2)
(defalias 'rng-xsd-months-seconds< #[1028 "\301\211@\211@A\302	#\\\302#\\W\204!\303\262\205*A\211\262\266\203\204\207" [xsd-duration-reference-dates t rng-xsd-month-seconds nil] 14 (#$ . 16131)])
#@137 Return the seconds in a number of months starting on a reference date.
Returns a floating point number.

(fn MONTHS REF-YEAR REF-MONTH)
(defalias 'rng-xsd-month-seconds #[771 "\301\302\303!#\304!\305W\203\306\202\307#\207" [rng-xsd-seconds-per-day * rng-xsd-month-days abs float 0 -1.0 1.0] 8 (#$ . 16397)])
(defconst rng-xsd-years-per-gregorian-cycle 400)
(defconst rng-xsd-months-per-gregorian-cycle (* rng-xsd-years-per-gregorian-cycle 12))
(defconst rng-xsd-leap-years-per-gregorian-cycle 97)
(defconst rng-xsd-days-per-gregorian-cycle (byte-code "\302_	\\\207" [rng-xsd-years-per-gregorian-cycle rng-xsd-leap-years-per-gregorian-cycle 365] 2))
#@133 Return the days in a number of months starting on a reference date.
MONTHS must be an integer >= 0.

(fn MONTHS REF-YEAR REF-MONTH)
(defalias 'rng-xsd-month-days #[771 "\302\303\"\262\302V\203.\304\"\\\262\305=\203#T\262\306\202%T\262S\262\202\245	_\\\207" [rng-xsd-months-per-gregorian-cycle rng-xsd-days-per-gregorian-cycle 0 mod rng-xsd-days-in-month 12 1] 7 (#$ . 17063)])
#@10 

(fn D)
(defalias 'rng-xsd-duration-months #[257 "\211\300H\301_\302H\\\207" [0 12 1] 4 (#$ . 17469)])
#@10 

(fn D)
(defalias 'rng-xsd-duration-seconds #[257 "\211\300H\301_\302H\\\303_\304H\\\305_\306H\\\207" [2 24.0 3 60.0 4 60.0 5] 4 (#$ . 17580)])
#@15 

(fn STRING)
(defalias 'rng-xsd-convert-qname #[257 "\301\302\"\2058\303\224\304@A\"\203/\305\224O\306A\"\211\205*\211AT\305\225OB\266\202\2026\211@\307\305\"B\266\202\207" [rng-dt-namespace-context-getter string-match "\\`[ 
\n	]*\\([_[:alpha:]][-._[:alnum:]]*\\(:[_[:alpha:]][-._[:alnum:]]*\\)?\\)[ 
\n	]*\\'" 2 apply 1 assoc match-string] 9 (#$ . 17734)])
#@34 

(fn STRING CONVERT &rest ARGS)
(defalias 'rng-xsd-convert-list #[642 "\300\301\"\211\211\203)\302@B\"\211\203\240\210A\262\202%\303\262\303\262\210\202\207" [split-string "[ 	\n
]+" apply nil] 9 (#$ . 18115)])
#@14 

(fn S1 S2)
(defalias 'rng-xsd-strcmp #[514 "\230\203\300\207\231\203\301\207\302\207" [0 -1 1] 4 (#$ . 18350)])
(byte-code "\300\301\302\303#\210\300\301\304\305#\210\300\301\306\307#\210\300\310\302\311#\210\300\310\304\305#\210\300\310\306\307#\210\300\312\302\313#\210\300\312\304\305#\210\300\312\306\307#\210\300\314\302\315#\210\300\314\304\316#\210\300\317\302\320#\210\300\317\304\321#\210\300\322\302\323#\210\300\324\302\325#\210\300\324\326\327#\210\300\330\302\331#\210\300\330\326\327#\210\300\332\302\333#\210\300\332\326\334#\210\300\335\302\336#\210\300\335\326\334#\207" [put string rng-xsd-convert (identity) rng-xsd-length length rng-xsd-matches-anything t normalizedString (identity) token (identity) hexBinary (rng-xsd-convert-hex-binary) rng-xsd-hex-binary-length base64Binary (rng-xsd-convert-base64-binary) rng-xsd-base64-binary-length boolean (rng-xsd-convert-boolean) float (rng-xsd-convert-float) rng-xsd-less-than rng-xsd-float< double (rng-xsd-convert-float) decimal (rng-xsd-convert-decimal) rng-xsd-decimal< integer (rng-xsd-convert-integer)] 4)
#@21 

(fn NAME MIN MAX)
(defalias 'rng-xsd-def-integer-type #[771 "\300\301\302#\210\300\303\304\305\306\205\307BC\205 \310BC\"\"A#\207" [put rng-xsd-less-than rng-xsd-decimal< rng-xsd-convert rng-xsd-compile integer append minInclusive maxInclusive] 12 (#$ . 19443)])
#@20 

(fn NAME REGEXP)
(defalias 'rng-xsd-def-token-type #[514 "\300\301\302\303\304QD#\210\300\305\306#\207" [put rng-xsd-convert rng-xsd-convert-token "\\`[
\n	 ]*\\(" "\\)[
\n	 ]*\\'" rng-xsd-length length] 9 (#$ . 19727)])
(byte-code "\300\301\302\"\210\300\303\304\"\210\300\305\306\"\210\300\307\310\"\210\311\312\313\305\313N#\210\311\312\314\315#\210\311\316\313\305\313N#\210\311\316\314\315#\210\311\317\313\305\313N#\210\311\317\314\315#\207" [rng-xsd-def-token-type NMTOKEN "[-.:_[:alnum:]]+" Name "[:_[:alpha:]][-.:_[:alnum:]]*" NCName "[_[:alpha:]][-._[:alnum:]]*" language "[a-zA-Z]\\{1,8\\}\\(?:-[a-zA-Z0-9]\\{1,8\\}\\)*" put ENTITY rng-xsd-convert rng-xsd-length length ID IDREF] 5)
#@25 

(fn NAME MEMBER-NAME)
(defalias 'rng-xsd-def-list-type #[514 "\300\301\302\301NB#\210\300\303\304#\207" [put rng-xsd-convert rng-xsd-convert-list rng-xsd-length length] 8 (#$ . 20432)])
(byte-code "\300\301\302\"\210\300\303\304\"\210\300\305\306\"\210\307\310\311\312#\210\307\310\313\314#\210\307\315\311\316#\210\307\317\311\320#\207" [rng-xsd-def-list-type NMTOKENS NMTOKEN IDREFS IDREF ENTITIES ENTITY put anyURI rng-xsd-convert (rng-xsd-convert-any-uri) rng-xsd-length length QName (rng-xsd-convert-qname) NOTATION (rng-xsd-convert-qname)] 4)
(defconst rng-xsd-long-max "9223372036854775807")
(defconst rng-xsd-long-min "-9223372036854775808")
(defconst rng-xsd-int-max "2147483647")
(defconst rng-xsd-int-min "-2147483648")
(defconst rng-xsd-short-max "32767")
(defconst rng-xsd-short-min "-32768")
(defconst rng-xsd-byte-max "127")
(defconst rng-xsd-byte-min "-128")
(defconst rng-xsd-unsigned-long-max "18446744073709551615")
(defconst rng-xsd-unsigned-int-max "4294967295")
(defconst rng-xsd-unsigned-short-max "65535")
(defconst rng-xsd-unsigned-byte-max "255")
(byte-code "\306\307\310\311#\210\306\312\313\311#\210\306\314\311\310#\210\306\315\311\316#\210\306\317	#\210\306\320\n#\210\306\321\f
#\210\306\322#\210\306\323\310#\210\306\324\310#\210\306\325\310#\210\306\326\310#\207" [rng-xsd-long-min rng-xsd-long-max rng-xsd-int-min rng-xsd-int-max rng-xsd-short-min rng-xsd-short-max rng-xsd-def-integer-type nonNegativeInteger "0" nil positiveInteger "1" nonPositiveInteger negativeInteger "-1" long int short byte unsignedLong unsignedInt unsignedShort unsignedByte rng-xsd-byte-min rng-xsd-byte-max rng-xsd-unsigned-long-max rng-xsd-unsigned-int-max rng-xsd-unsigned-short-max rng-xsd-unsigned-byte-max] 4)
#@22 

(fn NAME TEMPLATE)
(defalias 'rng-xsd-def-date-time-type #[514 "\300\301\302\303!D#\210\300\304\305#\207" [put rng-xsd-convert rng-xsd-convert-date-time rng-xsd-make-date-time-regexp rng-xsd-less-than rng-xsd-date-time<] 8 (#$ . 22183)])
(byte-code "\300\301\302\"\210\300\303\304\"\210\300\305\306\"\210\300\307\310\"\210\300\311\312\"\210\300\313\314\"\210\300\315\316\"\210\300\317\320\"\210\321\322\323\324#\210\321\322\325\326#\210\327\330!\207" [rng-xsd-def-date-time-type dateTime "Y-M-DTt" time "t" date "Y-M-D" gYearMonth "Y-M" gYear "Y" gMonthDay "--M-D" gDay "---D" gMonth "--M" put duration rng-xsd-convert (rng-xsd-convert-duration) rng-xsd-less-than rng-xsd-duration< provide rng-xsd] 4)