XQuery-40.ebnf Find Productions:X AbbreviatedStep AbsolutePathExpr AdditiveExpr AllowingEmpty AndExpr Annotation AnyArrayType AnyFunctionType AnyItemTest AnyMapType AnyNodeKindTest AnyRecordType AposAttrContentChar AposAttrValueContent AposStringLiteral Argument ArgumentList ArrayConstructor ArrayType ArrowExpr ArrowTarget AttributeName AttributeTest Axis AxisStep BaseURIDecl BinaryDigit BinaryDigits BinaryIntegerLiteral BoundarySpaceDecl BracedAction BracedSwitchCases BracedTypeswitchCases BracedURILiteral CDataSection CDataSectionContents CaseClause CastExpr CastTarget CastableExpr CatchClause Char CharRef ChoiceItemType Comment CommentContents CommentTest CommonContent CompAttrConstructor CompCommentConstructor CompDocConstructor CompElemConstructor CompNamespaceConstructor CompNodeNCName CompNodeName CompPIConstructor CompTextConstructor ComparisonExpr ComputedConstructor Constant ConstructionDecl ContextValueDecl CopyNamespacesDecl CountClause CurlyArrayConstructor CurrentVar DFPropertyName DecDigit DecimalFormatDecl DecimalLiteral DefaultCollationDecl DefaultNamespaceDecl Digits DirAttributeList DirAttributeValue DirCommentConstructor DirCommentContents DirElemConstructor DirElemConstructorDelimiter DirElemContent DirPIConstructor DirPIContents DirectConstructor DocumentTest DoubleLiteral DynamicFunctionCall EOF EQName ElementContentChar ElementName ElementTest EmptyOrderDecl EnclosedContentExpr EnclosedExpr EnumerationType Expr ExprSingle ExtendedFieldDeclaration ExtensibleFlag ExtensionExpr FLWORExpr FieldDeclaration FieldName FilterExpr FilterExprAM FinallyClause ForBinding ForClause ForEntryBinding ForEntryKeyBinding ForEntryValueBinding ForItemBinding ForMemberBinding FullStep FunctionBody FunctionCall FunctionDecl FunctionItemExpr FunctionSignature FunctionType GNodeType GeneralComp GeneralCompDelimiter GroupByClause GroupingSpec HexDigit HexDigits HexIntegerLiteral IfExpr Import InheritMode InitialClause InlineFunctionExpr InstanceofExpr IntegerLiteral IntermediateClause IntersectExceptExpr ItemType ItemTypeDecl JNodeType KeySpecifier KeywordArgument KeywordArguments LetArrayBinding LetBinding LetClause LetMapBinding LetSequenceBinding LetValueBinding LibraryModule Literal LocalPart Lookup LookupExpr MainModule MapConstructor MapConstructorEntry MapType MappingArrowTarget MarkedNCName MethodCall Module ModuleDecl ModuleImport MultiplicativeExpr NCName NCName NCNameDelimiter Name NameChar NameStartChar NameTest NameTestUnion NamedFunctionRef NamedRecordTypeDecl NamespaceDecl NamespaceNodeTest NextVar NodeComp NodeConstructor NodeFollows NodeKindTest NodePrecedes NodeTest NumericLiteral NumericLiteralDelimiter OccurrenceIndicator OptionDecl OrExpr OrderByClause OrderModifier OrderSpec OrderedExpr OrderingModeDecl OtherwiseExpr PITarget PITest ParamList ParamListWithDefaults ParamWithDefault ParenthesizedExpr PathExpr PipelineExpr PositionalArgumentList PositionalArguments PositionalVar PostfixExpr Pragma PragmaContents PredefinedEntityRef Predicate Prefix PrefixedName PreserveMode PreviousVar PrimaryExpr Prolog QName QName QNameLiteral QNameOrKeywordDelimiter QuantifiedExpr QuantifierBinding QueryBody QuotAttrContentChar QuotAttrValueContent QuotStringLiteral RangeExpr RecordType RegularItemType RelativePathExpr ReservedName RestrictedDynamicCall ReturnClause S SchemaAttributeTest SchemaElementTest SchemaImport SchemaPrefix Selector SequenceArrowTarget SequenceType SequenceTypeUnion Setter SimpleMapExpr SimpleNodeTest SlidingWindowClause SquareArrayConstructor StepExpr StringConcatExpr StringConstructor StringConstructorChars StringConstructorContent StringInterpolation StringLiteral StringTemplate StringTemplateFixedPart StringTemplateVariablePart SwitchCaseClause SwitchCaseOperand SwitchCases SwitchComparand SwitchExpr TextTest TreatExpr TryCatchExpr TryClause TumblingWindowClause TypeDeclaration TypeName TypeTest TypedArrayType TypedFunctionParam TypedFunctionType TypedMapType TypedRecordType TypeswitchCases TypeswitchExpr URILiteral URIQualifiedName UnaryExpr UnaryLookup UnbracedActions UnionExpr UnionNodeTest UnorderedExpr UnprefixedName UnreservedFunctionEQName UnreservedFunctionQName UnreservedNCName UnreservedName UnreservedQName ValidateExpr ValidationMode ValueComp ValueExpr VarDecl VarDefaultValue VarName VarNameAndType VarRef VarValue VersionDecl WhereClause WhileClause Whitespace Wildcard WindowClause WindowEndCondition WindowStartCondition WindowVars var filter = document.getElementById("the-filter"), // search box list = document.querySelectorAll("#the-list li"); // all list items update=function(){ let search = filter.value.toLowerCase(); for (let i of list) { let item = i.innerHTML.toLowerCase(); if (item.indexOf(search) == -1) { i.classList.add("hide"); } else { i.classList.remove("hide"); } } }; window.addEventListener("load", () => {filter.onkeyup =update;}); var details = document.getElementById("the-details"), // form document.addEventListener('click', function(e){ if(!details.contains(e.target)){ details.removeAttribute('open') } })

Module:

VersionDecl LibraryModule MainModule EOF

no references


VersionDecl:

xquery encoding version StringLiteral encoding StringLiteral ;

         ::= 'xquery' ( 'encoding' | 'version' ( StringLiteral 'encoding' )? ) StringLiteral ';'

referenced by:


LibraryModule:

ModuleDecl Prolog

         ::= ModuleDecl Prolog

referenced by:


ModuleDecl:

module namespace NCName = URILiteral ;

         ::= 'module' 'namespace' NCName '=' URILiteral ';'

referenced by:


NCName:

