BaseX.ebnf Find Productions:X AbbrevForwardStep AdditiveExpr AllowingEmpty AndExpr AnnotatedDecl Annotation AnyArrayTest AnyFunctionTest AnyKindTest AnyMapTest AposAttrContentChar AposAttrValueContent Argument ArgumentList ArrayConstructor ArrayTest ArrowExpr ArrowFunctionSpecifier AtomicOrUnionType AttribNameOrWildcard AttributeDeclaration AttributeName AttributeTest AxisStep BaseURIDecl BasexIfExpr BasexUpdate1Expr BasexUpdateExpr BoundarySpaceDecl BracedURILiteral CDataSection CDataSectionContents CaseClause CastExpr CastableExpr CatchClause CatchErrorList Char CharRef Comment CommentContents CommentTest CommonContent CompAttrConstructor CompCommentConstructor CompDocConstructor CompElemConstructor CompNamespaceConstructor CompPIConstructor CompTextConstructor ComparisonExpr ComputedConstructor ConstructionDecl Constructor ContextItemDecl CopyModifyExpr CopyModifySpec CopyNamespacesDecl CountClause CurlyArrayConstructor CurrentItem DFPropertyName DecimalFormatDecl DecimalLiteral DefaultCollationDecl DefaultNamespaceDecl DeleteExpr DelimitingChar Digits DirAttributeList DirAttributeValue DirCommentConstructor DirCommentContents DirElemConstructor DirElemContent DirPIConstructor DirPIContents DirectConstructor DocumentTest DoubleLiteral EOF EQName ElementContentChar ElementDeclaration ElementName ElementNameOrWildcard ElementTest EmptyOrderDecl EnclosedContentExpr EnclosedExpr EnclosedTryTargetExpr Expr ExprSingle ExtensionExpr FLWORExpr FTAnd FTAnyallOption FTBigUnit FTCaseOption FTContainsExpr FTContent FTDiacriticsOption FTDistance FTExtensionOption FTExtensionSelection FTIgnoreOption FTLanguageOption FTLiteralRange FTMatchOption FTMatchOptions FTMildNot FTOptionDecl FTOr FTPosFilter FTPrimary FTPrimaryWithOptions FTRange FTScope FTScoreVar FTSelection FTStemOption FTStopWordOption FTStopWords FTStopWordsInclExcl FTThesaurusID FTThesaurusOption FTTimes FTUnaryNot FTUnit FTWeight FTWildCardOption FTWindow FTWords FTWordsValue ForBinding ForClause ForwardAxis ForwardStep FunctionBody FunctionCall FunctionDecl FunctionEQName FunctionItemExpr FunctionName FunctionTest GeneralComp GroupByClause GroupingSpec GroupingSpecList GroupingVariable IfExpr Import InheritMode InitialClause InlineFunctionExpr InsertExpr InsertExprTargetChoice InstanceofExpr IntegerLiteral IntermediateClause IntersectExceptExpr ItemType KeySpecifier KindTest LetBinding LetClause LibraryModule Literal LocalPart Lookup MainModule MapConstructor MapConstructorEntry MapKeyExpr MapTest MapValueExpr Module ModuleDecl ModuleImport MultiplicativeExpr NCName NCName Name NameChar NameStartChar NameTest NamedFunctionRef NamespaceDecl NamespaceNodeTest NewNameExpr NextItem NodeComp NodeTest NonNCNameChar NumericLiteral OccurrenceIndicator OptionDecl OrExpr OrderByClause OrderModifier OrderSpec OrderSpecList OrderedExpr OrderingModeDecl OtherwiseExpr PITarget PITest Param ParamList ParenthesizedExpr ParenthesizedItemType PathExpr PositionalVar PostfixExpr Pragma PragmaContents PredefinedEntityRef Predicate PredicateList Prefix Prefix PrefixExpr PrefixedName PreserveMode PreviousItem PrimaryExpr Prolog QName QName QuantifiedExpr QuantifiedVarDecl QueryBody QuotAttrContentChar QuotAttrValueContent RangeExpr RelativePathExpr RenameExpr ReplaceExpr ReturnClause RevalidationDecl ReverseAxis ReverseStep S SchemaAttributeTest SchemaElementTest SchemaImport SchemaPrefix SequenceType SequenceTypeUnion Setter SimpleMapExpr SimpleTypeName SingleType SlidingWindowClause SourceExpr SquareArrayConstructor StepExpr StringConcatExpr StringConstructor StringConstructorChars StringConstructorContent StringConstructorInterpolation StringLiteral SwitchCaseClause SwitchCaseOperand SwitchExpr TargetExpr TextTest TransformWithExpr TreatExpr TryCatchExpr TryClause TumblingWindowClause TypeDeclaration TypeName TypedArrayTest TypedFunctionTest TypedMapTest TypeswitchExpr URIExpr URILiteral URIQualifiedName UnaryExpr UnaryLookup UnionExpr UnorderedExpr UnprefixedName UpdatingFunctionCall ValidateExpr ValidationMode ValueComp ValueExpr VarDecl VarDefaultValue VarName VarRef VarValue VersionDecl WhereClause Whitespace Wildcard WindowClause WindowEndCondition WindowStartCondition WindowVars XQuery 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') } })

XQuery:

Module EOF

XQuery   ::= Module EOF

no references


Module:

VersionDecl LibraryModule MainModule

referenced by:


VersionDecl:

xquery encoding version StringLiteral encoding StringLiteral ;

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

