rW      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgh i j k l m n o p q r s t u v w x y z { | } ~                                   ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e fghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                       !!!!!"""""############### # $ $ $ $$$$$$$$%&&&&'''''' '!'"'#'$'%(&('((()(*(+(,(-(.(/(0(1(2(3(4(5(6(7(8(9(:(;(<(=(>(?)@)A*B*C*D*E*F*G*H*I*J*K*L*M*N*O*P*Q*R*S*T*U*V* Safe-Inferred:M First argument is a transformer for pattern strings, e.g. map toLower, but only applying to parts of the pattern not in quotation marks. (Needed to canonicalise HTML where tags are case-insensitive, but attribute values are case sensitive.) WXYZ[\] ^_`abcd       WXYZ[\] ^_`abcd Safe-Inferred:MSource positions contain a filename, line, column, and an inclusion point, which is itself another source position, recursively.ODummy value for generated data, where a true source position does not exist.posInNewCxt name pos creates a new source position from an old one. It is used when opening a new file (e.g. a DTD inclusion), to denote the start of the file nameJ, but retain the stacked information that it was included from the old pos.RJust used to strictify the internal values of a position, to avoid space leaks.0Add n character positions to the given position.+Add a newline or tab to the given position.+Add a newline or tab to the given position.FAdd the given whitespace char to the given position. Precondition: white c | isSpace c = True ef   ef Safe-Inferred:M%#The basic token type.$ lexical error% fake token&any character data'begins with letter, no spaces('' or ""),*%+|,)-(.#/;0&1+2*3?4=5]6[7 8<9/>:</;DOCTYPE ELEMENT ATTLIST etc<<!=CDATA INCLUDE IGNORE etc>]]>?<![@?>A<?B->C<!--D`All tokens are paired up with a source position. Lexical errors are passed back as a special TokenT value.EThe first argument to E is the filename (used for source positions, especially in error messages), and the second is the string content of the XML file.FF is used when the parser expands a macro (PE reference). The expansion of the macro must be re-lexed as if for the first time.GG1 is used solely within parsing an entityvalue. Normally, a PERef is logically separated from its surroundings by whitespace. But in an entityvalue, a PERef can be juxtaposed to an identifier, so the expansion forms a new identifier. Thus the need to rescan the whole text for possible PERefs.C !"#$%&'()*+,-./0123456789:;<=>?@ABCDghijklmnopEFGqrstuvwxyz/ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFG/EFGD#CBA@?>=<;:9876543210/.-,+*)('&%$"! "! # CBA@?>=<;:9876543210/.-,+*)('&%$DgihjklmnopEFGqrstuvwxyz Safe-Inferred:MJstring only (#PCDATA)Kmixed (#PCDATA | ... )*LXML's contentspec allows ANYONon-empty lists.QString holds default value.WBool for main/aux.X9Need to keep both the XML and Haskell versions of a name.Zoriginal XML name[mangled Haskell name]Pretty print Haskell name.^Pretty print XML name._%Pretty print Haskell attributes name.`/Make a type name valid in both XML and Haskell.a8Append an underscore to the Haskell version of the name.bNPrefix an attribute enumeration type name with its containing element name.chPrefix an attribute enumeration constructor with its element-tag name, and its enumeration type name.d4Prefix a field name with its enclosing element name.e'Convert an XML name to a Haskell conid.{FEnsure a generated name does not conflict with a standard haskell one.f'Convert an XML name to a Haskell varid.|-Convert colon to prime, hyphen to underscore.(HIJKLMNOPQRSTUVWXYZ[\}~]^_`abcde{f|HIJKLMNOPQRSTUVWXYZ[\]^_`abcdefUWVTSHRQPONMLKJI\]^_XYZ[`abcdefH RQPONMLKJISTUWVXYZ[\}~]^_`abcde{f| Safe-Inferred:Mg<Convert typedef to appropriate instance declaration, either  XmlContent,  XmlAttributes, or  XmlAttrType.gggg  Safe-Inferred:MyGNamespaces are not defined in the XML spec itself, but at http:/ www.w3.org TR/xml-names}GA QName is a (possibly) qualified name, in the sense of XML namespaces. One Or More Zero Or More Zero Or OneJust One)bool is whether whitespace is significant\The symbol table stored in a document holds all its general entity reference definitions.hijklmnopqrstuvwxyz{|}~hijklmnopqrstuvwxyz{|}~stqrnpolmjk}~yz{|xwvuihOhijklmnpoqrstuvwxyz{|}~  Safe-Inferred:M             Safe-Inferred:FM  'The null Namespace (no prefix, no URI). fEvery Name can be split into a Namespace and local Name. The Namespace might of course be missing.;Return the (possibly absent) Namespace component of a Name.<Return the local component of a Name, without its Namespace.eReturn the printable string for a Name, i.e. attaching a prefix for its namespace (if it has one).M splits a Name of the form "pr:nm" into the prefix "pr" and local name "nm", and looks up the prefix in the given environment to determine its Namespace. There may also be a default namespace (the first argument) for unqualified names. In the absence of a default Namespace, a Name that does not have a prefix remains unqualified. A prefix that is not known in the environment becomes a fresh namespace with null URI. A Name that is already qualified is passed unchanged, unless its URI was null, in which case we check afresh for that prefix in the environment. has the same signature as {, but ignores the arguments for default namespace and environment, and simply removes any pre-existing qualification. converts names to qualified names, except where an existing qualification matches the default namespace, in which case the qualification is removed. (This is useful when translating QNames to Haskell, because Haskell qualified names cannot use the current module name.)OThe initial Namespace environment. It always has bindings for the prefixes xml and xmlns.eAdd a fresh Namespace into the Namespace environment. It is not permitted to rebind the prefixes xml or xmlns", but that is not checked here.)resolveAllNames in a document, causes every name to be properly qualified with its namespace. There is a default namespace for any name that was originally unqualified. This is likely only useful when dealing with parsed document, less useful when generating a document from scratch.              Safe-Inferred:M*pA LabelFilter is like a CFilter except that it pairs up a polymorphic value (label) with each of its results.*Conjoin the two branches of a conditional.!All document transformations are content filters!. A filter takes a single XML $ value and returns a sequence of  values, possibly empty.>Throw away current node, keep just the (unprocessed) children. Select the n"'th positional result of a filter.%!For a mandatory attribute field,  find key cont- looks up the value of the attribute name key, and applies the continuation cont to the value.&+When an attribute field may be absent, use iffind key yes noE to lookup its value. If the attribute is absent, it acts as the no% filter, otherwise it applies the yes filter.' ifTxt yes no( processes any textual content with the yes- filter, but otherwise is the same as the no filter.(8Select between the two branches of a joined conditional.) Sequential (Irish, backwards ) composition*Binary parallel composition. Each filter uses a copy of the input, rather than one filter using the result of the other. (Has a more general type than just CFilter.)+oGlue a list of filters together. (A list version of union; also has a more general type than just CFilter.),A special form of filter composition where the second filter works over the same data as the first, but also uses the first's result.-)Process children using specified filters..Directional choice: in f |>| g, give g-productions only if no f-productions/ Pruning: in f / gG, keep only those f-productions which have at least one g-production0 Pruning: in f 0 g>, keep only those f-productions which have no g-productions1 Pronounced slash, f /> g means g inside f2 Pronounced outside, f </ g means f containing g37Join an element-matching filter with a text-only filter47Express a list of filters like an XPath query, e.g. Apath [children, tag "name1", attr "attr1", children, tag "name2"] is like the XPath query /name1[@attr1]/name2.8Interior editing: f 8 g applies f only when the predicate g1 succeeds, otherwise the content is unchanged.9Interior editing: g 9 f applies f only when the predicate g1 succeeds, otherwise the content is discarded.:Process CHildren In Place. The filter is applied to any children of an element content, and the element rebuilt around the results.;Process an element In Place. The filter is applied to the element itself, and then the original element rebuilt around the results.<Recursively process an element in place. That is, the filter is applied to the element itself, then recursively to the results of the filter, all the way to the bottom, then the original element rebuilt around the final results.=GRecursive application of filters: a fold-like operator. Defined as f ) chip (foldXml f).>fBuild an element with the given tag name - its content is the results of the given list of filters.?>Build an element with the given name, attributes, and content.@Build some textual content.ABuild some CDATA content.B4Rename an element tag (leaving attributes in place).C<Replace the attributes of an element (leaving tag the same).DrAdd the desired attribute name and value to the topmost element, without changing the element in any other way.EACompose a label-processing filter with a label-generating filter.FECombine labels. Think of this as a pair-wise zip on labels. e.g.  (numbered F tagged)G"Number the results from 1 upwards.HIn interspersed a f b, label each result of f with the string a?, except for the last one which is labelled with the string b.IfLabel each element in the result with its tag name. Non-element results get an empty string label.JLabel each element in the result with the value of the named attribute. Elements without the attribute, and non-element results, get an empty string label.KcLabel each textual part of the result with its text. Element results get an empty string label.L?Label each content with some information extracted from itself.6 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKL6 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKL6- !#$"%&')*+,./0123456789:;<=>?@ABCD(EFGHIJKL5 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKL ()*,./01289E None:MM9XParser is just a specialisation of the PolyState parser.NTo parse a whole document, xmlParse file content takes a filename (for generating error reports) and the string content of that file. A parse error causes program failure, with message to stderr.OTo parse just a DTD, dtdParse file contentz takes a filename (for generating error reports) and the string content of that file. If no DTD was found, you get Nothing^ rather than an error. However, if a DTD is found but contains errors, the program crashes.PTo parse a whole document, xmlParse' file content takes a filename (for generating error reports) and the string content of that file. Any parse error message is passed back to the caller through the Either type.QTo parse just a DTD, dtdParse' file contentz takes a filename (for generating error reports) and the string content of that file. If no DTD was found, you get  Right Nothing7. If a DTD was found but contains errors, you get a  Left message.RMTo parse a partial document, e.g. from an XML-based stream protocol, where you may later want to get more document elements from the same stream. Arguments are: a parser for the item you want, and the already-lexed input to parse from. Returns the item you wanted (or an error message), plus the remainder of the input.S2Some empty symbol tables for GE and PE references.WHReturn the next token from the input only if it matches the given token.XReturn a qualified name (although the namespace qualification is not processed here; this is merely to get the correct type).Y6Return just a name, e.g. element name, attribute name.ZAReturn an entire XML document including prolog and trailing junk.[Return an XML comment.\Parse a processing instruction.^(Return a DOCTYPE decl, indicating a DTD.4Return a DTD markup decl, e.g. ELEMENT, ATTLIST, etc_:Return a complete element including all its inner content.`>Parse only the parts between angle brackets in an element tag.aGFor use with stream parsers - returns the complete opening element tag.bcFor use with stream parsers - accepts a closing tag, provided it matches the given element name.c=Return a content particle, e.g. text, element, reference, etcdCReturn either a general entity reference, or a character reference.e3Return parsed freetext (i.e. until the next markup)]MNOPQRSTUVWXYZ[\]^_`abcdeMNOPQRSTUVWXYZ[\]^_`abcdeNPOQRZ_c[]ed^\`XYWabSMTUV]MNOPQRSTUVWXYZ[\]^_`abcde Safe-Inferred:M4fghijk      !"fghijkfjihgk4fghijk      !" Safe-Inferred:Mlmnopqrstuvwxyz{|}~lmnopqrstuvwxyz{|}~lmnopqrst}~uvwxyz{|lmnopqrstuvwxyz{|}~ Safe-Inferred:MThe first argument is the name of the file, the second is the string contents of the file. The result is the generic representation of an XML document. Any errors cause program failure with message to stderr.The first argument is the name of the file, the second is the string contents of the file. The result is the generic representation of an XML document. Any parsing errors are returned in the Either type.0#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOP0#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPNone:MThis useful auxiliary checks the commandline arguments for two filenames, the input and output file respectively. If either is missing, it is replaced by QC, which can be interpreted by the caller as stdin and/or stdout. The wrapper processXmlWith returns an IO () computation that collects the filenames (or stdin/stdout) to use when reading/writing XML documents. Its CFilter argument is applied to transform the XML document from the input and write it to the output. No DTD is attached to the output.If the input filename ends with .html or .htm, it is parsed using the error-correcting HTML parser rather than the strict XML parser. The wrapper  onContentn simply applies a given content filter to a document. Ambiguous or empty results raise an error exception.simons@cryp.to experimentalportable Safe-Inferred:M&This class promises that the function T knows how to format this data type into a string without changing the formatting.fThis is a helper function is required because Haskell does not allow to make an ordinary tuple (like x) an instance of a class. The resulting output will preface the actual attribute with a single blank so that lists of <s can be handled implicitly by the definition for lists of  data types.    Safe-Inferred:M@RSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~@RSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~TUV Safe-Inferred:MNone:MThe first argument is the name of the file, the second is the string contents of the file. The result is the generic representation of an XML document. Any errors cause program failure with message to stderr... Safe-Inferred:M11None:M=XParser is just a specialisation of the PolyStateLazy parser.To parse a whole document, xmlParse file content takes a filename (for generating error reports) and the string content of that file. A parse error causes program failure, with message to stderr.To parse just a DTD, dtdParse file contentz takes a filename (for generating error reports) and the string content of that file. If no DTD was found, you get Nothing^ rather than an error. However, if a DTD is found but contains errors, the program crashes.MTo parse a partial document, e.g. from an XML-based stream protocol, where you may later want to get more document elements from the same stream. Arguments are: a parser for the item you want, and the already-lexed input to parse from. Returns the item you wanted (or an error message), plus the remainder of the input.2Some empty symbol tables for GE and PE references.HReturn the next token from the input only if it matches the given token.Return a qualified name (although the namespace qualification is not processed here; this is merely to get the correct type).6Return just a name, e.g. element name, attribute name.AReturn an entire XML document including prolog and trailing junk.Return an XML comment.Parse a processing instruction.(Return a DOCTYPE decl, indicating a DTD.4Return a DTD markup decl, e.g. ELEMENT, ATTLIST, etc:Return a complete element including all its inner content.>Parse only the parts between angle brackets in an element tag.GFor use with stream parsers - returns the complete opening element tag.cFor use with stream parsers - accepts a closing tag, provided it matches the given element name.=Return a content particle, e.g. text, element, reference, etcCReturn either a general entity reference, or a character reference.3Return parsed freetext (i.e. until the next markup)[      !"#$%&'()*+,-./0[      !"#$%&'()*+,-./0None:M A reference occuredSome string data occured(An element without content occured (</>)An element was closed (</>)An element was opened (<>)A comment occured (<!-- -->)'A processing instruction occured (<??>))A doctype declaration occured(<!DOCTYPE>)saxParse file contentS takes a filename and the string content of that file and generates a stream of  SaxElementOs. If an error occurs, the parsing stops and a string is returned using the Maybe type. The filenameThe content of the file#A tuple of the parsed elements and Nothing, if no error occured, or Just String if an error occured.123456789   123456789 Safe-Inferred:M      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~~q}|{zyxwvutsrhijklmnop`ecafgfdgb^_YZ[\]XVWPQRSTULONMGKJIHABCDEF<=>?@789:;*+,-./0123456&'() !"#$%     0      !"#$%&'()* +,-./0123456789:;<=>?@ABCDEFGKJIHLONMPQRSTUVWXYZ[\]^_` ecafgfdgbhijklmnopq }|{zyxwvutsr~    Safe-Inferred:M A NameConverter is a collection of functions that convert an XName into an HName, for various Haskell namespaces. You can define your own arbitrary resolver, but should ensure that you abide by the Haskell rules for conid, varid, etc.for forward type declsAn HName is a resolved version of an XName. It should conform to the various namespace rules, and may already include a module qualifier if appropriate.An XName just holds the original XSD qualified name. It does not ensure that the string conforms to any rules of the various Haskell namespaces. Use a NameConverter to define how you would like names to be mangled.?A simple default set of rules for resolving XNames into HNames.7Character escapes to create a valid Haskell identifier.6Ensure that a string does not match a Haskell keyword.A specialised module-name converter for FpML module names with multiple dashes, including version numbers, e.g. fpml-dividend-swaps-4-7.xsd becomes FpML.V47.Swaps.Dividend but fpml-posttrade-execution-4-7.xsd becomes FpML.V47.PostTrade.ExecutionkChop a list into segments, at separators identified by the predicate. The separator items are discarded.>Remove any prefix directory names, and given suffix extension.  Safe-Inferred2:M|Ultimately, an XML parser will find some plain text as the content of a simpleType, which will need to be parsed. We use a TextParser, because values of simpleTypes can also be given elsewhere, e.g. as attribute values in an XSD definition, e.g. to restrict the permissible values of the simpleType. Such restrictions are therefore implemented as layered parsers.|     :;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~}~     W     }~T     :;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcde Safe-Inferred:MA concrete representation of any user-defined Haskell constructor. The constructor has a name, and a sequence of component types. The first sequence of types represents the minimum set of free type variables occurring in the (second) list of real component types. If there are fieldnames, they are contained in the final list, and correspond one-to-one with the component types..A concrete representation of any Haskell type.A user-defined type has a name, a sequence of type variables, and a set of constructors. (The variables might already be instantiated to actual types.)"separate Haskell name and XML name HTypeableW promises that we can create an explicit representation of of the type of any value.eProject the n'th constructor from an HType and convert it to a string suitable for an XML tagname.  ^ converts a concrete representation of the Haskell type of a value (obtained by the method ) into a real DocTypeDecl. It ensures that PERefs are defined before they are used, and that no element or attribute-list is declared more than once., ! !! $ ! Safe-Inferred:M"}The List1 type represents lists with at least one element. It is required for DTD content models that use + as a modifier.$YA type corresponding to XML's ANY contentspec. It is either a list of unconverted xml  or some 0 -able value.Parsing functions (e.g. 1) will always produce %. Note: The Show instance for % uses .'If an attribute is defaultable, then it either takes the default value (which is omitted from the output), or a non-default value (which obviously must be printed).*The  XmlAttrTypep class promises that an attribute taking an XML enumerated type can be converted to and from a Haskell value.-The  XmlAttributesb class promises that a list of XML tag attributes can be converted to and from a Haskell value.0The  XmlContent\ class promises that an XML Content element can be converted to and from a Haskell value.1Convert from XML to Haskell2Convert from Haskell to XML3'Dummy functions (for most types): used only@ in the Char instance for coercing lists of Char into String.5We need a parsing monad for reading generic XML Content into specific datatypes. This is a specialisation of the Text.ParserCombinators.Poly ones, where the input token type is fixed as XML Content.6'Read a single attribute called "value".7Generate a single attribute.8<Generate an element with no attributes, named for its HType.97Generate an element with no attributes, named directly.:#Turn a simple string into XML text.;JTurn a string into an XML CDATA section. (i.e. special characters like &' are preserved without interpretation.)<CThe most primitive combinator for XMLParser - get one content item.=Get the next content element, checking that it has one of the required tags, using the given matching function. (Skips over comments and whitespace, rejects text and refs. Also returns position of element.)>A specialisation of posnElementWith (==).?Get the next content element, checking that it has one of the required tags. (Skips over comments and whitespace, rejects text and refs.)@ELike element, only permits a more flexible match against the tagname.ARun an XMLParser on the contents of the given element (i.e. not on the current monadic content sequence), checking that the contents are exhausted, before returning the calculated value within the current parser context.B$A combination of element + interior.C(A combination of elementWith + interior.D6Do some parsing of the attributes of the given elementEE is a counterpart to ?T, parsing text content if it exists. Adjacent text and references are coalesced.Fn'choice f p' means if parseContents succeeds, apply f to the result, otherwise use the continuation parser.Gnot sure this is needed now. 'definite p' previously ensured that an element was definitely present. Now I think the monad might take care of that for us.E"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPfghijklmnopqrstuvwxyz{|}~st !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPCst01234-./*+,5<>?ABED=@CFG897:;HIJKLMN')(OP6"#$&%8"#$&%')(*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPNone:M QRRead an XML document from a file and convert it to a fully-typed Haskell value.RJWrite a fully-typed Haskell value to the given file as an XML document.SWrite any Haskell value to the given file as an XML document, using the FastPackedString interface (output will not be prettified).T.Read a fully-typed XML document from a string.U=Convert a fully-typed XML document to a string (without DTD).VAConvert a fully-typed XML document to a ByteString (without DTD).WEConvert a fully-typed XML document to a string (with or without DTD).X~Read a Haskell value from an XML document, ignoring the DTD and using the Haskell result type to determine how to parse it.Y3Read a fully-typed XML document from a file handle.Z2Write a fully-typed XML document to a file handle.[{Write a fully-typed XML document to a file handle, using the FastPackedString interface (output will not be prettified).QRSTUVWXYZ[fghijklmnopqrstuvwxyz{|}~st !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[ WXTUVQRSYZ[QRSTUVWXYZ[None:M\\k takes a DTD and a tagged element, and returns a list of errors in the document with respect to its DTD.If you have several documents to validate against a single DTD, then you will gain efficiency by freezing-in the DTD through partial application, e.g. checkMyDTD = validate myDTD.]]q is like validate, except that it does not check that the element type matches that of the DTD's root element.\]\]\] \]None:M?UEquivalent to the Either type, but using the regular naming scheme of this module.BgSomewhat of a nonsense - a choice of a single item. But sometimes it occurs in auto-generated code."^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVW"BC~D?A@}|E;>=<{zF6:987yxG054321wvH)/.-,+*utI!('&%$#"srJ qpKonL     mlMkjNihOgfPedQcbRa`S_^T]\Us~}|{zyxwvut[ZV^rqponmlkjihgfedcba`_YXWP^rqponmlkjihgfedcba`_s~}|{zyxwvut           !('&%$#")/.-,+*0543216:987;>=<?A@BCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ Safe-Inferred:M5We need a Parser monad for reading from a sequence of generic XML Contents into specific datatypes that model the structure of XSD descriptions. This is a specialisation of the polyparse combinators, fixing the input token type. Lift boolean  over predicates.0Qualify an ordinary name with the XSD namespace.Predicate for comparing against an XSD-qualified name. (Also accepts unqualified names, but this is probably a bit too lax. Doing it right would require checking to see whether the current schema module's default namespace is XSD or not.)1Get the next content element, checking that it matches some criterion given by the predicate. (Skips over comments and whitespace, rejects text and refs. Also returns position of element.) The list of strings argument is for error reporting - it usually represents a list of expected tags.fGet the next content element, checking that it has the required tag belonging to the XSD namespace.-Get the next content element, whatever it is.8Grab and parse any and all children of the next element.Run an XsdParser on the child contents of the given element (i.e. not in the current monadic content sequence), filtering the children before parsing, and checking that the contents are exhausted, before returning the calculated value within the current parser context.gCheck for the presence (and value) of an attribute in the given element. Absence results in failure.SGrab any attributes that declare a locally-used prefix for a specific namespace.@Predicate for whether an attribute belongs to a given namespace.Tidy up the parsing context.xGiven a URI for a targetNamespace, and a list of Namespaces, tell me the prefix corresponding to the targetNamespace.2An auxiliary you might expect to find in Data.ListTurn a qualified attribute value (two strings) into a qualified name (QName), but excluding the case where the namespace prefix corresponds to the targetNamespace of the current schema document.Parse a Schema declarationParse a (possibly missing)  xsd:annotation element.Parse a definitely-occurring  xsd:annotation element.Parse a FormDefault attribute.!Parse a Final or Block attribute.-Parse a schema item (just under the toplevel  xsd:schema) Parse an  xsd:include. Parse an  xsd:import.Parse a  xsd:redefine.Parse a  xsd:simpleType decl.Parse a  xsd:complexType decl.$Parse the alternative contents of a  xsd:complexType decl.Parse a particle decl./Parse a particle decl with optional attributes. Parse an  xsd:all,  xsd:choice, or  xsd:sequence decl.Parse a  xsd:group decl. Parse an  xsd:element,  xsd:group,  xsd:all,  xsd:choice,  xsd:sequence or  xsd:any. Parse an  xsd:any. Parse an  xsd:anyAttribute. Parse an  xsd:attributegroup. Parse an  xsd:element decl.Parse name and type attributes. Parse an  xsd:attribute decl.;Parse an occurrence range from attributes of given element.Parse a  xsd:unique,  xsd:key, or  xsd:keyref.Parse a  xsd:unique.Parse a  xsd:key.Parse a  xsd:keyref.Parse a  xsd:selector.Parse a  xsd:field.HText parser for a URI (very simple, non-validating, probably incorrect).KText parser for an arbitrary string consisting of possibly multiple tokens.:Parse a textual boolean, i.e. "true", "false", "0", or "1"KParse a "use" attribute value, i.e. "required", "optional", or "prohibited"EParse a "processContents" attribute, i.e. "skip", "lax", or "strict".0Parse an attribute value that should be a QName.6Parse an attribute value that should be a simple Name.9999  Safe-Inferred:MRestrictions on simpleTypeThere are essentially simple types, and complex types, each of which can be either restricted or extended. There are four kinds of complex type: choices, sequences, named groups, or a simple element with content.The whole Haskell module.HComments can be attached to most things, but not all of them will exist.2A helper for building the formal Module structure.77;! Safe-Inferred:MZVertically pretty-print a list of things, with open and close brackets, and separators.ZGenerate aligned haddock-style documentation. (but without escapes in comment text yet)Generate aligned haddock-style docs for choices (where each choice has its own documentation, but haddock cannot place it directly next to the appropriate component."Pretty-print a Haskell-style name.Pretty-print an XML-style name.2Some different ways of using a Haskell identifier. 2Some different ways of using a Haskell identifier. 2Some different ways of using a Haskell identifier. 2Some different ways of using a Haskell identifier. 2Some different ways of using a Haskell identifier. 2Some different ways of using a Haskell identifier.FConvert a whole document from HaskellTypeModel to Haskell source text./Generate a fragmentary parser for an attribute..Generate a fragmentary toXML for an attribute.-Generate a fragmentary parser for an element.kGenerate a fragmentary toXML for an element. Fragment must still be applied to an actual element value.?Convert multiple HaskellTypeModel Decls to Haskell source text.7Convert a single Haskell Decl into Haskell source text.IGenerate an instance of the Extension class for a subtype/supertype pair.}Generate an instance of the Extension class for a type and its "grand"-supertype, that is, the supertype of its supertype.3Generate named fields from elements and attributes.CGenerate a single named field (including type sig) from an element.<Generate a single named field (no type sig) from an element.DWhat is the name of the type for an Element (or choice of Elements)?0Generate a single named field from an attribute.<Generate a list or maybe type name (possibly parenthesised).,Generate a parser for a list or Maybe value.+Generate a toXML for a list or Maybe value.Eliminate a Maybe type modifier, when it occurs directly inside a choice construct (since a parsed Nothing would always be preferred over a real value later in the choice). Likewise, empty lists must be disallowed inside choice.Sometimes, a choice without a type modifier contains element sequences, all of which have the same modifier. In that case, it makes sense to lift the modifier (typically Maybe) to the outer layer.GSplit long lines of comment text into a paragraph with a maximum width.% !     "#$#!      "#$" Safe-Inferred:MZVertically pretty-print a list of things, with open and close brackets, and separators.ZGenerate aligned haddock-style documentation. (but without escapes in comment text yet)%"Pretty-print a Haskell-style name.&Pretty-print an XML-style name.'2Some different ways of using a Haskell identifier.(2Some different ways of using a Haskell identifier.)2Some different ways of using a Haskell identifier.*2Some different ways of using a Haskell identifier.+2Some different ways of using a Haskell identifier.,2Some different ways of using a Haskell identifier.FConvert a whole document from HaskellTypeModel to Haskell source text.-/Generate a fragmentary parser for an attribute..-Generate a fragmentary parser for an element.?Convert multiple HaskellTypeModel Decls to Haskell source text.7Convert a single Haskell Decl into Haskell source text./Instances that depend on FwdDecl'd types, need to be declared in a different module. So they have been separated out from ppHighLevelDecl.0IGenerate an instance of the Extension class for a subtype/supertype pair.1}Generate an instance of the Extension class for a type and its "grand"-supertype, that is, the supertype of its supertype.23Generate named fields from elements and attributes.3.Generate a single named field from an element.4DWhat is the name of the type for an Element (or choice of Elements)?50Generate a single named field from an attribute.6<Generate a list or maybe type name (possibly parenthesised).7,Generate a parser for a list or Maybe value.8GSplit long lines of comment text into a paragraph with a maximum width. 9:;%&'()*+,<=-./>012345678?9;:%&'()*+,<=-./>012345678?# Safe-Inferred:FM type definitions in scope)all type definitions, regardless of scopesupertype -> subtypessubstitution groupswhere type is defined*An empty environment of XSD type mappings.CCombine two environments (e.g. read from different interface files)?Build an environment of XSD type mappings from a schema module. $Find all direct module dependencies.     $ Safe-Inferred:FM Transform a Schema by lifting all locally-defined anonymous types to the top-level, naming them, and planting a referend at their original location. Given an environment of schema type mappings, and a schema module, create a bunch of Decls that describe the types in a more Haskell-friendly way.:Consolidate a Facet occurrence into a single Occurs value.7Find the supertype (if it exists) of a given type name.{Keep applying the function to transform the value, until it yields Nothing. Returns the sequence of transformed values.                    %None:M=Convert a fully-typed XML document to a string (without DTD).@EConvert a fully-typed XML document to a string (with or without DTD).AA@BCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~AA@BCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~& Safe-Inferred:MRGet the main element of the document so that you can apply CFilters directly. i/ is typically (posInNewCxt "filename" Nothing) dIf you know that your CFilter returns a tag, you can use this function to get the tagged Element.'None:M RRead an XML document from a file and convert it to a fully-typed Haskell value.JWrite a fully-typed Haskell value to the given file as an XML document.Write any Haskell value to the given file as an XML document, using the FastPackedString interface (output will not be prettified)..Read a fully-typed XML document from a string.=Convert a fully-typed XML document to a string (without DTD).AConvert a fully-typed XML document to a ByteString (without DTD). EConvert a fully-typed XML document to a string (with or without DTD).!~Read a Haskell value from an XML document, ignoring the DTD and using the Haskell result type to determine how to parse it."3Read a fully-typed XML document from a file handle.#2Write a fully-typed XML document to a file handle.${Write a fully-typed XML document to a file handle, using the FastPackedString interface (output will not be prettified). !"#$fghijklmnopqrstuvwxyz{|}~st !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOP !"#$  !"#$ !"#$( Safe-Inferred:M%<double content filter - takes document root + local subtree.&3lift an ordinary content filter to a double filter.'3lift an ordinary content filter to a double filter.(ddrop a double filter to an ordinary content filter. (permitting interior access to document root))drop a double filter to an ordinary content filter. (Where interior access to the document root is not needed, the retaining pointer to the outer element can be pruned away. ) is more space-efficient than ( in this situation.)*1lift a CFilter combinator to a DFilter combinator+1lift a CFilter combinator to a DFilter combinator,'lifted composition over double filters.-lifted choice.. lifted union./lifted predicates.0lifted predicates.1lifted unit and zero.2lifted unit and zero.%&'()*+,-./0123456789:;<=>%&'()*+,-./0123456789:;<=>%&'()*+,-./0123546789:;<>=%&'()*+,-./0123456789:;<=>) Safe-Inferred:M?To convert an Xtract query into an ordinary HaXml combinator expression. First arg is a tag-transformation function (e.g. map toLower) applied@SThe cool thing is that the Xtract command parser directly builds a higher-order % (see !Text.XML.HaXml.Xtract.CombinatorsF) which can be applied to an XML document without further ado. ( parseXtract. halts the program if a parse error is found.) parseXtract'0 returns error messages through the Either type.?@?@@??@*None268:M AThe  xsd:any' type. Parsing will always produce an UnconvertedANY.DA trick to enable forward-declaration of a type that will be defined properly in another module, higher in the dependency graph. fd# is a dummy type e.g. the empty  data FwdA, where a is the proper data A, not yet available.EA type t can restrict another type s, that is, t admits fewer values than s, but all the values t does admit also belong to the type s.G~A type t can extend another type s by the addition of extra elements and/or attributes. s is therefore the supertype of t.IA SchemaType promises to interconvert between a generic XML content tree and a Haskell value, according to the rules of XSD.LGiven a TextParser for a SimpleType, make it into an XMLParser, i.e. consuming textual XML content as input rather than a String.M|Between is a list parser that tries to ensure that any range specification (min and max elements) is obeyed when parsing.NGenerated parsers will use NO as a convenient wrapper to lift a SchemaAttribute parser into an XMLParser.P'Parse the textual part of mixed contentUFor a ComplexType that is an extension of a SimpleType, it is necessary to convert the value to XML first, then add in the extra attributes that constitute the extension.CABCDEFGHIJKLMNOPQRSTUufghijklmnopqrstuvwxyz{|}~5=>?AE^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWABCDEFGHIJKLMNOPQRSTU%IJKGHEFDNMLPACBO5>=?AEQRSTU=ACBDEFGHIJKLMNOPQRSTUNone:MVThe version of the library.Vhijklmnopqrstuvwxyz{|}~    !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLNOilmnopqrstuvwxyz{|}~\VVV+,-+,.+,/0123456789:;<=>?@=ABCDEFGHIJKLMNOPQRST9UVWXYZ[\]^_`abcdefghijklmnopqrst?uvwxyz{|}~                                                                                                                                                                          ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q rgsklptuvwxyz{|}~fgsklptglp[\]`abcdefghiklmnopqr-.z     || !"##$%&'()*++,-.//01234567889:;<=>?@ABCDEFGHIJKLMMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqqrstuvwxyz{||}~??Zyz~Lpl       !"#$%&'()*+,-./0123456789:;<=>/?@ABCDEFGHIJKLM?NOPQRSTUVWXYZ[N\]^_`abcdefgh\ijklmnopqrstiuvwxyz{|}~u      !"#$%&'f ( )   *    +   , - . /  0 1 } 2  3 4 5 6 7 8 9 : ; < = > ? @ #  A B C D E F G H I J J K L M N O  P!Q!R!S!T!U"Q"R"S"T"U#V#V#W#X#Y#Z#[#\#]#^#_#`#a#b#c#d$e$f$h$g$h$i$j$k$l$m$n%o&p&q&r&s'''''''''''(t(u(v(w(x(y(z(7(<(8(=(>()(*(+(-(.({(4(5(9(?(@(C(D(E)|)}*~******+**************GHIJ>                                       #              s             t                                !"#    q$%rjf&'()*+,ef#ghijskl-./0pmqr3123456789:; !"<    q$%rjf=&>?f@AB'(*+,ef#ghijskl-./0pmqrsk !"t    q$%rf#jst     CDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvw3xy3xz3x{3x|3x}3x~3x3x3x3x3x3x3x3x3x3x3x3x3x3x3x3x3x3x3x3x3x33 N     f3!!!!!!!!!!!!!!!!! !!!"!#!$!%!&!'!(!)!*!+!,!-!.!/"""""""""""0"""" """#"$"%")"*"+","-"."1"/%2%3%%5%8%6%3%4%:%%%;%%%g%s%%%%k%%l% %!%"%<%%p%%%t%%%%%%% % % % %q%$%%%%%%%%%%%%%%%%%%%r%j%f%&'4''5'''6'7'8'9':);)[)<)#)=)>)?)@))A)B)C)D)E)F)G)H)I)J)K)L)M)N)O)P)Q)R*S*T*U*V*W*X*Y*Z*[*\*]*^*_*`*a*b*c*d*e*f*g*h*i*j*k*l*m*n*o*p*q*r*s*t*u*v*w*x*y*z*{*|*}*~** HaXml-1.25.3$Text.XML.HaXml.Schema.PrimitiveTypes Text.XML.HaXml.XmlContent.ParserText.XML.HaXmlText.XML.HaXml.Xtract.LexText.XML.HaXml.PosnText.XML.HaXml.Lex#Text.XML.HaXml.DtdToHaskell.TypeDef$Text.XML.HaXml.DtdToHaskell.InstanceText.XML.HaXml.TypesText.XML.HaXml.EscapeText.XML.HaXml.NamespacesText.XML.HaXml.CombinatorsText.XML.HaXml.ParseText.XML.HaXml.PrettyText.XML.HaXml.Html.GenerateText.XML.HaXml.Html.ParseText.XML.HaXml.WrappersText.XML.HaXml.VerbatimText.XML.HaXml.ByteStringPP#Text.XML.HaXml.DtdToHaskell.ConvertText.XML.HaXml.Html.ParseLazyText.XML.HaXml.Html.PrettyText.XML.HaXml.ParseLazyText.XML.HaXml.SAX"Text.XML.HaXml.Schema.XSDTypeModel$Text.XML.HaXml.Schema.NameConversionText.XML.HaXml.TypeMappingText.XML.HaXml.XmlContentText.XML.HaXml.ValidateText.XML.HaXml.OneOfNText.XML.HaXml.Schema.Parse&Text.XML.HaXml.Schema.HaskellTypeModel#Text.XML.HaXml.Schema.PrettyHaskell"Text.XML.HaXml.Schema.PrettyHsBoot!Text.XML.HaXml.Schema.Environment$Text.XML.HaXml.Schema.TypeConversionText.XML.HaXml.ShowXmlLazyText.XML.HaXml.Util!Text.XML.HaXml.XmlContent.Haskell!Text.XML.HaXml.Xtract.CombinatorsText.XML.HaXml.Xtract.ParseText.XML.HaXml.Schema.Schemaghc-prim GHC.TypesDoubleFloatInt integer-gmpGHC.Integer.TypeIntegerbase Data.Maybe catMaybespretty-1.1.1.1Text.PrettyPrint.HughesPJrenderTokenTTokNum TokStringSymbolPosnPnToken lexXtract posnFilenameposnLine posnColumnnoPos posInNewCxtforcepaddcolnewlinetabwhiteSectionIGNORExINCLUDExCDATAxSpecial NOTATIONxENTITYxATTLISTxELEMENTxDOCTYPExTokErrorTokNull TokFreeTextTokNameTokQuoteTokComma TokPercentTokPipe TokBraClose TokBraOpenTokHashTokSemiTokAmpTokPlusTokStarTokQueryTokEqual TokSqClose TokSqOpen TokAnyClose TokAnyOpen TokEndClose TokEndOpen TokSpecialTokSpecialOpen TokSectionTokSectionCloseTokSectionOpen TokPIClose TokPIOpenTokCommentCloseTokCommentOpenxmlLexxmlReLexreLexEntityValue StructTypeDefinedString StringMixedAnyOneOfTupleList1List DefaultableMaybe AttrFields ConstructorsTypeDefEnumDefDataDefNamexNamehName ppTypeDefppHNameppXNameppANamenamename_name_aname_acname_fmanglemanglef mkInstanceCDSectCharData SystemLiteral PubidLiteralEVEVRefEVString EntityValueAttValueNmTokensNmTokenNames NamespacensPrefixnsURIQNameQNN EncodingDeclPublicIDPUBLICID NotationDeclNOTATIONExtPE ExtParsedEntTextDecl NDataDeclNDATA ExternalIDPUBLICSYSTEMPEDefPEDefExternalIDPEDefEntityValue EntityDef DefExternalIDDefEntityValuePEDeclGEDecl EntityDecl EntityPEDecl EntityGEDecl PEReferenceCharRef EntityRef ReferenceRefChar RefEntityIgnoreSectContentsIgnore IgnoreSect IncludeSectConditionalSectFIXED DefaultDecl DefaultToIMPLIEDREQUIRED Enumeration NotationTypeEnumeratedType TokenizedTypeNMTOKENSNMTOKENENTITIESENTITYIDREFSIDREFIDAttType StringTypeAttDef AttListDeclMixed PCDATAplusPCDATAModifierPlusStarQueryNoneCPSeqChoiceTagName ContentSpecANYEMPTY ElementDeclContentCMiscCRefCStringCElem AttributeElemTagElementElem ExtSubsetDeclExtConditionalSect ExtMarkupDecl ExtSubset MarkupDecl MarkupMiscNotationEntityAttList DocTypeDeclDTDPITargetComment VersionInfoSDDeclProcessingInstructionMiscPIXMLDeclPrologDocumentSymTabemptySTaddSTlookupSTinfo XmlEscaper xmlEscapexmlEscapeContent xmlUnEscapexmlUnEscapeContent stdXmlEscaper mkXmlEscaper nullNamespace expandedName namespaceName localName printableNamequalify deQualifyqualifyExceptLocalinitNamespaceEnvaugmentNamespaceEnvresolveAllNames LabelFilterThenElse:>CFilterkeepnonechildrenpositionelmtxttagtagWithattrattrvalfindiffindifTxt?>ounioncatandThen childrenBy|>|withwithout/><+>$$hcathsepvcatsepfsepnest carryscantoWord8RecordRmkData mkAttrDef mkAttrField parseStreamsaxsaxelementopensaxelementclose saxcomment saxchardata saxreferencesaxdoctypedeclsaxprocessinginstructionisNext$fSimpleTypePositiveInteger$fSimpleTypeUnsignedByte$fSimpleTypeUnsignedShort$fSimpleTypeUnsignedInt$fSimpleTypeUnsignedLong$fSimpleTypeNonNegativeInteger$fSimpleTypeByte$fSimpleTypeShort$fSimpleTypeInt$fSimpleTypeLong$fSimpleTypeNegativeInteger$fSimpleTypeNonPositiveInteger$fSimpleTypeInteger$fSimpleTypeNMTOKENS$fSimpleTypeNMTOKEN$fSimpleTypeENTITIES$fSimpleTypeENTITY$fSimpleTypeIDREFS$fSimpleTypeIDREF$fSimpleTypeID$fSimpleTypeNCName$fSimpleTypeName$fSimpleTypeLanguage$fSimpleTypeToken$fSimpleTypeNormalizedString$fSimpleTypeGMonth$fSimpleTypeGDay$fSimpleTypeGMonthDay$fSimpleTypeGYear$fSimpleTypeGYearMonth$fSimpleTypeDate$fSimpleTypeTime$fSimpleTypeDateTime$fSimpleTypeDuration$fSimpleTypeDouble$fSimpleTypeFloat$fSimpleTypeDecimal$fSimpleTypeNOTATION$fSimpleTypeAnyURI$fSimpleTypeHexBinary$fSimpleTypeBase64Binary$fSimpleTypeXsdString$fSimpleTypeBoolControl.Applicative<*>pure Alternative ApplicativeoptionalliftA3liftA2liftA<**><**>manysome<|>emptygetConstConst unwrapMonad WrapMonad WrappedMonad unwrapArrow WrapArrow WrappedArrow getZipListZipList Data.Functor<$>GHC.Base<$polyparse-1.11 Text.Parse allAsString parseLitChar parseFloatparseHexparseOctparseDecparseInt parseSigned constructorsfieldoptionalParensisWordreadsPrecByParsePrec readByParse parseByRead TextParser parseList parsePrecparseParse!Text.ParserCombinators.Poly.Plain runParser"Text.ParserCombinators.Poly.Parserreparse satisfyMsgsatisfyeofnextonFailPParser Text.ParserCombinators.Poly.Base manyFinally' manyFinallybracket bracketSepsepBy1sepBymany1uptoexactlyindentoneOf adjustErrBadfailBaddiscardapplyoneOf' adjustErrcommit Commitment PolyParse"Text.ParserCombinators.Poly.ResultSuccessFailure CommittedResult flatConstr outerHtExpr innerHtExpr constrHtExpr $fHTypeable[]$fHTypeableEither$fHTypeableMaybe$fHTypeable(,,,,,,,,,,,,,,)$fHTypeable(,,,,,,,,,,,,,)$fHTypeable(,,,,,,,,,,,,)$fHTypeable(,,,,,,,,,,,)$fHTypeable(,,,,,,,,,,)$fHTypeable(,,,,,,,,,)$fHTypeable(,,,,,,,,)$fHTypeable(,,,,,,,)$fHTypeable(,,,,,,)$fHTypeable(,,,,,)$fHTypeable(,,,,)$fHTypeable(,,,)$fHTypeable(,,)$fHTypeable(,) $fHTypeable()$fHTypeableChar$fHTypeableDouble$fHTypeableFloat$fHTypeableInteger$fHTypeableInt$fHTypeableBool $fEqHType searchMaybe$fXmlContentANYContent$fHTypeableANYContent$fXmlContentList1$fHTypeableList1$fEqANYContent$fShowANYContent$fXmlContent(,,,,,,,,,,,,,,)$fXmlContent(,,,,,,,,,,,,,)$fXmlContent(,,,,,,,,,,,,)$fXmlContent(,,,,,,,,,,,)$fXmlContent(,,,,,,,,,,)$fXmlContent(,,,,,,,,,)$fXmlContent(,,,,,,,,)$fXmlContent(,,,,,,,)$fXmlContent(,,,,,,)$fXmlContent(,,,,,)$fXmlContent(,,,,)$fXmlContent(,,,)$fXmlContent(,,)$fXmlContent(,)$fXmlContentMaybe$fXmlContent[]$fXmlContentChar SimpleDTDelementsrequiredidsidrefs simplifyDTDgivescpErrordisplay duplicatesGHC.ListorppCommentForChoiceppModIdppConIdppVarId ppUnqConId ppUnqVarId ppFwdConIdppAttr toXmlAttrppElem toXmlElem ppExtensionppSuperExtensionppFieldsppFieldElement ppFieldNameppElemTypeNameppFieldAttributeppTypeModifierppElemModifierxmlElemModifier cleanChoicesliftedElemModifier paragraphCommentPositionAfterBefore ppJoinConId ppFieldId uniqueifyppHighLevelInstancesppElementAbstractOfType toXmlLazyDoc$fXmlContentEither$fXmlContent()$fXmlContentDouble$fXmlContentFloat$fXmlContentInteger$fXmlContentInt$fXmlContentBool parseXtract'unescapenumbersymbolquotepamaquerytqueryxtagxquery tpredicate upredicate vpredicate tattribute uattribute vattribute wattributeiindex simpleindexrrange numberdollaridxcommaopnop$fSchemaTypePositiveInteger$fSchemaTypeUnsignedByte$fSchemaTypeUnsignedShort$fSchemaTypeUnsignedInt$fSchemaTypeUnsignedLong$fSchemaTypeNonNegativeInteger$fSchemaTypeByte$fSchemaTypeShort$fSchemaTypeInt$fSchemaTypeLong$fSchemaTypeNegativeInteger$fSchemaTypeNonPositiveInteger$fSchemaTypeInteger$fSchemaTypeNMTOKENS$fSchemaTypeNMTOKEN$fSchemaTypeENTITIES$fSchemaTypeENTITY$fSchemaTypeIDREFS$fSchemaTypeIDREF$fSchemaTypeID$fSchemaTypeNCName$fSchemaTypeName$fSchemaTypeLanguage$fSchemaTypeToken$fSchemaTypeNormalizedString$fSchemaTypeGMonth$fSchemaTypeGDay$fSchemaTypeGMonthDay$fSchemaTypeGYear$fSchemaTypeGYearMonth$fSchemaTypeDate$fSchemaTypeTime$fSchemaTypeDateTime$fSchemaTypeDuration$fSchemaTypeNOTATION$fSchemaTypeAnyURI$fSchemaTypeDouble$fSchemaTypeDecimal$fSchemaTypeFloat$fSchemaTypeHexBinary$fSchemaTypeBase64Binary$fSchemaTypeBool$fSchemaTypeXsdString$fSchemaTypeAnyElement$fEqAnyElement$fShowAnyElement