UnreservedNCName NaN allowing ancestor ancestor-or-self and array as ascending at attribute base-uri boundary-space by case cast castable catch child collation comment construction context copy-namespaces count decimal-format decimal-separator declare default descendant descendant-or-self descending digit div document document-node element else empty empty-sequence encoding end enum eq every except exponent-separator external false finally fixed fn following following-or-self following-sibling following-sibling-or-self follows follows-or-is for function ge get gnode greatest group grouping-separator gt idiv if import in infinity inherit instance intersect is is-not item jnode key lax le least let lt map member minus-sign mod module namespace namespace-node ne next no-inherit no-preserve node of only option or order ordered ordering otherwise parent pattern-separator per-mille percent precedes precedes-or-is preceding preceding-or-self preceding-sibling preceding-sibling-or-self preserve previous processing-instruction record return satisfies schema schema-attribute schema-element self sliding some stable start strict strip switch text then to treat true try tumbling type typeswitch union unordered validate value variable version when where while window xquery zero-digit

           | 'NaN'
           | 'allowing'
           | 'ancestor'
           | 'ancestor-or-self'
           | 'and'
           | 'array'
           | 'as'
           | 'ascending'
           | 'at'
           | 'attribute'
           | 'base-uri'
           | 'boundary-space'
           | 'by'
           | 'case'
           | 'cast'
           | 'castable'
           | 'catch'
           | 'child'
           | 'collation'
           | 'comment'
           | 'construction'
           | 'context'
           | 'copy-namespaces'
           | 'count'
           | 'decimal-format'
           | 'decimal-separator'
           | 'declare'
           | 'default'
           | 'descendant'
           | 'descendant-or-self'
           | 'descending'
           | 'digit'
           | 'div'
           | 'document'
           | 'document-node'
           | 'element'
           | 'else'
           | 'empty'
           | 'empty-sequence'
           | 'encoding'
           | 'end'
           | 'enum'
           | 'eq'
           | 'every'
           | 'except'
           | 'exponent-separator'
           | 'external'
           | 'false'
           | 'finally'
           | 'fixed'
           | 'fn'
           | 'following'
           | 'following-or-self'
           | 'following-sibling'
           | 'following-sibling-or-self'
           | 'follows'
           | 'follows-or-is'
           | 'for'
           | 'function'
           | 'ge'
           | 'get'
           | 'gnode'
           | 'greatest'
           | 'group'
           | 'grouping-separator'
           | 'gt'
           | 'idiv'
           | 'if'
           | 'import'
           | 'in'
           | 'infinity'
           | 'inherit'
           | 'instance'
           | 'intersect'
           | 'is'
           | 'is-not'
           | 'item'
           | 'jnode'
           | 'key'
           | 'lax'
           | 'le'
           | 'least'
           | 'let'
           | 'lt'
           | 'map'
           | 'member'
           | 'minus-sign'
           | 'mod'
           | 'module'
           | 'namespace'
           | 'namespace-node'
           | 'ne'
           | 'next'
           | 'no-inherit'
           | 'no-preserve'
           | 'node'
           | 'of'
           | 'only'
           | 'option'
           | 'or'
           | 'order'
           | 'ordered'
           | 'ordering'
           | 'otherwise'
           | 'parent'
           | 'pattern-separator'
           | 'per-mille'
           | 'percent'
           | 'precedes'
           | 'precedes-or-is'
           | 'preceding'
           | 'preceding-or-self'
           | 'preceding-sibling'
           | 'preceding-sibling-or-self'
           | 'preserve'
           | 'previous'
           | 'processing-instruction'
           | 'record'
           | 'return'
           | 'satisfies'
           | 'schema'
           | 'schema-attribute'
           | 'schema-element'
           | 'self'
           | 'sliding'
           | 'some'
           | 'stable'
           | 'start'
           | 'strict'
           | 'strip'
           | 'switch'
           | 'text'
           | 'then'
           | 'to'
           | 'treat'
           | 'true'
           | 'try'
           | 'tumbling'
           | 'type'
           | 'typeswitch'
           | 'union'
           | 'unordered'
           | 'validate'
           | 'value'
           | 'variable'
           | 'version'
           | 'when'
           | 'where'
           | 'while'
           | 'window'
           | 'xquery'
           | 'zero-digit'

referenced by:


URILiteral:

StringLiteral

         ::= StringLiteral

referenced by:


Prolog:

DefaultNamespaceDecl Setter NamespaceDecl Import ; ContextValueDecl VarDecl FunctionDecl ItemTypeDecl NamedRecordTypeDecl OptionDecl ;

referenced by:


DefaultNamespaceDecl:

declare fixed default element function namespace URILiteral

         ::= 'declare' 'fixed'? 'default' ( 'element' | 'function' ) 'namespace' URILiteral

referenced by:


Setter:

BoundarySpaceDecl DefaultCollationDecl BaseURIDecl ConstructionDecl OrderingModeDecl EmptyOrderDecl CopyNamespacesDecl DecimalFormatDecl

           | DefaultCollationDecl
           | BaseURIDecl
           | ConstructionDecl
           | OrderingModeDecl
           | EmptyOrderDecl
           | CopyNamespacesDecl
           | DecimalFormatDecl

referenced by:


BoundarySpaceDecl:

declare boundary-space preserve strip

         ::= 'declare' 'boundary-space' ( 'preserve' | 'strip' )

referenced by:


DefaultCollationDecl:

declare default collation URILiteral

         ::= 'declare' 'default' 'collation' URILiteral

referenced by:


BaseURIDecl:

declare base-uri URILiteral

         ::= 'declare' 'base-uri' URILiteral

referenced by:


ConstructionDecl:

declare construction strip preserve

         ::= 'declare' 'construction' ( 'strip' | 'preserve' )

referenced by:


OrderingModeDecl:

declare ordering ordered unordered

         ::= 'declare' 'ordering' ( 'ordered' | 'unordered' )

referenced by:


EmptyOrderDecl:

declare default order empty greatest least

         ::= 'declare' 'default' 'order' 'empty' ( 'greatest' | 'least' )

referenced by:


CopyNamespacesDecl:

declare copy-namespaces PreserveMode , InheritMode

         ::= 'declare' 'copy-namespaces' PreserveMode ',' InheritMode

referenced by:


PreserveMode:

preserve no-preserve

         ::= 'preserve'
           | 'no-preserve'

referenced by:


InheritMode:

inherit no-inherit

         ::= 'inherit'
           | 'no-inherit'

referenced by:


DecimalFormatDecl:

declare decimal-format EQName default decimal-format DFPropertyName = StringLiteral

         ::= 'declare' ( 'decimal-format' EQName | 'default' 'decimal-format' ) ( DFPropertyName '=' StringLiteral )*

referenced by:


EQName:

QName URIQualifiedName

EQName   ::= QName
           | URIQualifiedName

referenced by:


QName:

UnreservedFunctionQName attribute comment document-node element namespace-node node processing-instruction schema-attribute schema-element text array enum fn function gnode get if item jnode map record switch type typeswitch

           | 'attribute'
           | 'comment'
           | 'document-node'
           | 'element'
           | 'namespace-node'
           | 'node'
           | 'processing-instruction'
           | 'schema-attribute'
           | 'schema-element'
           | 'text'
           | 'array'
           | 'enum'
           | 'fn'
           | 'function'
           | 'gnode'
           | 'get'
           | 'if'
           | 'item'
           | 'jnode'
           | 'map'
           | 'record'
           | 'switch'
           | 'type'
           | 'typeswitch'

referenced by:


UnreservedFunctionQName:

UnreservedQName NaN allowing ancestor ancestor-or-self and as ascending at base-uri boundary-space by case cast castable catch child collation construction context copy-namespaces count decimal-format decimal-separator declare default descendant descendant-or-self descending digit div document else empty empty-sequence encoding end eq every except exponent-separator external false finally fixed following following-or-self following-sibling following-sibling-or-self follows follows-or-is for ge greatest group grouping-separator gt idiv import in infinity inherit instance intersect is is-not key lax le least let lt member minus-sign mod module namespace ne next no-inherit no-preserve of only option or order ordered ordering otherwise parent pattern-separator per-mille percent precedes precedes-or-is preceding preceding-or-self preceding-sibling preceding-sibling-or-self preserve previous return satisfies schema self sliding some stable start strict strip then to treat true try tumbling union unordered validate value variable version when where while window xquery zero-digit

         ::= UnreservedQName
           | 'NaN'
           | 'allowing'
           | 'ancestor'
           | 'ancestor-or-self'
           | 'and'
           | 'as'
           | 'ascending'
           | 'at'
           | 'base-uri'
           | 'boundary-space'
           | 'by'
           | 'case'
           | 'cast'
           | 'castable'
           | 'catch'
           | 'child'
           | 'collation'
           | 'construction'
           | 'context'
           | 'copy-namespaces'
           | 'count'
           | 'decimal-format'
           | 'decimal-separator'
           | 'declare'
           | 'default'
           | 'descendant'
           | 'descendant-or-self'
           | 'descending'
           | 'digit'
           | 'div'
           | 'document'
           | 'else'
           | 'empty'
           | 'empty-sequence'
           | 'encoding'
           | 'end'
           | 'eq'
           | 'every'
           | 'except'
           | 'exponent-separator'
           | 'external'
           | 'false'
           | 'finally'
           | 'fixed'
           | 'following'
           | 'following-or-self'
           | 'following-sibling'
           | 'following-sibling-or-self'
           | 'follows'
           | 'follows-or-is'
           | 'for'
           | 'ge'
           | 'greatest'
           | 'group'
           | 'grouping-separator'
           | 'gt'
           | 'idiv'
           | 'import'
           | 'in'
           | 'infinity'
           | 'inherit'
           | 'instance'
           | 'intersect'
           | 'is'
           | 'is-not'
           | 'key'
           | 'lax'
           | 'le'
           | 'least'
           | 'let'
           | 'lt'
           | 'member'
           | 'minus-sign'
           | 'mod'
           | 'module'
           | 'namespace'
           | 'ne'
           | 'next'
           | 'no-inherit'
           | 'no-preserve'
           | 'of'
           | 'only'
           | 'option'
           | 'or'
           | 'order'
           | 'ordered'
           | 'ordering'
           | 'otherwise'
           | 'parent'
           | 'pattern-separator'
           | 'per-mille'
           | 'percent'
           | 'precedes'
           | 'precedes-or-is'
           | 'preceding'
           | 'preceding-or-self'
           | 'preceding-sibling'
           | 'preceding-sibling-or-self'
           | 'preserve'
           | 'previous'
           | 'return'
           | 'satisfies'
           | 'schema'
           | 'self'
           | 'sliding'
           | 'some'
           | 'stable'
           | 'start'
           | 'strict'
           | 'strip'
           | 'then'
           | 'to'
           | 'treat'
           | 'true'
           | 'try'
           | 'tumbling'
           | 'union'
           | 'unordered'
           | 'validate'
           | 'value'
           | 'variable'
           | 'version'
           | 'when'
           | 'where'
           | 'while'
           | 'window'
           | 'xquery'
           | 'zero-digit'