referenced by:


MainModule:

Prolog QueryBody

         ::= Prolog QueryBody

referenced by:


LibraryModule:

ModuleDecl Prolog

         ::= ModuleDecl Prolog

referenced by:


ModuleDecl:

module namespace NCName = URILiteral ;

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

referenced by:


Prolog:

DefaultNamespaceDecl Setter NamespaceDecl Import FTOptionDecl ; ContextItemDecl AnnotatedDecl OptionDecl ;

referenced by:


Setter:

BoundarySpaceDecl DefaultCollationDecl BaseURIDecl ConstructionDecl OrderingModeDecl EmptyOrderDecl RevalidationDecl CopyNamespacesDecl DecimalFormatDecl

           | DefaultCollationDecl
           | BaseURIDecl
           | ConstructionDecl
           | OrderingModeDecl
           | EmptyOrderDecl
           | RevalidationDecl
           | 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:


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:


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 = default element namespace

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

referenced by:


ModuleImport:

import module namespace NCName = URILiteral at URILiteral ,

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

referenced by:


NamespaceDecl:

declare namespace NCName = URILiteral

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

referenced by:


DefaultNamespaceDecl:

declare default element function namespace URILiteral

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

referenced by:


FTOptionDecl:

declare ft-option FTMatchOptions

         ::= 'declare' 'ft-option' FTMatchOptions

referenced by:


AnnotatedDecl:

declare updating Annotation VarDecl FunctionDecl

         ::= 'declare' ( 'updating' | Annotation )* ( VarDecl | FunctionDecl )

referenced by:


Annotation:

% EQName ( Literal , )

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

referenced by:


VarDecl:

variable $ VarName TypeDeclaration := VarValue external := VarDefaultValue

VarDecl  ::= 'variable' '$' VarName TypeDeclaration? ( ':=' VarValue | 'external' ( ':=' VarDefaultValue )? )

referenced by:


VarValue:

ExprSingle

referenced by:


VarDefaultValue:

ExprSingle

         ::= ExprSingle

referenced by:


ContextItemDecl:

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

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

referenced by:


FunctionDecl:

function EQName ( ParamList ) as SequenceType FunctionBody external

         ::= 'function' EQName '(' ParamList? ')' ( 'as' SequenceType )? ( FunctionBody | 'external' )

referenced by:


ParamList:

Param ,

         ::= Param ( ',' Param )*

referenced by:


Param:

$ EQName TypeDeclaration

Param    ::= '$' EQName TypeDeclaration?

referenced by:


FunctionBody:

EnclosedExpr

         ::= EnclosedExpr

referenced by:


EnclosedExpr:

{ Expr }

         ::= '{' Expr? '}'

referenced by:


OptionDecl:

declare option EQName StringLiteral

         ::= 'declare' 'option' EQName StringLiteral

referenced by:


FLWORExpr:

InitialClause IntermediateClause ReturnClause

referenced by:


InitialClause:

ForClause LetClause WindowClause

         ::= ForClause
           | LetClause
           | WindowClause

referenced by:


IntermediateClause:

InitialClause WhereClause GroupByClause OrderByClause CountClause

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

referenced by:


ForClause:

for ForBinding ,

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

referenced by:


ForBinding:

$ VarName TypeDeclaration AllowingEmpty PositionalVar FTScoreVar in ExprSingle

referenced by:


AllowingEmpty:

allowing empty

         ::= 'allowing' 'empty'

referenced by:


PositionalVar:

at $ VarName

         ::= 'at' '$' VarName

referenced by:


FTScoreVar:

score $ VarName

         ::= 'score' '$' VarName

referenced by:


LetClause:

let LetBinding ,

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

referenced by:


LetBinding:

$ VarName TypeDeclaration FTScoreVar := ExprSingle

         ::= ( '$' VarName TypeDeclaration? | FTScoreVar ) ':=' ExprSingle

referenced by:


WindowClause:

for TumblingWindowClause SlidingWindowClause

         ::= 'for' ( TumblingWindowClause | SlidingWindowClause )

referenced by:


TumblingWindowClause:

tumbling window $ VarName TypeDeclaration in ExprSingle WindowStartCondition WindowEndCondition

         ::= 'tumbling' 'window' '$' VarName TypeDeclaration? 'in' ExprSingle WindowStartCondition WindowEndCondition?

referenced by:


SlidingWindowClause:

sliding window $ VarName TypeDeclaration in ExprSingle WindowStartCondition WindowEndCondition

         ::= 'sliding' 'window' '$' VarName TypeDeclaration? 'in' ExprSingle WindowStartCondition WindowEndCondition

referenced by:


WindowStartCondition:

start WindowVars when ExprSingle

         ::= 'start' WindowVars 'when' ExprSingle

referenced by:


WindowEndCondition:

only end WindowVars when ExprSingle

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

referenced by:


WindowVars:

$ CurrentItem PositionalVar previous $ PreviousItem next $ NextItem

         ::= ( '$' CurrentItem )? PositionalVar? ( 'previous' '$' PreviousItem )? ( 'next' '$' NextItem )?

referenced by:


CurrentItem:

EQName

         ::= EQName

referenced by:


PreviousItem:

EQName

         ::= EQName

referenced by:


NextItem:

EQName

referenced by:


CountClause:

count $ VarName

         ::= 'count' '$' VarName

referenced by:


WhereClause:

where ExprSingle

         ::= 'where' ExprSingle

referenced by:


GroupByClause:

group by GroupingSpecList

         ::= 'group' 'by' GroupingSpecList

referenced by:


GroupingSpecList:

GroupingSpec ,

         ::= GroupingSpec ( ',' GroupingSpec )*

referenced by:


GroupingSpec:

GroupingVariable TypeDeclaration := ExprSingle collation URILiteral ExprSingle

         ::= GroupingVariable ( TypeDeclaration? ':=' ExprSingle )? ( 'collation' URILiteral )?
           | ExprSingle

referenced by:


GroupingVariable:

$ VarName

         ::= '$' VarName

referenced by:


OrderByClause:

stable order by OrderSpecList

         ::= 'stable'? 'order' 'by' OrderSpecList

referenced by:


OrderSpecList:

OrderSpec ,

         ::= 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:


ReturnClause:

return ExprSingle

         ::= 'return' ExprSingle

referenced by:


QuantifiedExpr:

some every QuantifiedVarDecl , satisfies ExprSingle

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

referenced by:


QuantifiedVarDecl:

$ VarName TypeDeclaration in ExprSingle

         ::= '$' VarName TypeDeclaration? 'in' ExprSingle

referenced by:


SwitchExpr:

switch ( Expr ) SwitchCaseClause default return ExprSingle

         ::= 'switch' '(' Expr ')' SwitchCaseClause+ 'default' 'return' ExprSingle

referenced by:


SwitchCaseClause:

case SwitchCaseOperand return ExprSingle

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

referenced by:


SwitchCaseOperand:

ExprSingle

         ::= ExprSingle

referenced by:


TypeswitchExpr:

typeswitch ( Expr ) CaseClause default $ VarName return ExprSingle

         ::= 'typeswitch' '(' Expr ')' 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:


IfExpr:

if ( Expr ) then ExprSingle else ExprSingle

IfExpr   ::= 'if' '(' Expr ')' 'then' ExprSingle 'else' ExprSingle

referenced by:


BasexIfExpr:

if ( Expr ) then ExprSingle

         ::= 'if' '(' Expr ')' 'then' ExprSingle

referenced by:


TryCatchExpr:

TryClause CatchClause

         ::= TryClause CatchClause+

referenced by:


TryClause:

try EnclosedTryTargetExpr

         ::= 'try' EnclosedTryTargetExpr

referenced by:


EnclosedTryTargetExpr:

EnclosedExpr

         ::= EnclosedExpr

referenced by:


CatchClause:

catch CatchErrorList EnclosedExpr

         ::= 'catch' CatchErrorList EnclosedExpr

referenced by:


CatchErrorList:

NameTest |

         ::= NameTest ( '|' NameTest )*

referenced by:


OrExpr:

AndExpr or

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

referenced by:


AndExpr:

ComparisonExpr and

referenced by:


ComparisonExpr:

FTContainsExpr ValueComp GeneralComp NodeComp FTContainsExpr

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

referenced by:


FTContainsExpr:

StringConcatExpr contains text FTSelection FTIgnoreOption

         ::= StringConcatExpr ( 'contains' 'text' FTSelection FTIgnoreOption? )?

referenced by:


StringConcatExpr:

RangeExpr ||

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

referenced by:


RangeExpr:

AdditiveExpr to AdditiveExpr

         ::= AdditiveExpr ( 'to' AdditiveExpr )?

referenced by:


AdditiveExpr:

MultiplicativeExpr + -

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

referenced by:


MultiplicativeExpr:

OtherwiseExpr * div idiv mod

         ::= OtherwiseExpr ( ( '*' | 'div' | 'idiv' | 'mod' ) OtherwiseExpr )*

referenced by:


OtherwiseExpr:

UnionExpr otherwise ?:

         ::= UnionExpr ( ( 'otherwise' | '?:' ) 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 SingleType

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

referenced by:


CastExpr:

TransformWithExpr cast as SingleType

CastExpr ::= TransformWithExpr ( 'cast' 'as' SingleType )?

referenced by:


TransformWithExpr:

BasexUpdate1Expr transform with { Expr }

         ::= BasexUpdate1Expr ( 'transform' 'with' '{' Expr? '}' )?

referenced by:


BasexUpdate1Expr:

BasexUpdateExpr update { Expr }

         ::= BasexUpdateExpr ( 'update' '{' Expr? '}' )?

referenced by:


BasexUpdateExpr:

ArrowExpr update { Expr }

         ::= ArrowExpr ( 'update' '{' Expr? '}' )*

referenced by:


ArrowExpr:

UnaryExpr => ArrowFunctionSpecifier ArgumentList

         ::= UnaryExpr ( '=>' ArrowFunctionSpecifier ArgumentList )*

referenced by:


UnaryExpr:

- + ValueExpr

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

referenced by:


ValueExpr:

ValidateExpr SimpleMapExpr ExtensionExpr

         ::= ValidateExpr
           | SimpleMapExpr
           | ExtensionExpr

referenced by:


SimpleMapExpr:

PathExpr !

         ::= PathExpr ( '!' PathExpr )*

referenced by:


GeneralComp:

= != < <= > >=

         ::= '='
           | '!='
           | '<'
           | '<='
           | '>'
           | '>='

referenced by:


ValueComp:

eq ne lt le gt ge

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

referenced by:


NodeComp:

is << >>

NodeComp ::= 'is'
           | '<<'
           | '>>'

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:


PathExpr:

/ RelativePathExpr // RelativePathExpr

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

referenced by:


RelativePathExpr:

StepExpr / // !

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

referenced by:


StepExpr:

PostfixExpr AxisStep

           | AxisStep

referenced by:


AxisStep:

ReverseStep ForwardStep PredicateList

referenced by:


ForwardStep:

ForwardAxis NodeTest AbbrevForwardStep

         ::= ForwardAxis NodeTest
           | AbbrevForwardStep

referenced by:


ForwardAxis:

child descendant attribute self descendant-or-self following-sibling following ::

         ::= ( 'child' | 'descendant' | 'attribute' | 'self' | 'descendant-or-self' | 'following-sibling' | 'following' ) '::'

referenced by:


AbbrevForwardStep:

@ NodeTest

         ::= '@'? NodeTest

referenced by:


ReverseStep:

ReverseAxis NodeTest ..

         ::= ReverseAxis NodeTest
           | '..'

referenced by:


ReverseAxis:

parent ancestor preceding-sibling preceding ancestor-or-self ::

         ::= ( 'parent' | 'ancestor' | 'preceding-sibling' | 'preceding' | 'ancestor-or-self' ) '::'

referenced by:


NodeTest:

KindTest NameTest

           | NameTest

referenced by:


NameTest:

EQName Wildcard

           | Wildcard

referenced by:


PostfixExpr:

PrimaryExpr Predicate ArgumentList Lookup

         ::= PrimaryExpr ( Predicate | ArgumentList | Lookup )*

referenced by:


ArgumentList:

( Argument , )

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

referenced by:


PredicateList:

Predicate

         ::= Predicate*

referenced by:


Predicate:

[ Expr ]

         ::= '[' Expr ']'

referenced by:


Lookup:

? KeySpecifier

Lookup   ::= '?' KeySpecifier

referenced by:


UnaryLookup:

? KeySpecifier

         ::= '?' KeySpecifier

referenced by:


KeySpecifier:

NCName IntegerLiteral ParenthesizedExpr *

         ::= NCName
           | IntegerLiteral
           | ParenthesizedExpr
           | '*'

referenced by:


ArrowFunctionSpecifier:

EQName VarRef ParenthesizedExpr

         ::= EQName
           | VarRef
           | ParenthesizedExpr

referenced by:


Literal:

NumericLiteral StringLiteral

           | StringLiteral

referenced by:


NumericLiteral:

IntegerLiteral DecimalLiteral DoubleLiteral

         ::= IntegerLiteral
           | DecimalLiteral
           | DoubleLiteral

referenced by:


VarRef:

$ VarName

VarRef   ::= '$' VarName

referenced by:


VarName:

EQName

referenced by:


ParenthesizedExpr:

( Expr )

         ::= '(' Expr? ')'

referenced by:


OrderedExpr:

ordered { Expr }

         ::= 'ordered' '{' Expr '}'

referenced by:


UnorderedExpr:

unordered { Expr }

         ::= 'unordered' '{' Expr '}'

referenced by:


FunctionCall:

FunctionEQName ArgumentList

         ::= FunctionEQName ArgumentList

referenced by:


Argument:

ExprSingle ?

           | '?'

referenced by:


Constructor:

DirectConstructor ComputedConstructor

         ::= DirectConstructor
           | ComputedConstructor

referenced by:


DirectConstructor:

DirElemConstructor DirCommentConstructor DirPIConstructor

         ::= DirElemConstructor
           | DirCommentConstructor
           | DirPIConstructor

referenced by:


DirElemConstructor:

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

         ::= '<' 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:


AposAttrValueContent:

AposAttrContentChar CommonContent

         ::= AposAttrContentChar
           | CommonContent

referenced by:


DirElemContent:

DirectConstructor CDataSection CommonContent ElementContentChar

         ::= DirectConstructor
           | CDataSection
           | CommonContent
           | ElementContentChar

referenced by:


DirCommentConstructor:

<!-- DirCommentContents -->

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

referenced by:


DirPIConstructor:

<? PITarget S DirPIContents ?>

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

referenced by:


CDataSection:

<![CDATA[ CDataSectionContents ]]>

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

referenced by:


ComputedConstructor:

CompDocConstructor CompElemConstructor CompAttrConstructor CompNamespaceConstructor CompTextConstructor CompCommentConstructor CompPIConstructor

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

referenced by:


CompElemConstructor:

element EQName { Expr } EnclosedContentExpr

         ::= 'element' ( EQName | '{' Expr '}' ) EnclosedContentExpr

referenced by:


EnclosedContentExpr:

EnclosedExpr

         ::= EnclosedExpr

referenced by:


CompNamespaceConstructor:

namespace Prefix { PrefixExpr } { URIExpr }

         ::= 'namespace' ( Prefix | '{' PrefixExpr '}' ) '{' URIExpr '}'

referenced by:


Prefix:

NCName

Prefix   ::= NCName

referenced by:


PrefixExpr:

Expr

         ::= Expr

referenced by:


URIExpr:

Expr

URIExpr  ::= Expr

referenced by:


FunctionItemExpr:

NamedFunctionRef InlineFunctionExpr

         ::= NamedFunctionRef
           | InlineFunctionExpr

referenced by:


NamedFunctionRef:

EQName # IntegerLiteral

         ::= EQName '#' IntegerLiteral

referenced by:


InlineFunctionExpr:

Annotation function ( ParamList ) as SequenceType FunctionBody

         ::= Annotation* 'function' '(' ParamList? ')' ( 'as' SequenceType )? FunctionBody

referenced by:


MapConstructor:

map { MapConstructorEntry , }

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

referenced by:


MapConstructorEntry:

MapKeyExpr : MapValueExpr

         ::= MapKeyExpr ':' MapValueExpr

referenced by:


MapKeyExpr:

ExprSingle

         ::= ExprSingle

referenced by:


MapValueExpr:

ExprSingle

         ::= ExprSingle

referenced by:


ArrayConstructor:

SquareArrayConstructor CurlyArrayConstructor

         ::= SquareArrayConstructor
           | CurlyArrayConstructor

referenced by:


SquareArrayConstructor:

[ ExprSingle , ]

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

referenced by:


CurlyArrayConstructor:

array EnclosedExpr

         ::= 'array' EnclosedExpr

referenced by:


StringConstructor:

``[ StringConstructorContent ]``

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

referenced by:


StringConstructorContent:

StringConstructorChars StringConstructorInterpolation

          /* ws: explicit */

referenced by:


StringConstructorInterpolation:

`{ Expr }`

         ::= '`{' Expr? '}`'

referenced by:


SingleType:

SimpleTypeName ?

         ::= SimpleTypeName '?'?

referenced by:


TypeDeclaration:

as SequenceType

         ::= 'as' SequenceType

referenced by:


SequenceType:

empty-sequence ( ) ItemType OccurrenceIndicator

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

referenced by:


ItemType:

KindTest item ( ) FunctionTest MapTest ArrayTest AtomicOrUnionType ParenthesizedItemType

           | 'item' '(' ')'
           | FunctionTest
           | MapTest
           | ArrayTest
           | AtomicOrUnionType
           | ParenthesizedItemType

referenced by:


OccurrenceIndicator:

? * +

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

referenced by:


AtomicOrUnionType:

EQName

         ::= EQName

referenced by:


KindTest:

DocumentTest ElementTest AttributeTest SchemaElementTest SchemaAttributeTest PITest CommentTest TextTest NamespaceNodeTest AnyKindTest

           | ElementTest
           | AttributeTest
           | SchemaElementTest
           | SchemaAttributeTest
           | PITest
           | CommentTest
           | TextTest
           | NamespaceNodeTest
           | AnyKindTest

referenced by:


AnyKindTest:

node ( )

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

referenced by:


DocumentTest:

document-node ( ElementTest SchemaElementTest )

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

referenced by:


TextTest:

text ( )

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

referenced by:


CommentTest:

comment ( )

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

referenced by:


NamespaceNodeTest:

namespace-node ( )

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

referenced by:


PITest:

processing-instruction ( NCName StringLiteral )

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

referenced by:


AttributeTest:

attribute ( AttribNameOrWildcard , TypeName )

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

referenced by:


AttribNameOrWildcard:

AttributeName *

         ::= AttributeName
           | '*'

referenced by:


SchemaAttributeTest:

schema-attribute ( AttributeDeclaration )

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

referenced by:


AttributeDeclaration:

AttributeName

         ::= AttributeName

referenced by:


ElementTest:

element ( ElementNameOrWildcard , TypeName ? )

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

referenced by:


ElementNameOrWildcard:

ElementName *

         ::= ElementName
           | '*'

referenced by:


SchemaElementTest:

schema-element ( ElementDeclaration )

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

referenced by:


ElementDeclaration:

ElementName

         ::= ElementName

referenced by:


AttributeName:

EQName

         ::= EQName

referenced by:


ElementName:

EQName

         ::= EQName

referenced by:


SimpleTypeName:

TypeName

         ::= TypeName

referenced by:


TypeName:

EQName

referenced by:


FunctionTest:

Annotation AnyFunctionTest TypedFunctionTest

         ::= Annotation* ( AnyFunctionTest | TypedFunctionTest )

referenced by:


AnyFunctionTest:

function ( * )

         ::= 'function' '(' '*' ')'

referenced by:


TypedFunctionTest:

function ( SequenceType , ) as SequenceType

         ::= 'function' '(' ( SequenceType ( ',' SequenceType )* )? ')' 'as' SequenceType

referenced by:


MapTest:

AnyMapTest TypedMapTest

           | TypedMapTest

referenced by:


AnyMapTest:

map ( * )

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

referenced by:


TypedMapTest:

map ( AtomicOrUnionType , SequenceType )

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

referenced by:


ArrayTest:

AnyArrayTest TypedArrayTest

         ::= AnyArrayTest
           | TypedArrayTest

referenced by:


AnyArrayTest:

array ( * )

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

referenced by:


TypedArrayTest:

array ( SequenceType )

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

referenced by:


ParenthesizedItemType:

( ItemType )

         ::= '(' ItemType ')'

referenced by:


URILiteral:

StringLiteral

         ::= StringLiteral

referenced by:


EQName:

QName URIQualifiedName

EQName   ::= QName
           | URIQualifiedName

referenced by:


FunctionEQName:

FunctionName URIQualifiedName

         ::= FunctionName
           | URIQualifiedName

referenced by:


QName:

FunctionName attribute comment document-node element empty-sequence function if item namespace-node node processing-instruction schema-attribute schema-element switch text typeswitch

QName    ::= FunctionName
           | 'attribute'
           | 'comment'
           | 'document-node'
           | 'element'
           | 'empty-sequence'
           | 'function'
           | 'if'
           | 'item'
           | 'namespace-node'
           | 'node'
           | 'processing-instruction'
           | 'schema-attribute'
           | 'schema-element'
           | 'switch'
           | 'text'
           | 'typeswitch'

referenced by:


FunctionName:

QName ancestor ancestor-or-self and as ascending at case cast castable child collation copy count declare default delete descendant descendant-or-self descending div document else empty end eq every except following following-sibling for ge group gt idiv import insert instance intersect invoke is le let lt mod module modify namespace ne only or order ordered parent preceding preceding-sibling rename replace return satisfies self some stable start to transform treat try union unordered update updating validate where with xquery

         ::= QName^Token
           | 'ancestor'
           | 'ancestor-or-self'
           | 'and'
           | 'as'
           | 'ascending'
           | 'at'
           | 'case'
           | 'cast'
           | 'castable'
           | 'child'
           | 'collation'
           | 'copy'
           | 'count'
           | 'declare'
           | 'default'
           | 'delete'
           | 'descendant'
           | 'descendant-or-self'
           | 'descending'
           | 'div'
           | 'document'
           | 'else'
           | 'empty'
           | 'end'
           | 'eq'
           | 'every'
           | 'except'
           | 'following'
           | 'following-sibling'
           | 'for'
           | 'ge'
           | 'group'
           | 'gt'
           | 'idiv'
           | 'import'
           | 'insert'
           | 'instance'
           | 'intersect'
           | 'invoke'
           | 'is'
           | 'le'
           | 'let'
           | 'lt'
           | 'mod'
           | 'module'
           | 'modify'
           | 'namespace'
           | 'ne'
           | 'only'
           | 'or'
           | 'order'
           | 'ordered'
           | 'parent'
           | 'preceding'
           | 'preceding-sibling'
           | 'rename'
           | 'replace'
           | 'return'
           | 'satisfies'
           | 'self'
           | 'some'
           | 'stable'
           | 'start'
           | 'to'
           | 'transform'
           | 'treat'
           | 'try'
           | 'union'
           | 'unordered'
           | 'update'
           | 'updating'
           | 'validate'
           | 'where'
           | 'with'
           | 'xquery'

referenced by:


RevalidationDecl:

declare revalidation strict lax skip

         ::= 'declare' 'revalidation' ( 'strict' | 'lax' | 'skip' )

referenced by:


InsertExprTargetChoice:

as first last into after before

         ::= ( 'as' ( 'first' | 'last' ) )? 'into'
           | 'after'
           | 'before'

referenced by:


InsertExpr:

insert node nodes SourceExpr InsertExprTargetChoice TargetExpr

         ::= 'insert' ( 'node' | 'nodes' ) SourceExpr InsertExprTargetChoice TargetExpr

referenced by:


DeleteExpr:

delete node nodes TargetExpr

         ::= 'delete' ( 'node' | 'nodes' ) TargetExpr

referenced by:


ReplaceExpr:

replace value of node TargetExpr with ExprSingle

         ::= 'replace' ( 'value' 'of' )? 'node' TargetExpr 'with' ExprSingle

referenced by:


RenameExpr:

rename node TargetExpr as NewNameExpr

         ::= 'rename' 'node' TargetExpr 'as' NewNameExpr

referenced by:


SourceExpr:

ExprSingle

         ::= ExprSingle

referenced by:


TargetExpr:

ExprSingle

         ::= ExprSingle

referenced by:


NewNameExpr:

ExprSingle

         ::= ExprSingle

referenced by:


UpdatingFunctionCall:

invoke updating PrimaryExpr ( ExprSingle , )

         ::= 'invoke'? 'updating' PrimaryExpr '(' ( ExprSingle ( ',' ExprSingle )* )? ')'

referenced by:


CopyModifyExpr:

copy CopyModifySpec , modify ExprSingle return ExprSingle

         ::= 'copy' CopyModifySpec ( ',' CopyModifySpec )* 'modify' ExprSingle 'return' ExprSingle

referenced by:


CopyModifySpec:

$ VarName := ExprSingle

         ::= '$' VarName ':=' ExprSingle

referenced by:


FTSelection:

FTOr FTPosFilter

         ::= FTOr FTPosFilter*

referenced by:


FTWeight:

weight { Expr }

FTWeight ::= 'weight' '{' Expr '}'

referenced by:


FTOr:

FTAnd ftor

FTOr     ::= FTAnd ( 'ftor' FTAnd )*

referenced by:


FTAnd:

FTMildNot ftand

FTAnd    ::= FTMildNot ( 'ftand' FTMildNot )*

referenced by:


FTMildNot:

FTUnaryNot in not

         ::= FTUnaryNot ( 'not' 'in' FTUnaryNot )*

referenced by:


FTUnaryNot:

ftnot FTPrimaryWithOptions

         ::= 'ftnot'? FTPrimaryWithOptions

referenced by:


FTPrimaryWithOptions:

FTPrimary FTMatchOptions FTWeight

         ::= FTPrimary FTMatchOptions? FTWeight?

referenced by:


FTPrimary:

FTWords FTTimes ( FTSelection ) FTExtensionSelection

         ::= FTWords FTTimes?
           | '(' FTSelection ')'
           | FTExtensionSelection

referenced by:


FTWords:

FTWordsValue FTAnyallOption

referenced by:


FTWordsValue:

StringLiteral { Expr }

         ::= StringLiteral
           | '{' Expr '}'

referenced by:


FTExtensionSelection:

Pragma { FTSelection }

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

referenced by:


FTAnyallOption:

any word all words phrase

         ::= 'any' 'word'?
           | 'all' 'words'?
           | 'phrase'

referenced by:


FTTimes:

occurs FTRange times

FTTimes  ::= 'occurs' FTRange 'times'

referenced by:


FTRange:

exactly from AdditiveExpr to at least most AdditiveExpr

FTRange  ::= ( 'exactly' | 'from' AdditiveExpr 'to' | 'at' ( 'least' | 'most' ) ) AdditiveExpr

referenced by:


FTPosFilter:

ordered FTWindow FTDistance FTScope FTContent

         ::= 'ordered'
           | FTWindow
           | FTDistance
           | FTScope
           | FTContent

referenced by:


FTWindow:

window AdditiveExpr FTUnit

referenced by:


FTDistance:

distance FTRange FTUnit

         ::= 'distance' FTRange FTUnit

referenced by:


FTUnit:

words sentences paragraphs

FTUnit   ::= 'words'
           | 'sentences'
           | 'paragraphs'

referenced by:


FTScope:

same different FTBigUnit

FTScope  ::= ( 'same' | 'different' ) FTBigUnit

referenced by:


FTBigUnit:

sentence paragraph

         ::= 'sentence'
           | 'paragraph'

referenced by:


FTContent:

at start end entire content

         ::= 'at' ( 'start' | 'end' )
           | 'entire' 'content'

referenced by:


FTMatchOptions:

using FTMatchOption

         ::= ( 'using' FTMatchOption )+

referenced by:


FTMatchOption:

FTLanguageOption FTWildCardOption FTThesaurusOption FTStemOption FTCaseOption FTDiacriticsOption FTStopWordOption FTExtensionOption

         ::= FTLanguageOption
           | FTWildCardOption
           | FTThesaurusOption
           | FTStemOption
           | FTCaseOption
           | FTDiacriticsOption
           | FTStopWordOption
           | FTExtensionOption

referenced by:


FTCaseOption:

case insensitive sensitive lowercase uppercase

         ::= 'case' ( 'insensitive' | 'sensitive' )
           | 'lowercase'
           | 'uppercase'

referenced by:


FTDiacriticsOption:

diacritics insensitive sensitive

         ::= 'diacritics' ( 'insensitive' | 'sensitive' )

referenced by:


FTStemOption:

no stemming

         ::= 'no'? 'stemming'

referenced by:


FTThesaurusOption:

thesaurus FTThesaurusID default ( FTThesaurusID default , FTThesaurusID ) no thesaurus

         ::= 'thesaurus' ( FTThesaurusID | 'default' | '(' ( FTThesaurusID | 'default' ) ( ',' FTThesaurusID )* ')' )
           | 'no' 'thesaurus'

referenced by:


FTThesaurusID:

at URILiteral relationship StringLiteral FTLiteralRange levels

         ::= 'at' URILiteral ( 'relationship' StringLiteral )? ( FTLiteralRange 'levels' )?

referenced by:


FTLiteralRange:

exactly from IntegerLiteral to at least most IntegerLiteral

         ::= ( 'exactly' | 'from' IntegerLiteral 'to' | 'at' ( 'least' | 'most' ) ) IntegerLiteral

referenced by:


FTStopWordOption:

stop words FTStopWords default FTStopWordsInclExcl no stop words

         ::= 'stop' 'words' ( FTStopWords | 'default' ) FTStopWordsInclExcl*
           | 'no' 'stop' 'words'

referenced by:


FTStopWords:

at URILiteral ( StringLiteral , )

         ::= 'at' URILiteral
           | '(' StringLiteral ( ',' StringLiteral )* ')'

referenced by:


FTStopWordsInclExcl:

union except FTStopWords

         ::= ( 'union' | 'except' ) FTStopWords

referenced by:


FTLanguageOption:

language StringLiteral

         ::= 'language' StringLiteral

referenced by:


FTWildCardOption:

no wildcards

         ::= 'no'? 'wildcards'

referenced by:


FTExtensionOption:

option EQName StringLiteral

         ::= 'option' EQName StringLiteral

referenced by:


FTIgnoreOption:

without content OtherwiseExpr

         ::= 'without' 'content' OtherwiseExpr

referenced by:


Comment:

(: CommentContents Comment :)

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

referenced by:


Whitespace:

S Comment

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

no references


NCName:

NCName and as ascending case cast castable collation count default descending div else empty end eq except for ge group gt idiv instance intersect is le let lt mod ne only or order return satisfies stable start to treat union updating where

           | 'and'
           | 'as'
           | 'ascending'
           | 'case'
           | 'cast'
           | 'castable'
           | 'collation'
           | 'count'
           | 'default'
           | 'descending'
           | 'div'
           | 'else'
           | 'empty'
           | 'end'
           | 'eq'
           | 'except'
           | 'for'
           | 'ge'
           | 'group'
           | 'gt'
           | 'idiv'
           | 'instance'
           | 'intersect'
           | 'is'
           | 'le'
           | 'let'
           | 'lt'
           | 'mod'
           | 'ne'
           | 'only'
           | 'or'
           | 'order'
           | 'return'
           | 'satisfies'
           | 'stable'
           | 'start'
           | 'to'
           | 'treat'
           | 'union'
           | 'updating'
           | 'where'

referenced by:


QueryBody:

Expr

         ::= Expr

referenced by:


Expr:

ExprSingle ,

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

referenced by:


ExprSingle:

FLWORExpr QuantifiedExpr SwitchExpr TypeswitchExpr IfExpr BasexIfExpr TryCatchExpr InsertExpr DeleteExpr RenameExpr ReplaceExpr UpdatingFunctionCall CopyModifyExpr OrExpr

         ::= FLWORExpr
           | QuantifiedExpr
           | SwitchExpr
           | TypeswitchExpr
           | IfExpr
           | BasexIfExpr
           | TryCatchExpr
           | InsertExpr
           | DeleteExpr
           | RenameExpr
           | ReplaceExpr
           | UpdatingFunctionCall
           | CopyModifyExpr
           | OrExpr

referenced by:


CommonContent:

PredefinedEntityRef CharRef {{ }} EnclosedExpr

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

referenced by:


CompDocConstructor:

document EnclosedExpr

         ::= 'document' EnclosedExpr

referenced by:


CompAttrConstructor:

attribute EQName { Expr } EnclosedExpr

         ::= 'attribute' ( EQName | '{' Expr '}' ) EnclosedExpr

referenced by:


CompPIConstructor:

processing-instruction NCName { Expr } EnclosedExpr

         ::= 'processing-instruction' ( NCName | '{' Expr '}' ) EnclosedExpr

referenced by:


CompCommentConstructor:

comment EnclosedExpr

         ::= 'comment' EnclosedExpr

referenced by:


CompTextConstructor:

text EnclosedExpr

         ::= 'text' EnclosedExpr

referenced by:


PrimaryExpr:

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

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

referenced by:


IntegerLiteral:

Digits

         ::= Digits

referenced by:


DecimalLiteral:

Digits . [0-9] . Digits

         ::= '.' Digits
           | Digits '.' [0-9]*
          /* ws: explicit */

referenced by:


DoubleLiteral:

Digits . [0-9] . Digits e E + [#x002D] Digits

         ::= ( '.' Digits | Digits ( '.' [0-9]* )? ) [eE] [+#x002D]? Digits
          /* ws: explicit */

referenced by:


StringLiteral:

" PredefinedEntityRef CharRef "" [^"&] " ' PredefinedEntityRef CharRef '' [^'&] '

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

referenced by:


URIQualifiedName:

BracedURILiteral NCName

         ::= BracedURILiteral NCName
          /* ws: explicit */

referenced by:


BracedURILiteral:

Q { PredefinedEntityRef CharRef [^&{}] }

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

referenced by:


PredefinedEntityRef:

& lt gt amp quot apos ;

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

referenced by:


ElementContentChar:

Char - [{}<&]

         ::= Char - [{}<&]

referenced by:


QuotAttrContentChar:

Char - ["{}<&]

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

referenced by:


AposAttrContentChar:

Char - ['{}<&]

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

referenced by:


PITarget:

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

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

referenced by:


NameStartChar:

: [A-Z] _ [a-z] [#x00C0-#x00D6] [#x00D8-#x00F6] [#x00F8-#x02FF] [#x0370-#x037D] [#x037F-#x1FFF] [#x200C-#x200D] [#x2070-#x218F] [#x2C00-#x2FEF] [#x3001-#xD7FF] [#xF900-#xFDCF] [#xFDF0-#xFFFD] [#x10000-#xEFFFF]

         ::= [:A-Z_a-z#x00C0-#x00D6#x00D8-#x00F6#x00F8-#x02FF#x0370-#x037D#x037F-#x1FFF#x200C-#x200D#x2070-#x218F#x2C00-#x2FEF#x3001-#xD7FF#xF900-#xFDCF#xFDF0-#xFFFD#x10000-#xEFFFF]

referenced by:


NameChar:

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

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

referenced by:


Name:

NameStartChar NameChar

referenced by:


CharRef:

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

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

referenced by:


NCName:

Name - ( Char* ':' Char* )

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

referenced by:


QName:

PrefixedName UnprefixedName

QName    ::= PrefixedName
           | UnprefixedName

referenced by:


PrefixedName:

Prefix : LocalPart

         ::= Prefix ':' LocalPart

referenced by:


UnprefixedName:

LocalPart

         ::= LocalPart

referenced by:


Prefix:

NCName

Prefix   ::= NCName

referenced by:


LocalPart:

NCName

         ::= NCName

referenced by:


StringConstructorChars:

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

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

referenced by:


S:

[#x0020] [#x0009] [#x000D] [#x000A]

S        ::= [#x0020#x0009#x000D#x000A]+

referenced by:


Char:

[#x0009] [#x000A] [#x000D] [#x0020-#xD7FF] [#xE000-#xFFFD] [#x10000-#x10FFFF]

Char     ::= [#x0009#x000A#x000D#x0020-#xD7FF#xE000-#xFFFD#x10000-#x10FFFF]

referenced by:


Digits:

[0-9]

Digits   ::= [0-9]+

referenced by:


CommentContents:

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

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

referenced by:


PragmaContents:

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

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

referenced by:


Wildcard:

BracedURILiteral * NCName :* *: NCName

           | NCName ':*'
           | '*:' NCName

referenced by:


DirCommentContents:

- Char - '-'

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

referenced by:


DirPIContents:

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

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

referenced by:


CDataSectionContents:

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

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

referenced by:


EOF:

$

EOF      ::= $

referenced by:


NonNCNameChar:

$ : Char - NameChar

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

referenced by:


DelimitingChar:

NonNCNameChar - .

         ::= NonNCNameChar
           | '-'
           | '.'

no references


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