referenced by:


DFPropertyName:

decimal-separator grouping-separator infinity minus-sign NaN percent per-mille zero-digit digit pattern-separator exponent-separator

         ::= 'decimal-separator'
           | 'grouping-separator'
           | 'infinity'
           | 'minus-sign'
           | 'NaN'
           | 'percent'
           | 'per-mille'
           | 'zero-digit'
           | 'digit'
           | 'pattern-separator'
           | 'exponent-separator'

referenced by:


NamespaceDecl:

declare namespace NCName = URILiteral

         ::= 'declare' 'namespace' NCName '=' URILiteral

referenced by:


Import:

SchemaImport ModuleImport

           | ModuleImport

referenced by:


SchemaImport:

import schema SchemaPrefix URILiteral at URILiteral ,

         ::= 'import' 'schema' SchemaPrefix? URILiteral ( 'at' URILiteral ( ',' URILiteral )* )?

referenced by:


SchemaPrefix:

namespace NCName = fixed default element namespace

         ::= 'namespace' NCName '='
           | 'fixed'? 'default' 'element' 'namespace'

referenced by:


ModuleImport:

import module namespace NCName = URILiteral at URILiteral ,

         ::= 'import' 'module' ( 'namespace' NCName '=' )? URILiteral ( 'at' URILiteral ( ',' URILiteral )* )?

referenced by:


ContextValueDecl:

declare context value as SequenceType item as ItemType := VarValue external := VarDefaultValue

         ::= 'declare' 'context' ( 'value' ( 'as' SequenceType )? | 'item' ( 'as' ItemType )? ) ( ':=' VarValue | 'external' ( ':=' VarDefaultValue )? )

referenced by:


SequenceType:

empty-sequence ( ) ItemType OccurrenceIndicator

         ::= 'empty-sequence' '(' ')'
           | ItemType ( OccurrenceIndicator | )

referenced by:


ItemType:

RegularItemType FunctionType TypeName ChoiceItemType

           | FunctionType
           | TypeName
           | ChoiceItemType

referenced by:


RegularItemType:

AnyItemTest NodeKindTest GNodeType JNodeType MapType ArrayType RecordType EnumerationType

         ::= AnyItemTest
           | NodeKindTest
           | GNodeType
           | JNodeType
           | MapType
           | ArrayType
           | RecordType
           | EnumerationType

referenced by:


AnyItemTest:

item ( )

         ::= 'item' '(' ')'

referenced by:


NodeKindTest:

DocumentTest ElementTest AttributeTest SchemaElementTest SchemaAttributeTest PITest CommentTest TextTest NamespaceNodeTest AnyNodeKindTest

         ::= DocumentTest
           | ElementTest
           | AttributeTest
           | SchemaElementTest
           | SchemaAttributeTest
           | PITest
           | CommentTest
           | TextTest
           | NamespaceNodeTest
           | AnyNodeKindTest

referenced by:


DocumentTest:

document-node ( ElementTest SchemaElementTest NameTestUnion )

         ::= 'document-node' '(' ( ElementTest | SchemaElementTest | NameTestUnion )? ')'

referenced by:


ElementTest:

element ( NameTestUnion , TypeName ? )

         ::= 'element' '(' ( NameTestUnion ( ',' TypeName '?'? )? )? ')'

referenced by:


NameTestUnion:

NameTest |

         ::= NameTest ( '|' NameTest )*

referenced by:


NameTest:

EQName Wildcard

           | Wildcard

referenced by:


TypeName:

EQName

referenced by:


SchemaElementTest:

schema-element ( ElementName )

         ::= 'schema-element' '(' ElementName ')'

referenced by:


ElementName:

EQName

         ::= EQName

referenced by:


AttributeTest:

attribute ( NameTestUnion , TypeName )

         ::= 'attribute' '(' ( NameTestUnion ( ',' TypeName )? )? ')'

referenced by:


SchemaAttributeTest:

schema-attribute ( AttributeName )

         ::= 'schema-attribute' '(' AttributeName ')'

referenced by:


AttributeName:

EQName

         ::= EQName

referenced by:


PITest:

processing-instruction ( NCName StringLiteral )

PITest   ::= 'processing-instruction' '(' ( NCName | StringLiteral )? ')'

referenced by:


CommentTest:

comment ( )

         ::= 'comment' '(' ')'

referenced by:


TextTest:

text ( )

TextTest ::= 'text' '(' ')'

referenced by:


NamespaceNodeTest:

namespace-node ( )

         ::= 'namespace-node' '(' ')'

referenced by:


AnyNodeKindTest:

node ( )

         ::= 'node' '(' ')'

referenced by:


GNodeType:

gnode ( )

         ::= 'gnode' '(' ')'

referenced by:


JNodeType:

jnode ( SequenceType )

         ::= 'jnode' '(' SequenceType? ')'

referenced by:


MapType:

AnyMapType TypedMapType

           | TypedMapType

referenced by:


AnyMapType:

map ( * )

         ::= 'map' '(' '*' ')'

referenced by:


TypedMapType:

map ( ItemType , SequenceType )

         ::= 'map' '(' ItemType ',' SequenceType ')'

referenced by:


ArrayType:

AnyArrayType TypedArrayType

         ::= AnyArrayType
           | TypedArrayType

referenced by:


AnyArrayType:

array ( * )

         ::= 'array' '(' '*' ')'

referenced by:


TypedArrayType:

array ( SequenceType )

         ::= 'array' '(' SequenceType ')'

referenced by:


RecordType:

AnyRecordType TypedRecordType

         ::= AnyRecordType
           | TypedRecordType

referenced by:


AnyRecordType:

record ( * )

         ::= 'record' '(' '*' ')'

referenced by:


TypedRecordType:

record ( FieldDeclaration , ExtensibleFlag )

         ::= 'record' '(' ( FieldDeclaration ( ',' FieldDeclaration )* )? ExtensibleFlag? ')'

referenced by:


FieldDeclaration:

FieldName ? as SequenceType

         ::= FieldName '?'? ( 'as' SequenceType )?

referenced by:


FieldName:

NCName StringLiteral

         ::= NCName
           | StringLiteral

referenced by:


ExtensibleFlag:

, *

         ::= ',' '*'

referenced by:


EnumerationType:

enum ( StringLiteral , )

         ::= 'enum' '(' StringLiteral ( ',' StringLiteral )* ')'

referenced by:


FunctionType:

Annotation AnyFunctionType TypedFunctionType

         ::= Annotation* ( AnyFunctionType | TypedFunctionType )

referenced by:


Annotation:

% EQName ( Constant , )

         ::= '%' EQName ( '(' Constant ( ',' Constant )* ')' )?

referenced by:


Constant:

StringLiteral - NumericLiteral QNameLiteral true false ( )

           | '-'? NumericLiteral
           | QNameLiteral
           | ( 'true' | 'false' ) '(' ')'

referenced by:


NumericLiteral:

IntegerLiteral HexIntegerLiteral BinaryIntegerLiteral DecimalLiteral DoubleLiteral

         ::= IntegerLiteral
           | HexIntegerLiteral
           | BinaryIntegerLiteral
           | DecimalLiteral
           | DoubleLiteral

referenced by:


QNameLiteral:

# EQName

         ::= '#' EQName

referenced by:


AnyFunctionType:

function fn ( * )

         ::= ( 'function' | 'fn' ) '(' '*' ')'

referenced by:


TypedFunctionType:

function fn ( TypedFunctionParam , ) as SequenceType

         ::= ( 'function' | 'fn' ) '(' ( TypedFunctionParam ( ',' TypedFunctionParam )* )? ')' 'as' SequenceType

referenced by:


TypedFunctionParam:

$ EQName as SequenceType

         ::= ( '$' EQName 'as' )? SequenceType

referenced by:


ChoiceItemType:

( ItemType | )

         ::= '(' ItemType ( '|' ItemType )* ')'

referenced by:


OccurrenceIndicator:

? * +

         ::= '?'
           | '*'
           | '+'

referenced by:


VarValue:

ExprSingle

referenced by:


ExprSingle:

FLWORExpr QuantifiedExpr SwitchExpr TypeswitchExpr IfExpr TryCatchExpr OrExpr

         ::= FLWORExpr
           | QuantifiedExpr
           | SwitchExpr
           | TypeswitchExpr
           | IfExpr
           | TryCatchExpr
           | OrExpr

referenced by:


FLWORExpr:

InitialClause IntermediateClause ReturnClause

referenced by:


InitialClause:

ForClause LetClause WindowClause

         ::= ForClause
           | LetClause
           | WindowClause

referenced by:


ForClause:

for ForBinding ,

         ::= 'for' ForBinding ( ',' ForBinding )*

referenced by:


ForBinding:

ForItemBinding ForMemberBinding ForEntryBinding

         ::= ForItemBinding
           | ForMemberBinding
           | ForEntryBinding

referenced by:


ForItemBinding:

VarNameAndType AllowingEmpty PositionalVar in ExprSingle

referenced by:


VarNameAndType:

$ EQName TypeDeclaration

         ::= '$' EQName TypeDeclaration?

referenced by:


TypeDeclaration:

as SequenceType

         ::= 'as' SequenceType

referenced by:


AllowingEmpty:

allowing empty

         ::= 'allowing' 'empty'

referenced by:


PositionalVar:

at VarName

         ::= 'at' VarName

referenced by:


VarName:

$ EQName

VarName  ::= '$' EQName

referenced by:


ForMemberBinding:

member VarNameAndType PositionalVar in ExprSingle

         ::= 'member' VarNameAndType PositionalVar? 'in' ExprSingle

referenced by:


ForEntryBinding:

ForEntryKeyBinding ForEntryValueBinding ForEntryValueBinding PositionalVar in ExprSingle

referenced by:


ForEntryKeyBinding:

key VarNameAndType

         ::= 'key' VarNameAndType

referenced by:


ForEntryValueBinding:

value VarNameAndType

         ::= 'value' VarNameAndType

referenced by:


LetClause:

let LetBinding ,

         ::= 'let' LetBinding ( ',' LetBinding )*

referenced by:


LetBinding:

LetValueBinding LetSequenceBinding LetArrayBinding LetMapBinding

         ::= LetValueBinding
           | LetSequenceBinding
           | LetArrayBinding
           | LetMapBinding

referenced by:


LetValueBinding:

VarNameAndType := ExprSingle

         ::= VarNameAndType ':=' ExprSingle

referenced by:


LetSequenceBinding:

$ ( VarNameAndType , ) TypeDeclaration := ExprSingle

         ::= '$' '(' VarNameAndType ( ',' VarNameAndType )* ')' TypeDeclaration? ':=' ExprSingle

referenced by:


LetArrayBinding:

$ [ VarNameAndType , ] TypeDeclaration := ExprSingle

         ::= '$' '[' VarNameAndType ( ',' VarNameAndType )* ']' TypeDeclaration? ':=' ExprSingle

referenced by:


LetMapBinding:

$ { VarNameAndType , } TypeDeclaration := ExprSingle

         ::= '$' '{' VarNameAndType ( ',' VarNameAndType )* '}' TypeDeclaration? ':=' ExprSingle

referenced by:


WindowClause:

for TumblingWindowClause SlidingWindowClause

         ::= 'for' ( TumblingWindowClause | SlidingWindowClause )

referenced by:


TumblingWindowClause:

tumbling window VarNameAndType in ExprSingle WindowStartCondition WindowEndCondition

         ::= 'tumbling' 'window' VarNameAndType 'in' ExprSingle WindowStartCondition? WindowEndCondition?

referenced by:


WindowStartCondition:

start WindowVars when ExprSingle

         ::= 'start' WindowVars ( 'when' ExprSingle )?

referenced by:


WindowVars:

CurrentVar PositionalVar PreviousVar NextVar

         ::= CurrentVar? PositionalVar? PreviousVar? NextVar?

referenced by:


CurrentVar:

VarName

         ::= VarName

referenced by:


PreviousVar:

previous VarName

         ::= 'previous' VarName

referenced by:


NextVar:

next VarName

NextVar  ::= 'next' VarName

referenced by:


WindowEndCondition:

only end WindowVars when ExprSingle

         ::= 'only'? 'end' WindowVars ( 'when' ExprSingle )?

referenced by:


SlidingWindowClause:

sliding window VarNameAndType in ExprSingle WindowStartCondition WindowEndCondition

         ::= 'sliding' 'window' VarNameAndType 'in' ExprSingle WindowStartCondition? WindowEndCondition

referenced by:


IntermediateClause:

InitialClause WhereClause WhileClause GroupByClause OrderByClause CountClause

         ::= InitialClause
           | WhereClause
           | WhileClause
           | GroupByClause
           | OrderByClause
           | CountClause

referenced by:


WhereClause:

where ExprSingle

         ::= 'where' ExprSingle

referenced by:


WhileClause:

while ExprSingle

         ::= 'while' ExprSingle

referenced by:


GroupByClause:

group by GroupingSpec ,

         ::= 'group' 'by' GroupingSpec ( ',' GroupingSpec )*

referenced by:


GroupingSpec:

VarName TypeDeclaration := ExprSingle collation URILiteral

         ::= VarName ( TypeDeclaration? ':=' ExprSingle )? ( 'collation' URILiteral )?

referenced by:


OrderByClause:

stable order by OrderSpec ,

         ::= 'stable'? 'order' 'by' OrderSpec ( ',' OrderSpec )*

referenced by:


OrderSpec:

ExprSingle OrderModifier

         ::= ExprSingle OrderModifier

referenced by:


OrderModifier:

ascending descending empty greatest least collation URILiteral

         ::= ( 'ascending' | 'descending' )? ( 'empty' ( 'greatest' | 'least' ) )? ( 'collation' URILiteral )?

referenced by:


CountClause:

count VarName

         ::= 'count' VarName

referenced by:


ReturnClause:

return ExprSingle

         ::= 'return' ExprSingle

referenced by:


QuantifiedExpr:

some every QuantifierBinding , satisfies ExprSingle

         ::= ( 'some' | 'every' ) QuantifierBinding ( ',' QuantifierBinding )* 'satisfies' ExprSingle

referenced by:


QuantifierBinding:

VarNameAndType in ExprSingle

         ::= VarNameAndType 'in' ExprSingle

referenced by:


SwitchExpr:

switch SwitchComparand SwitchCases BracedSwitchCases

         ::= 'switch' SwitchComparand ( SwitchCases | BracedSwitchCases )

referenced by:


SwitchComparand:

( Expr )

         ::= '(' Expr? ')'

referenced by:


Expr:

ExprSingle ,

Expr     ::= ExprSingle ( ',' ExprSingle )*

referenced by:


SwitchCases:

SwitchCaseClause default return ExprSingle

         ::= SwitchCaseClause+ 'default' 'return' ExprSingle

referenced by:


SwitchCaseClause:

case SwitchCaseOperand return ExprSingle

         ::= ( 'case' SwitchCaseOperand )+ 'return' ExprSingle

referenced by:


SwitchCaseOperand:

Expr

         ::= Expr

referenced by:


BracedSwitchCases:

{ SwitchCases }

         ::= '{' SwitchCases '}'

referenced by:


TypeswitchExpr:

typeswitch ( Expr ) TypeswitchCases BracedTypeswitchCases

         ::= 'typeswitch' '(' Expr ')' ( TypeswitchCases | BracedTypeswitchCases )

referenced by:


TypeswitchCases:

CaseClause default VarName return ExprSingle

         ::= CaseClause+ 'default' VarName? 'return' ExprSingle

referenced by:


CaseClause:

case VarName as SequenceTypeUnion return ExprSingle

         ::= 'case' ( VarName 'as' )? SequenceTypeUnion 'return' ExprSingle

referenced by:


SequenceTypeUnion:

SequenceType |

         ::= SequenceType ( '|' SequenceType )*

referenced by:


BracedTypeswitchCases:

{ TypeswitchCases }

         ::= '{' TypeswitchCases '}'

referenced by:


IfExpr:

if ( Expr ) UnbracedActions BracedAction

IfExpr   ::= 'if' '(' Expr ')' ( UnbracedActions | BracedAction )

referenced by:


UnbracedActions:

then ExprSingle else ExprSingle

         ::= 'then' ExprSingle 'else' ExprSingle

referenced by:


BracedAction:

EnclosedExpr

         ::= EnclosedExpr

referenced by:


EnclosedExpr:

{ Expr }

         ::= '{' Expr? '}'

referenced by:


TryCatchExpr:

TryClause CatchClause FinallyClause FinallyClause

         ::= TryClause ( CatchClause+ FinallyClause? | FinallyClause )

referenced by:


TryClause:

try EnclosedExpr

         ::= 'try' EnclosedExpr

referenced by:


CatchClause:

catch NameTestUnion EnclosedExpr

         ::= 'catch' NameTestUnion EnclosedExpr

referenced by:


FinallyClause:

finally EnclosedExpr

         ::= 'finally' EnclosedExpr

referenced by:


OrExpr:

AndExpr or

OrExpr   ::= AndExpr ( 'or' AndExpr )*

referenced by:


AndExpr:

ComparisonExpr and

referenced by:


ComparisonExpr:

OtherwiseExpr ValueComp GeneralComp NodeComp OtherwiseExpr

         ::= OtherwiseExpr ( ( ValueComp | GeneralComp | NodeComp ) OtherwiseExpr )?

referenced by:


OtherwiseExpr:

StringConcatExpr otherwise

         ::= StringConcatExpr ( 'otherwise' StringConcatExpr )*

referenced by:


StringConcatExpr:

RangeExpr ||

         ::= RangeExpr ( '||' RangeExpr )*

referenced by:


RangeExpr:

AdditiveExpr to AdditiveExpr

         ::= AdditiveExpr ( 'to' AdditiveExpr )?

referenced by:


AdditiveExpr:

MultiplicativeExpr + -

         ::= MultiplicativeExpr ( ( '+' | '-' ) MultiplicativeExpr )*

referenced by:


MultiplicativeExpr:

UnionExpr * × div ÷ idiv mod

         ::= UnionExpr ( ( '*' | '×' | 'div' | '÷' | 'idiv' | 'mod' ) UnionExpr )*

referenced by:


UnionExpr:

IntersectExceptExpr union |

         ::= IntersectExceptExpr ( ( 'union' | '|' ) IntersectExceptExpr )*

referenced by:


IntersectExceptExpr:

InstanceofExpr intersect except

         ::= InstanceofExpr ( ( 'intersect' | 'except' ) InstanceofExpr )*

referenced by:


InstanceofExpr:

TreatExpr instance of SequenceType

         ::= TreatExpr ( 'instance' 'of' SequenceType )?

referenced by:


TreatExpr:

CastableExpr treat as SequenceType

         ::= CastableExpr ( 'treat' 'as' SequenceType )?

referenced by:


CastableExpr:

CastExpr castable as CastTarget ?

         ::= CastExpr ( 'castable' 'as' CastTarget '?'? )?

referenced by:


CastExpr:

PipelineExpr cast as CastTarget ?

CastExpr ::= PipelineExpr ( 'cast' 'as' CastTarget '?'? )?

referenced by:


PipelineExpr:

ArrowExpr ->

         ::= ArrowExpr ( '->' ArrowExpr )*

referenced by:


ArrowExpr:

UnaryExpr SequenceArrowTarget MappingArrowTarget

         ::= UnaryExpr ( SequenceArrowTarget | MappingArrowTarget )*

referenced by:


UnaryExpr:

- + ValueExpr

         ::= ( '-' | '+' )* ValueExpr

referenced by:


ValueExpr:

ValidateExpr ExtensionExpr SimpleMapExpr

         ::= ValidateExpr
           | ExtensionExpr
           | SimpleMapExpr

referenced by:


ValidateExpr:

validate ValidationMode type TypeName { Expr }

         ::= 'validate' ( ValidationMode | 'type' TypeName )? '{' Expr '}'

referenced by:


ValidationMode:

lax strict

         ::= 'lax'
           | 'strict'

referenced by:


ExtensionExpr:

Pragma { Expr }

         ::= Pragma+ '{' Expr? '}'

referenced by:


Pragma:

(# S EQName S PragmaContents #)

Pragma   ::= '(#' S EQName ( S PragmaContents )? '#)'
          /* ws: explicit */

referenced by:


SimpleMapExpr:

PathExpr !

         ::= PathExpr ( '!' PathExpr )*

referenced by:


PathExpr:

AbsolutePathExpr RelativePathExpr

           | RelativePathExpr

referenced by:


AbsolutePathExpr:

/ RelativePathExpr // RelativePathExpr

         ::= '/' ( RelativePathExpr | )
           | '//' RelativePathExpr

referenced by:


RelativePathExpr:

StepExpr / //

         ::= StepExpr ( ( '/' | '//' ) StepExpr )*

referenced by:


StepExpr:

PostfixExpr AxisStep

           | AxisStep

referenced by:


PostfixExpr:

PrimaryExpr FilterExpr DynamicFunctionCall LookupExpr MethodCall FilterExprAM

         ::= PrimaryExpr
           | FilterExpr
           | DynamicFunctionCall
           | LookupExpr
           | MethodCall
           | FilterExprAM

referenced by:


PrimaryExpr:

Literal VarRef ParenthesizedExpr . FunctionCall OrderedExpr UnorderedExpr NodeConstructor FunctionItemExpr MapConstructor ArrayConstructor StringTemplate StringConstructor UnaryLookup

         ::= Literal
           | VarRef
           | ParenthesizedExpr
           | '.'
           | FunctionCall
           | OrderedExpr
           | UnorderedExpr
           | NodeConstructor
           | FunctionItemExpr
           | MapConstructor
           | ArrayConstructor
           | StringTemplate
           | StringConstructor
           | UnaryLookup

referenced by:


Literal:

NumericLiteral StringLiteral QNameLiteral

           | StringLiteral
           | QNameLiteral

referenced by:


VarRef:

$ EQName

VarRef   ::= '$' EQName

referenced by:


ParenthesizedExpr:

( Expr )

         ::= '(' Expr? ')'

referenced by:


FunctionCall:

UnreservedFunctionEQName ArgumentList

referenced by:


UnreservedFunctionEQName:

UnreservedFunctionQName URIQualifiedName

         ::= UnreservedFunctionQName
           | URIQualifiedName

referenced by:


ArgumentList:

( PositionalArguments , KeywordArguments KeywordArguments )

         ::= '(' ( PositionalArguments ( ',' KeywordArguments )? | KeywordArguments )? ')'

referenced by:


PositionalArguments:

Argument ,

         ::= Argument ( ',' Argument )*

referenced by:


Argument:

ExprSingle ?

           | '?'

referenced by:


KeywordArguments:

KeywordArgument ,

         ::= KeywordArgument ( ',' KeywordArgument )*

referenced by:


KeywordArgument:

EQName := Argument

         ::= EQName ':=' Argument

referenced by:


OrderedExpr:

ordered EnclosedExpr

         ::= 'ordered' EnclosedExpr

referenced by:


UnorderedExpr:

unordered EnclosedExpr

         ::= 'unordered' EnclosedExpr

referenced by:


NodeConstructor:

DirectConstructor ComputedConstructor

         ::= DirectConstructor
           | ComputedConstructor

referenced by:


DirectConstructor:

DirElemConstructor DirCommentConstructor DirPIConstructor

         ::= DirElemConstructor
           | DirCommentConstructor
           | DirPIConstructor

referenced by:


DirElemConstructor:

< QName DirAttributeList > DirElemContent </ QName S > />

         ::= '<'^DirElemConstructor QName DirAttributeList ( '/>' | '>' DirElemContent* '</' QName S? '>' )
          /* ws: explicit */

referenced by:


DirAttributeList:

S QName S = S DirAttributeValue

         ::= ( S ( QName S? '=' S? DirAttributeValue )? )*
          /* ws: explicit */

referenced by:


DirAttributeValue:

" "" QuotAttrValueContent " ' '' AposAttrValueContent '

         ::= '"' ( '""' | QuotAttrValueContent )* '"'
           | "'" ( "''" | AposAttrValueContent )* "'"
          /* ws: explicit */

referenced by:


QuotAttrValueContent:

QuotAttrContentChar CommonContent

         ::= QuotAttrContentChar
           | CommonContent

referenced by:


CommonContent:

PredefinedEntityRef CharRef {{ }} EnclosedExpr

         ::= PredefinedEntityRef
           | CharRef
           | '{{'
           | '}}'
           | EnclosedExpr

referenced by:


AposAttrValueContent:

AposAttrContentChar CommonContent

         ::= AposAttrContentChar
           | CommonContent

referenced by:


DirElemContent:

DirectConstructor CDataSection CommonContent ElementContentChar

         ::= DirectConstructor
           | CDataSection
           | CommonContent
           | ElementContentChar

referenced by:


CDataSection:

<![CDATA[ CDataSectionContents ]]>

         ::= '<![CDATA[' CDataSectionContents ']]>'
          /* ws: explicit */

referenced by:


DirCommentConstructor:

<!-- DirCommentContents -->

         ::= '<!--' DirCommentContents '-->'
          /* ws: explicit */

referenced by:


DirPIConstructor:

<? PITarget S DirPIContents ?>

         ::= '<?' PITarget ( S DirPIContents )? '?>'
          /* ws: explicit */

referenced by:


ComputedConstructor:

CompDocConstructor CompElemConstructor CompAttrConstructor CompNamespaceConstructor CompTextConstructor CompCommentConstructor CompPIConstructor

         ::= CompDocConstructor
           | CompElemConstructor
           | CompAttrConstructor
           | CompNamespaceConstructor
           | CompTextConstructor
           | CompCommentConstructor
           | CompPIConstructor

referenced by:


CompDocConstructor:

document EnclosedExpr

         ::= 'document' EnclosedExpr

referenced by:


CompElemConstructor:

element CompNodeName EnclosedContentExpr

         ::= 'element' CompNodeName EnclosedContentExpr

referenced by:


CompNodeName:

QNameLiteral UnreservedName { Expr }

         ::= QNameLiteral
           | UnreservedName
           | '{' Expr '}'

referenced by:


UnreservedName:

UnreservedQName URIQualifiedName

         ::= UnreservedQName
           | URIQualifiedName

referenced by:


EnclosedContentExpr:

EnclosedExpr

         ::= EnclosedExpr

referenced by:


CompAttrConstructor:

attribute CompNodeName EnclosedExpr

         ::= 'attribute' CompNodeName EnclosedExpr

referenced by:


CompNamespaceConstructor:

namespace CompNodeNCName EnclosedExpr

         ::= 'namespace' CompNodeNCName EnclosedExpr

referenced by:


CompNodeNCName:

MarkedNCName UnreservedNCName { Expr }

         ::= MarkedNCName
           | UnreservedNCName
           | '{' Expr '}'

referenced by:


MarkedNCName:

# NCName

         ::= '#' NCName

referenced by:


CompTextConstructor:

text EnclosedExpr

         ::= 'text' EnclosedExpr

referenced by:


CompCommentConstructor:

comment EnclosedExpr

         ::= 'comment' EnclosedExpr

referenced by:


CompPIConstructor:

processing-instruction CompNodeNCName EnclosedExpr

         ::= 'processing-instruction' CompNodeNCName EnclosedExpr

referenced by:


FunctionItemExpr:

NamedFunctionRef InlineFunctionExpr

         ::= NamedFunctionRef
           | InlineFunctionExpr

referenced by:


NamedFunctionRef:

UnreservedFunctionEQName # IntegerLiteral

         ::= UnreservedFunctionEQName '#' IntegerLiteral

referenced by:


InlineFunctionExpr:

Annotation function fn FunctionSignature FunctionBody

         ::= Annotation* ( 'function' | 'fn' ) FunctionSignature? FunctionBody

referenced by:


FunctionSignature:

( ParamList ) TypeDeclaration

         ::= '(' ParamList ')' TypeDeclaration?

referenced by:


ParamList:

VarNameAndType ,

         ::= ( VarNameAndType ( ',' VarNameAndType )* )?

referenced by:


FunctionBody:

EnclosedExpr

         ::= EnclosedExpr

referenced by:


MapConstructor:

map { MapConstructorEntry , }

         ::= 'map'? '{' ( MapConstructorEntry ( ',' MapConstructorEntry )* )? '}'

referenced by:


MapConstructorEntry:

ExprSingle : ExprSingle

         ::= ExprSingle ( ':' ExprSingle )?

referenced by:


ArrayConstructor:

SquareArrayConstructor CurlyArrayConstructor

         ::= SquareArrayConstructor
           | CurlyArrayConstructor

referenced by:


SquareArrayConstructor:

[ ExprSingle , ]

         ::= '[' ( ExprSingle ( ',' ExprSingle )* )? ']'

referenced by:


CurlyArrayConstructor:

array EnclosedExpr

         ::= 'array' EnclosedExpr

referenced by:


StringTemplate:

` StringTemplateFixedPart StringTemplateVariablePart `

         ::= '`' ( StringTemplateFixedPart | StringTemplateVariablePart )* '`'
          /* ws: explicit */

referenced by:


StringTemplateVariablePart:

EnclosedExpr

         ::= EnclosedExpr

referenced by:


StringConstructor:

``[ StringConstructorContent ]``

         ::= '``[' StringConstructorContent ']``'
          /* ws: explicit */

referenced by:


StringConstructorContent:

StringConstructorChars StringInterpolation

          /* ws: explicit */

referenced by:


StringInterpolation:

` EnclosedExpr `

         ::= '`' EnclosedExpr '`'
          /* ws: explicit */

referenced by:


UnaryLookup:

Lookup

         ::= Lookup

referenced by:


Lookup:

? KeySpecifier

Lookup   ::= '?' KeySpecifier

referenced by:


KeySpecifier:

NCName Literal . VarRef ParenthesizedExpr *

         ::= NCName
           | Literal
           | '.'
           | VarRef
           | ParenthesizedExpr
           | '*'

referenced by:


FilterExpr:

PostfixExpr Predicate

         ::= PostfixExpr Predicate

referenced by:


Predicate:

[ Expr ]

         ::= '[' Expr ']'

referenced by:


DynamicFunctionCall:

PostfixExpr PositionalArgumentList

         ::= PostfixExpr PositionalArgumentList

referenced by:


PositionalArgumentList:

( PositionalArguments )

         ::= '(' PositionalArguments? ')'

referenced by:


LookupExpr:

PostfixExpr Lookup

         ::= PostfixExpr Lookup

referenced by:


MethodCall:

PostfixExpr =?> NCName PositionalArgumentList

         ::= PostfixExpr '=?>' NCName PositionalArgumentList

referenced by:


FilterExprAM:

PostfixExpr ?[ Expr ]

         ::= PostfixExpr '?[' Expr ']'

referenced by:


AxisStep:

AbbreviatedStep FullStep Predicate

referenced by:


AbbreviatedStep:

.. @ NodeTest SimpleNodeTest

         ::= '..'
           | '@' NodeTest
           | SimpleNodeTest

referenced by:


NodeTest:

UnionNodeTest SimpleNodeTest

           | SimpleNodeTest

referenced by:


UnionNodeTest:

( SimpleNodeTest | )

         ::= '(' SimpleNodeTest ( '|' SimpleNodeTest )* ')'

referenced by:


SimpleNodeTest:

TypeTest Selector

         ::= TypeTest
           | Selector

referenced by:


TypeTest:

RegularItemType type ( SequenceType )

           | 'type' '(' SequenceType ')'

referenced by:


Selector:

EQName Wildcard get ( ExprSingle )

           | Wildcard
           | 'get' '(' ExprSingle ')'

referenced by:


FullStep:

Axis NodeTest

referenced by:


Axis:

ancestor ancestor-or-self attribute child descendant descendant-or-self following following-or-self following-sibling following-sibling-or-self parent preceding preceding-or-self preceding-sibling preceding-sibling-or-self self ::

Axis     ::= ( 'ancestor' | 'ancestor-or-self' | 'attribute' | 'child' | 'descendant' | 'descendant-or-self' | 'following' | 'following-or-self' | 'following-sibling' | 'following-sibling-or-self' | 'parent' | 'preceding' | 'preceding-or-self' | 'preceding-sibling' | 'preceding-sibling-or-self' | 'self' ) '::'

referenced by:


SequenceArrowTarget:

=> ArrowTarget

         ::= '=>' ArrowTarget

referenced by:


ArrowTarget:

FunctionCall RestrictedDynamicCall

         ::= FunctionCall
           | RestrictedDynamicCall

referenced by:


RestrictedDynamicCall:

VarRef ParenthesizedExpr FunctionItemExpr MapConstructor ArrayConstructor PositionalArgumentList

referenced by:


MappingArrowTarget:

=!> ArrowTarget

         ::= '=!>' ArrowTarget

referenced by:


CastTarget:

TypeName ChoiceItemType EnumerationType

         ::= TypeName
           | ChoiceItemType
           | EnumerationType

referenced by:


ValueComp:

eq ne lt le gt ge

         ::= 'eq'
           | 'ne'
           | 'lt'
           | 'le'
           | 'gt'
           | 'ge'

referenced by:


GeneralComp:

= != < <= > >=

         ::= '='
           | '!='
           | '<'^GeneralComp
           | '<='
           | '>'
           | '>='

referenced by:


NodeComp:

is is-not NodePrecedes NodeFollows precedes-or-is follows-or-is

NodeComp ::= 'is'
           | 'is-not'
           | NodePrecedes
           | NodeFollows
           | 'precedes-or-is'
           | 'follows-or-is'

referenced by:


NodePrecedes:

<< precedes

         ::= '<<'
           | 'precedes'

referenced by:


NodeFollows:

>> follows

         ::= '>>'
           | 'follows'

referenced by:


VarDefaultValue:

ExprSingle

         ::= ExprSingle

referenced by:


VarDecl:

declare Annotation variable VarNameAndType := VarValue external := VarDefaultValue

VarDecl  ::= 'declare' Annotation* 'variable' VarNameAndType ( ':=' VarValue | 'external' ( ':=' VarDefaultValue )? )

referenced by:


FunctionDecl:

declare Annotation function UnreservedFunctionEQName ( ParamListWithDefaults ) TypeDeclaration FunctionBody external

         ::= 'declare' Annotation* 'function' UnreservedFunctionEQName '(' ParamListWithDefaults? ')' TypeDeclaration? ( FunctionBody | 'external' )

referenced by:


ParamListWithDefaults:

ParamWithDefault ,

         ::= ParamWithDefault ( ',' ParamWithDefault )*

referenced by:


ParamWithDefault:

VarNameAndType := ExprSingle

         ::= VarNameAndType ( ':=' ExprSingle )?

referenced by:


ItemTypeDecl:

declare Annotation type EQName as ItemType

         ::= 'declare' Annotation* 'type' EQName 'as' ItemType

referenced by:


NamedRecordTypeDecl:

declare Annotation record EQName ( ExtendedFieldDeclaration , ExtensibleFlag )

         ::= 'declare' Annotation* 'record' EQName '(' ( ExtendedFieldDeclaration ( ',' ExtendedFieldDeclaration )* )? ExtensibleFlag? ')'

referenced by:


ExtendedFieldDeclaration:

FieldDeclaration := ExprSingle

         ::= FieldDeclaration ( ':=' ExprSingle )?

referenced by:


OptionDecl:

declare option EQName StringLiteral

         ::= 'declare' 'option' EQName StringLiteral

referenced by:


MainModule:

Prolog QueryBody

         ::= Prolog QueryBody

referenced by:


QueryBody:

Expr

         ::= Expr

referenced by:


Whitespace:

S Comment

         ::= S^WS
           | Comment
          /* ws: definition */

no references


Comment:

(: CommentContents Comment :)

Comment  ::= '(:' ( CommentContents | Comment )* ':)'
          /* ws: explicit */

referenced by:


EOF:

$

EOF      ::= $

referenced by:


StringLiteral:

AposStringLiteral QuotStringLiteral

         ::= AposStringLiteral
           | QuotStringLiteral
          /* ws: explicit */

referenced by:


AposStringLiteral:

' PredefinedEntityRef CharRef '' [^'&] '

         ::= "'" ( PredefinedEntityRef | CharRef | "''" | [^'&] )* "'"
          /* ws: explicit */

referenced by:


PredefinedEntityRef:

& lt gt amp quot apos ;

         ::= '&' ( 'lt' | 'gt' | 'amp' | 'quot' | 'apos' ) ';'
          /* ws: explicit */

referenced by:


CharRef:

&# [0-9] &#x [0-9] [a-f] [A-F] ;

CharRef  ::= ( '&#' [0-9]+ | '&#x' [0-9a-fA-F]+ ) ';'

referenced by:


QuotStringLiteral:

" PredefinedEntityRef CharRef "" [^"&] "

         ::= '"' ( PredefinedEntityRef | CharRef | '""' | [^"&] )* '"'
          /* ws: explicit */

referenced by:


UnreservedNCName:

NCName - ReservedName

         ::= NCName - ReservedName

referenced by:


NCName:

Name - ( Char* ':' Char* )

NCName   ::= Name - ( Char* ':' Char* )

referenced by:


Name:

NameStartChar NameChar

referenced by:


NameStartChar:

: [A-Z] _ [a-z] [#xC0-#xD6] [#xD8-#xF6] [#xF8-#x2FF] [#x370-#x37D] [#x37F-#x1FFF] [#x200C-#x200D] [#x2070-#x218F] [#x2C00-#x2FEF] [#x3001-#xD7FF] [#xF900-#xFDCF] [#xFDF0-#xFFFD] [#x10000-#xEFFFF]

         ::= [:A-Z_a-z#xC0-#xD6#xD8-#xF6#xF8-#x2FF#x370-#x37D#x37F-#x1FFF#x200C-#x200D#x2070-#x218F#x2C00-#x2FEF#x3001-#xD7FF#xF900-#xFDCF#xFDF0-#xFFFD#x10000-#xEFFFF]

referenced by:


NameChar:

NameStartChar - . [0-9] [#xB7] [#x0300-#x036F] [#x203F-#x2040]

           | [-.0-9#xB7#x0300-#x036F#x203F-#x2040]

referenced by:


Char:

[#x9] [#xA] [#xD] [#x20-#xD7FF] [#xE000-#xFFFD] [#x10000-#x10FFFF]

Char     ::= [#x9#xA#xD#x20-#xD7FF#xE000-#xFFFD#x10000-#x10FFFF]

referenced by:


ReservedName:

NaN allowing ancestor ancestor-or-self and array as ascending at attribute base-uri boundary-space by case cast castable catch child collation comment construction context copy-namespaces count decimal-format decimal-separator declare default descendant descendant-or-self descending digit div document document-node element else empty empty-sequence encoding end enum eq every except exponent-separator external false finally fixed fn following following-or-self following-sibling following-sibling-or-self follows follows-or-is for function ge get gnode greatest group grouping-separator gt idiv if import in infinity inherit instance intersect is is-not item jnode key lax le least let lt map member minus-sign mod module namespace namespace-node ne next no-inherit no-preserve node of only option or order ordered ordering otherwise parent pattern-separator per-mille percent precedes precedes-or-is preceding preceding-or-self preceding-sibling preceding-sibling-or-self preserve previous processing-instruction record return satisfies schema schema-attribute schema-element self sliding some stable start strict strip switch text then to treat true try tumbling type typeswitch union unordered validate value variable version when where while window xquery zero-digit

         ::= 'NaN'
           | 'allowing'
           | 'ancestor'
           | 'ancestor-or-self'
           | 'and'
           | 'array'
           | 'as'
           | 'ascending'
           | 'at'
           | 'attribute'
           | 'base-uri'
           | 'boundary-space'
           | 'by'
           | 'case'
           | 'cast'
           | 'castable'
           | 'catch'
           | 'child'
           | 'collation'
           | 'comment'
           | 'construction'
           | 'context'
           | 'copy-namespaces'
           | 'count'
           | 'decimal-format'
           | 'decimal-separator'
           | 'declare'
           | 'default'
           | 'descendant'
           | 'descendant-or-self'
           | 'descending'
           | 'digit'
           | 'div'
           | 'document'
           | 'document-node'
           | 'element'
           | 'else'
           | 'empty'
           | 'empty-sequence'
           | 'encoding'
           | 'end'
           | 'enum'
           | 'eq'
           | 'every'
           | 'except'
           | 'exponent-separator'
           | 'external'
           | 'false'
           | 'finally'
           | 'fixed'
           | 'fn'
           | 'following'
           | 'following-or-self'
           | 'following-sibling'
           | 'following-sibling-or-self'
           | 'follows'
           | 'follows-or-is'
           | 'for'
           | 'function'
           | 'ge'
           | 'get'
           | 'gnode'
           | 'greatest'
           | 'group'
           | 'grouping-separator'
           | 'gt'
           | 'idiv'
           | 'if'
           | 'import'
           | 'in'
           | 'infinity'
           | 'inherit'
           | 'instance'
           | 'intersect'
           | 'is'
           | 'is-not'
           | 'item'
           | 'jnode'
           | 'key'
           | 'lax'
           | 'le'
           | 'least'
           | 'let'
           | 'lt'
           | 'map'
           | 'member'
           | 'minus-sign'
           | 'mod'
           | 'module'
           | 'namespace'
           | 'namespace-node'
           | 'ne'
           | 'next'
           | 'no-inherit'
           | 'no-preserve'
           | 'node'
           | 'of'
           | 'only'
           | 'option'
           | 'or'
           | 'order'
           | 'ordered'
           | 'ordering'
           | 'otherwise'
           | 'parent'
           | 'pattern-separator'
           | 'per-mille'
           | 'percent'
           | 'precedes'
           | 'precedes-or-is'
           | 'preceding'
           | 'preceding-or-self'
           | 'preceding-sibling'
           | 'preceding-sibling-or-self'
           | 'preserve'
           | 'previous'
           | 'processing-instruction'
           | 'record'
           | 'return'
           | 'satisfies'
           | 'schema'
           | 'schema-attribute'
           | 'schema-element'
           | 'self'
           | 'sliding'
           | 'some'
           | 'stable'
           | 'start'
           | 'strict'
           | 'strip'
           | 'switch'
           | 'text'
           | 'then'
           | 'to'
           | 'treat'
           | 'true'
           | 'try'
           | 'tumbling'
           | 'type'
           | 'typeswitch'
           | 'union'
           | 'unordered'
           | 'validate'
           | 'value'
           | 'variable'
           | 'version'
           | 'when'
           | 'where'
           | 'while'
           | 'window'
           | 'xquery'
           | 'zero-digit'

referenced by:


URIQualifiedName:

BracedURILiteral NCName : NCName

         ::= BracedURILiteral NCName ( ':' NCName )?
          /* ws: explicit */

referenced by:


BracedURILiteral:

Q { PredefinedEntityRef CharRef [^&{}] }

         ::= 'Q' '{' ( PredefinedEntityRef | CharRef | [^&{}] )* '}'
          /* ws: explicit */

referenced by:


UnreservedQName:

QName - ReservedName

         ::= QName - ReservedName

referenced by:


QName:

PrefixedName UnprefixedName

QName    ::= PrefixedName
           | UnprefixedName

referenced by:


PrefixedName:

Prefix : LocalPart

         ::= Prefix ':' LocalPart

referenced by:


Prefix:

NCName

Prefix   ::= NCName

referenced by:


LocalPart:

NCName

         ::= NCName

referenced by:


UnprefixedName:

LocalPart

         ::= LocalPart

referenced by:


Wildcard:

BracedURILiteral * NCName :* *: NCName

           | NCName ':*'
           | '*:' NCName
          /* ws: explicit */

referenced by:


IntegerLiteral:

Digits

         ::= Digits
          /* ws: explicit */

referenced by:


Digits:

DecDigit DecDigit _ DecDigit

Digits   ::= DecDigit ( ( DecDigit | '_' )* DecDigit )?
          /* ws: explicit */

referenced by:


DecDigit:

[0-9]

DecDigit ::= [0-9]
          /* ws: explicit */

referenced by:


HexIntegerLiteral:

0x HexDigits

         ::= '0x' HexDigits
          /* ws: explicit */

referenced by:


HexDigits:

HexDigit HexDigit _ HexDigit

         ::= HexDigit ( ( HexDigit | '_' )* HexDigit )?
          /* ws: explicit */

referenced by:


HexDigit:

[0-9] [a-f] [A-F]

HexDigit ::= [0-9a-fA-F]
          /* ws: explicit */

referenced by:


BinaryIntegerLiteral:

0b BinaryDigits

         ::= '0b' BinaryDigits
          /* ws: explicit */

referenced by:


BinaryDigits:

BinaryDigit BinaryDigit _ BinaryDigit

         ::= BinaryDigit ( ( BinaryDigit | '_' )* BinaryDigit )?
          /* ws: explicit */

referenced by:


BinaryDigit:

[0-1]

         ::= [0-1]
          /* ws: explicit */

referenced by:


DecimalLiteral:

. Digits Digits . Digits

         ::= '.' Digits
           | Digits '.' Digits?
          /* ws: explicit */

referenced by:


DoubleLiteral:

. Digits Digits . Digits e E + [#x2D] Digits

         ::= ( '.' Digits | Digits ( '.' Digits? )? ) [eE] [+#x2D]? Digits
          /* ws: explicit */

referenced by:


S:

[#x20] [#x9] [#xD] [#xA]

S        ::= [#x20#x9#xD#xA]+

referenced by:


PragmaContents:

Char* - ( Char* '#)' Char* ) & '#'

         ::= Char* - ( Char* '#)' Char* ) & '#'

referenced by:


QuotAttrContentChar:

Char - ["{}<&]

         ::= Char - ["{}<&]

referenced by:


AposAttrContentChar:

Char - ['{}<&]

         ::= Char - ['{}<&]

referenced by:


ElementContentChar:

Char - [{}<&]

         ::= Char - [{}<&]

referenced by:


CDataSectionContents:

Char* - ( Char* ']]>' Char* ) & ']]'

         ::= Char* - ( Char* ']]>' Char* ) & ']]'

referenced by:


DirCommentContents:

- Char - '-'

         ::= ( '-'? ( Char - '-' ) )*
          /* ws: explicit */

referenced by:


PITarget:

NCName - ( ( 'X' | 'x' ) ( 'M' | 'm' ) ( 'L' | 'l' ) )

PITarget ::= NCName - ( ( 'X' | 'x' ) ( 'M' | 'm' ) ( 'L' | 'l' ) )

referenced by:


DirPIContents:

Char* - ( Char* '?>' Char* ) & '?'

         ::= Char* - ( Char* '?>' Char* ) & '?'

referenced by:


StringTemplateFixedPart:

Char - ( '{' | '}' | '`' ) {{ }} ``

         ::= ( Char - ( '{' | '}' | '`' ) | '{{' | '}}' | '``' )+
          /* ws: explicit */

referenced by:


StringConstructorChars:

Char* - ( Char* ( '`{' | ']``' ) Char* ) & ( '`{' | ']`' )

         ::= Char* - ( Char* ( '`{' | ']``' ) Char* ) & ( '`{' | ']`' )

referenced by:


CommentContents:

( Char+ - ( Char* ( '(:' | ':)' ) Char* ) ) - ( Char* '(' ) & ':' Char+ - ( Char* ( '(:' | ':)' ) Char* ) & '('

         ::= ( Char+ - ( Char* ( '(:' | ':)' ) Char* ) ) - ( Char* '(' ) & ':'
           | Char+ - ( Char* ( '(:' | ':)' ) Char* ) & '('
          /* ws: explicit */

referenced by:


QNameOrKeywordDelimiter:

$ : Char - NameChar

         ::= $
           | ':'
           | Char - NameChar

referenced by:


NCNameDelimiter:

$ $ Char - NameChar $ Char : Char - NameStartChar

         ::= $ $
           | ( Char - NameChar ) ( $ | Char )
           | ':' ( Char - NameStartChar )

no references


NumericLiteralDelimiter:

QNameOrKeywordDelimiter -

         ::= QNameOrKeywordDelimiter
           | '-'

no references


GeneralCompDelimiter:

[^?]

         ::= [^?]

no references


DirElemConstructorDelimiter:

QName S QName S = S / >

         ::= QName ( S QName S? '=' | S? [/>] )

no references


  ... generated by RR - Railroad Diagram Generator R R