[1] program unit ::=
program [2]
| module declaration [103]
[2] program [1] ::= program type [100]?, program-level declaration [108]?, preamble declaration [114]*, group member [95]*, identified group [93]*
[3] main process rule [96] ::=
process end rule [4]
| process rule [5]
| process start rule [6]
[4] process end rule [3] ::= PROCESS-END, condition [321]?, local scope [143]
[5] process rule [3] ::= PROCESS, condition [321]?, local scope [143]
[6] process start rule [3] ::= PROCESS-START, condition [321]?, local scope [143]
[7] markup processing rule [96] ::=
data content rule [8]
| document end rule [9]
| document start rule [10]
| dtd end rule [11]
| dtd start rule [12]
| element rule [13]
| epilog start rule [14]
| external data entity rule [15]
| invalid data rule [16]
| marked section rule [17]
| markup note rule [20]
| markup wrapper rule [21]
| processing instruction rule [22]
| prolog end rule [23]
| prolog in error rule [24]
| sgml comment processing rule [18]
| sgml declaration end rule [25]
| translation rule [26]
| xmlns-change rule [27]
[8] data content rule [7] ::= DATA-CONTENT, condition [321]?, local scope [143]
[9] document end rule [7] ::= DOCUMENT-END, condition [321]?, local scope [143]
[10] document start rule [7] ::= DOCUMENT-START, condition [321]?, local scope [143]
[11] dtd end rule [7] ::= DTD-END, condition [321]?, local scope [143]
[12] dtd start rule [7] ::= DTD-START, condition [321]?, local scope [143]
[13] element rule [7] ::= ELEMENT, (element rule name set [32] | #IMPLIED), condition [321]?, local scope [143]
[14] epilog start rule [7] ::= EPILOG-START, condition [321]?, local scope [143]
[15] external data entity rule [7] ::= (EXTERNAL-DATA-ENTITY | EXTERNAL-ENTITY), (entity name set [36] | #IMPLIED), condition [321]?, local scope [143]
[16] invalid data rule [7] ::= INVALID-DATA, condition [321]?, local scope [143]
[17] marked section rule [7] ::= MARKED-SECTION, marked section type [29], condition [321]?, local scope [143]
[18] sgml comment processing rule [7] ::= (MARKUP-COMMENT | SGML-COMMENT), condition [321]?, local scope [143]
[19] markup error rule [96] ::= (MARKUP-ERROR | SGML-ERROR), condition [321]?, LOG?, local scope [143]
[20] markup note rule [7] ::= MARKUP-NOTE, (sub-category name [30] | #IMPLIED), condition [321]?, local scope [143]
[21] markup wrapper rule [7] ::= MARKUP-WRAPPER, (sub-category name [30] | #IMPLIED), condition [321]?, local scope [143]
[22] processing instruction rule [7] ::= PROCESSING-INSTRUCTION, processing instruction matcher [28], condition [321]?, local scope [143]
[23] prolog end rule [7] ::= PROLOG-END, condition [321]?, local scope [143]
[24] prolog in error rule [7] ::= PROLOG-IN-ERROR, condition [321]?, local scope [143]
[25] sgml declaration end rule [7] ::= SGML-DECLARATION-END, condition [321]?, local scope [143]
[26] translation rule [7] ::= TRANSLATE, pattern expression [338], condition [321]?, local scope [143]
[27] xmlns-change rule [7] ::= XMLNS-CHANGE, condition [321]?, local scope [143]
[28] processing instruction matcher [22] ::=
pattern expression [338]
| NAMED, pattern expression [338], (VALUED, pattern expression [338])?
| VALUED, pattern expression [338], (NAMED, pattern expression [338])?
[29] marked section type [17] ::=
INCLUDE-START
| INCLUDE-END
| RCDATA
| CDATA
| IGNORE
[30] sub-category name [20] [21] ::=
DATATYPE
| NAMESPACE
| XMLNS
[31] element name set [40] [45] ::=
qualified element name [34]
| "(", qualified element name [34], ((OR | "|"), qualified element name [34])*, ")"
[32] element rule name set [13] ::=
restricted qualified element name [33]
| "(", restricted qualified element name [33], ((OR | "|"), restricted qualified element name [33])*, ")"
[33] restricted qualified element name [32] ::= (#BASE | #FULL)?, element name [35]
[34] qualified element name [31] [49] ::= (#BASE | #FULL | #XMLNS)?, element name [35]
[35] element name [33] [34] [42] ::=
constant string literal [279]
| name [460]
[36] entity name set [15] ::=
entity name [37]
| "(", entity name [37], ((OR | "|"), entity name [37])*, ")"
[37] entity name [36] [91] ::=
constant string literal [279]
| name [460]
[38] ancestry qualifier [39] [40] [43] [45] [55] [71] [73] [197] [220] [245] [247] ::= OF, specific element selector [40]
[39] anonymous element selector [45] ::=
aliased element selector [42]
| constrained element selector [43]
| element selection class [41], ancestry qualifier [38]?
[40] specific element selector [38] [266] ::=
aliased element selector [42]
| constrained element selector [43]
| element selection class [41], element name set [31], ancestry qualifier [38]?
[41] element selection class [39] [40] ::=
ANCESTOR
| OPEN, ELEMENT
| PREPARENT
[42] aliased element selector [39] [40] ::= CURRENT, ELEMENT, element name [35]
[43] constrained element selector [39] [40] ::=
DOCTYPE
| ELEMENT, ancestry qualifier [38]?
| PARENT, ancestry qualifier [38]?
[44] element alias [220] ::= name [460]
[45] element test primary [326] ::=
anonymous element selector [39], (IS | ISNT), element name set [31]
| short reference map selector [55], (IS | ISNT), short reference map name set [50]
| CONTENT, ancestry qualifier [38]?, (IS | ISNT), content type set [46]
| LAST, PROPER?, CONTENT, ancestry qualifier [38]?, (IS | ISNT), element name or data set [48]
| LAST, PROPER?, SUBELEMENT, ancestry qualifier [38]?, (IS | ISNT), element name set [31]
| PREVIOUS, ancestry qualifier [38]?, (IS | ISNT), element name set [31]
| STATUS, (OF, LAST, SUBELEMENT)?, ancestry qualifier [38]?, (IS | ISNT), (PROPER | INCLUSION)
[46] content type set [45] ::=
content type [47]
| "(", content type [47], ((OR | "|"), content type [47])*, ")"
[47] content type [46] ::=
ANY
| CDATA
| CONREF
| DECLARED-EMPTY
| ELEMENT
| EMPTY
| EMPTY-TAG
| MIXED
| RCDATA
[48] element name or data set [45] ::=
element name or data [49]
| "(", element name or data [49], ((OR | "|"), element name or data [49])*, ")"
[49] element name or data [48] ::=
qualified element name [34]
| #DATA
[50] short reference map name set [45] ::=
short reference map name [51]
| "(", short reference map name [51], ((OR | "|"), short reference map name [51])*, ")"
[51] short reference map name [50] ::=
constant string literal [279]
| name [460]
| #EMPTY
| #NONE
[52] entity test primary [326] ::=
qualified attribute part identifier [68], (IS | ISNT), entity category set [56]
| ENTITY, (IS | ISNT), entity category set [56]
| notation selector [54], (IS | ISNT), notation category set [58]
| notation selector [54], equivalence comparer [330], notation name set [66]
[53] entity selector [54] ::=
ENTITY
| qualified attribute part identifier [68]
[54] notation selector [52] ::= NOTATION, (OF, entity selector [53])?
[55] short reference map selector [45] ::= USEMAP, ancestry qualifier [38]?
[56] entity category set [52] ::=
entity category [57]
| "(", entity category [57], ((AND | "&"), entity category [57])*, ")"
| "(", entity category [57], ((OR | "|"), entity category [57])*, ")"
[57] entity category [56] ::=
anonymous entity type [64]
| default entity type [63]
| entity class [62]
| entity scope [65]
| entity type [61]
| external identifier type [60]
[58] notation category set [52] ::= notation category [59]
[59] notation category [58] ::= external identifier type [60]
[60] external identifier type [57] [59] ::=
PUBLIC
| SYSTEM
| IN-LIBRARY
[61] entity type [57] ::=
CDATA-ENTITY
| NDATA-ENTITY
| SDATA-ENTITY
| SUBDOC-ENTITY
[62] entity class [57] ::=
GENERAL
| PARAMETER
[63] default entity type [57] ::= DEFAULT-ENTITY
[64] anonymous entity type [57] [91] [92] ::=
#CAPACITY
| #CHARSET
| #DOCUMENT
| #DTD
| #SCHEMA
| #SYNTAX
[65] entity scope [57] ::=
INTERNAL
| EXTERNAL
[66] notation name set [52] ::=
notation name [67]
| "(", notation name [67], ((OR | "|"), notation name [67])*, ")"
[67] notation name [66] ::=
constant string literal [279]
| name [460]
[68] qualified attribute part identifier [52] [53] [71] [72] [73] [74] [266] ::=
complex qualified attribute identifier [72]
| simple qualified attribute identifier [71], item indexer [448]?
[69] qualified attribute identifier [83] [197] [220] [247] [268] ::=
complex qualified attribute identifier [72]
| simple qualified attribute identifier [71]
[70] qualified attribute set identifier [84] [220] [247] ::=
complex qualified attribute set identifier [74]
| simple qualified attribute set identifier [73]
[71] simple qualified attribute identifier [68] [69] [197] ::=
ATTRIBUTE, attribute name [77], ancestry qualifier [38]?
| DATA-ATTRIBUTE, attribute name [77], (OF, "(", qualified attribute part identifier [68], ")")?
[72] complex qualified attribute identifier [68] [69] ::=
simple qualified attribute set identifier [73], indexer [447]
| DATA-ATTRIBUTE, attribute name [77], OF, qualified attribute part identifier [68]
[73] simple qualified attribute set identifier [70] [72] [246] ::=
attribute subset specifier [75]?, ATTRIBUTES, ancestry qualifier [38]?
| attribute subset specifier [75]?, DATA-ATTRIBUTES, (OF, "(", qualified attribute part identifier [68], ")")?
[74] complex qualified attribute set identifier [70] ::= attribute subset specifier [75]?, DATA-ATTRIBUTES, OF, qualified attribute part identifier [68]
[75] attribute subset specifier [73] [74] ::=
NON-IMPLIED
| SPECIFIED
[76] attribute alias [220] ::= name [460]
[77] attribute name [71] [72] [197] [307] ::=
constant string literal [279]
| name [460]
[78] attribute type set [83] ::=
attribute type [79]
| "(", attribute type [79], ((AND | "&"), attribute type [79])*, ")"
| "(", attribute type [79], ((OR | "|"), attribute type [79])*, ")"
[79] attribute type [78] ::=
attribute declaration type [81]
| attribute default type [82]
| attribute specification type [80]
[80] attribute specification type [79] ::=
DEFAULTED
| IMPLIED
| SPECIFIED
[81] attribute declaration type [79] ::=
CDATA
| ENTITY
| ENTITIES
| GROUP
| ID
| IDREF
| IDREFS
| NAME
| NAMES
| NOTATION
| NUMBER
| NUMBERS
| NMTOKEN
| NMTOKENS
| NUTOKEN
| NUTOKENS
[82] attribute default type [79] ::=
DECLARED-CONREF
| DECLARED-CURRENT
| DECLARED-DEFAULTED
| DECLARED-FIXED
| DECLARED-IMPLIED
| DECLARED-REQUIRED
[83] attribute test primary [326] ::= qualified attribute identifier [69], (IS | ISNT), attribute type set [78]
[84] attributes test primary [326] ::= qualified attribute set identifier [70], (HAS | HASNT), (KEY | "^"), string primary [266]
[85] input processing rule [96] ::=
find rule [87]
| find end rule [86]
| find start rule [88]
| external text entity rule [90]
[86] find end rule [85] ::= FIND-END, condition [321]?, local scope [143]
[87] find rule [85] ::= FIND, NULL?, pattern expression [338], condition [321]?, local scope [143]
[88] find start rule [85] ::= FIND-START, condition [321]?, local scope [143]
[89] extended entity name set [90] ::=
extended entity name [91]
| "(", extended entity name [91], ((OR | "|"), extended entity name [91])*, ")"
[90] external text entity rule [85] ::= EXTERNAL-TEXT-ENTITY, (extended entity name set [89] | implied entity type set [92]), condition [321]?, local scope [143]
[91] extended entity name [89] ::=
entity name [37]
| anonymous entity type [64]
[92] implied entity type set [90] ::=
#IMPLIED
| "(", (anonymous entity type [64], (OR | "|"))*, #IMPLIED, ((OR | "|"), anonymous entity type [64])*, ")"
[93] identified group [2] ::=
GROUP, group identification [94], group member [95]*
| GROUP, "(", group identification [94], ")", group member [95]*
[94] group identification [93] ::=
group name set [97]
| #IMPLIED
[95] group member [2] [93] ::=
common declaration [115]
| include [101]
| rule [96]
[96] rule [95] ::=
markup processing rule [7]
| input processing rule [85]
| line breaking rule [127]
| main process rule [3]
| markup error rule [19]
[97] group name set [94] [99] [168] ::= group name [98], ((AND | "&"), group name [98])*
[98] group name [97] ::=
constant string literal [279]
| name [460]
[99] current group set [198] ::=
group name set [97]
| #GROUP, ((AND | "&"), group name set [97])?
| #IMPLIED
[100] program type [2] ::=
(CONTEXT-TRANSLATE | DOWN-TRANSLATE | UP-TRANSLATE), (WITH, (SGML | XML))?
| CROSS-TRANSLATE
[101] include [95] ::= INCLUDE, constant string literal [279]
[102] include guard declaration [115] ::= INCLUDE-GUARD, (name [460] | constant string literal [279])
[103] module declaration [1] ::= MODULE, (SHARED, AS, name [460])?
[104] import declaration [115] ::=
IMPORT, constant string expression [274], EXPORT?, PREFIXED, BY, name [460], use clause [105]*, supply clause [106]*
| IMPORT, constant string expression [274], EXPORT?, UNPREFIXED, use clause [105]*, supply clause [106]*
| IMPORT, constant string expression [274], ONLY, use clause [105]+, supply clause [106]*
[105] use clause [104] ::=
EXPORT?, USE, name [460], (AS, name [460])?
| EXPORT?, USE, #CONVERSION-FUNCTIONS
[106] supply clause [104] ::= SUPPLY, name [460], (AS, name [460])?
[107] library declaration [115] ::= LIBRARY, (constant string expression [274], constant string expression [274])+
[108] program-level declaration [2] ::=
default io declaration [109]
| escape declaration [110]
| main buffering declaration [111]*
| main mode declaration [112]*
| main output referent declaration [113]
[109] default io declaration [108] ::= DECLARE, NO-DEFAULT-IO
[110] escape declaration [108] [469] ::= ESCAPE, constant string expression [274]
[111] main buffering declaration [108] ::= DECLARE, (#ERROR | #MAIN-INPUT | #MAIN-OUTPUT | #PROCESS-INPUT | #PROCESS-OUTPUT), HAS, (BUFFERED | UNBUFFERED)
[112] main mode declaration [108] ::= DECLARE, (#MAIN-INPUT | #MAIN-OUTPUT | #PROCESS-INPUT | #PROCESS-OUTPUT), HAS, (BINARY-MODE | TEXT-MODE)
[113] main output referent declaration [108] ::= DECLARE, #MAIN-OUTPUT, HAS, (REFERENTS-ALLOWED | REFERENTS-NOT-ALLOWED | REFERENTS-DISPLAYED)
[114] preamble declaration [2] ::=
common declaration [115]
| global object definition [116]
| naming declaration [119]
[115] common declaration [95] [114] ::=
binary input declaration [117]
| binary output declaration [118]
| delimiter declaration [304]
| import declaration [104]
| include guard declaration [102]
| library declaration [107]
| macro definition [452]
| output break declaration [126]
| symbol declaration [303]
[116] global object definition [114] ::=
catch definition [402]
| function definition [356]
| global shelf definition [426]
| require function definition [367]
| require shelf definition [427]
| user-defined type declaration [131]
[117] binary input declaration [115] ::= BINARY-INPUT, constant numeric expression [249]
[118] binary output declaration [115] ::= BINARY-OUTPUT, constant numeric expression [249]
[119] naming declaration [114] ::=
data letters declaration [120]
| entity namecase declaration [121]
| general namecase declaration [122]
| markup identification declaration [123]
| name letters declaration [124]
| newline declaration [125]
[120] data letters declaration [119] ::=
DECLARE, DATA-LETTERS, constant string expression [274], constant string expression [274]?
| LETTERS, constant string expression [274], constant string expression [274]?
[121] entity namecase declaration [119] ::= NAMECASE, ENTITY, (YES | NO)
[122] general namecase declaration [119] ::= NAMECASE, GENERAL, (YES | NO)
[123] markup identification declaration [119] ::= DECLARE, MARKUP-IDENTIFICATION, (#FULL | #BASE)
[124] name letters declaration [119] ::= DECLARE, NAME-LETTERS, constant string expression [274], constant string expression [274]
[125] newline declaration [119] ::= NEWLINE, constant string expression [274]
[126] output break declaration [115] ::= BREAK-WIDTH, constant numeric expression [249], (number [248] | TO, constant numeric expression [249])?
[127] line breaking rule [96] ::=
insertion break rule [128]
| replacement break rule [129]
[128] insertion break rule [127] ::= INSERTION-BREAK, constant string expression [274], condition [321]?
[129] replacement break rule [127] ::= REPLACEMENT-BREAK, constant string expression [274], constant string expression [274], condition [321]?
[130] first-class type [358] [359] [361] [362] [363] [365] [379] [380] [381] [382] [383] [384] [427] ::=
user-defined type name [137]
| COUNTER
| INTEGER
| INT32
| STREAM
| SWITCH
[131] user-defined type declaration [116] ::=
opaque type declaration [132]
| record type declaration [133]
| user-defined type require [136]
[132] opaque type declaration [131] ::= (DECLARE | EXPORT), OPAQUE, user-defined type name [137], CREATED, BY, system-specific function name [472], (IN, FUNCTION-LIBRARY, system-specific library name [473])?
[133] record type declaration [131] ::= (DECLARE | EXPORT, (AS, OPAQUE)?), RECORD, user-defined type name [137], (record type inheritance clause [134]?, field declaration [135]* | ELSEWHERE)
[134] record type inheritance clause [133] ::= EXTENDS, user-defined type name [137]
[135] field declaration [133] ::= FIELD, shelf declaration [432]
[136] user-defined type require [131] ::= REQUIRE, OPAQUE, user-defined type name [137]
[137] user-defined type name [130] [132] [133] [134] [136] [140] [211] [377] [400] [436] ::= name [460]
[138] user-defined type expression [211] [235] [396] ::=
boolean term [324], "->", user-defined type expression [138], "|", user-defined type expression [138]
| user-defined type subexpression [139]
[139] user-defined type subexpression [138] [141] ::=
argument primary [395], (user-defined infix function name [468], argument primary [395])+
| user-defined type primary [140]
[140] user-defined type primary [139] [395] ::=
user-defined type name [137], CAST, user-defined type primary [140]
| value function call [389]
| shelf item reference [443]
[141] user-defined type test primary [326] ::= user-defined type subexpression [139], (reference comparer [142], user-defined type subexpression [139])+
[142] reference comparer [141] ::=
"=="
| "!=="
[143] local scope [4] [5] [6] [8] [9] [10] [11] [12] [13] [14] [15] [16] [17] [18] [19] [20] [21] [22] [23] [24] [25] [26] [27] [86] [87] [88] [90] [204] [205] [207] [208] [211] [212] [213] [214] [219] [222] [223] [225] [226] [388] ::= local declaration [428]*, action [146]*, catch alternative [145]*, always block [144]*
[144] always block [143] ::= ALWAYS, action [146]*
[145] catch alternative [143] ::= CATCH, (built-in catch invocation [409] | catch invocation [412]), action [146]*
[146] action [143] [144] [145] ::= using prefix [196]*, guarded action [147]
[147] guarded action [146] ::= basic action [148], condition [321]?
[148] basic action [147] ::=
activate action [149]
| assert action [150]
| clear action [151]
| close action [152]
| collect garbage action [153]
| copy action [154]
| copy and clear action [155]
| deactivate action [156]
| decrement action [157]
| discard action [158]
| do action [204]
| do conditional action [205]
| do markup parse action [206]
| do scan action [207]
| do select action [208]
| do select-type action [211]
| do skip action [212]
| exit action [159]
| fail action [160]
| flush action [161]
| void function call [390]
| halt action [164]
| increment action [165]
| log-message action [166]
| new action [167]
| next group action [168]
| not reached action [169]
| open action [170]
| output action [171]
| output to action [172]
| put action [175]
| remove action [178]
| remove key action [179]
| reopen action [180]
| repeat action [213]
| repeat for action [214]
| repeat over action [219]
| repeat scan action [221]
| reset action [181]
| return action [182]
| set action [183]
| set external function association action [398]
| set key action [184]
| set new action [185]
| set stream action [186]
| sgml in action [188]
| sgml out action [189]
| signal action [190]
| submit action [191]
| succeed action [192]
| suppress action [193]
| test system action [194]
| throw action [195]
[149] activate action [148] ::= ACTIVATE, (shelf item reference [443], ((AND | "&"), shelf item reference [443])* | "(", shelf item reference [443], ((AND | "&"), shelf item reference [443])*, ")")
[150] assert action [148] ::= ASSERT, boolean expression [322], (MESSAGE, string expression [261])?
[151] clear action [148] ::= CLEAR, shelf reference [444], ((AND | "&"), shelf reference [444])*
[152] close action [148] ::= CLOSE, shelf item reference [443], ((AND | "&"), shelf item reference [443])*
[153] collect garbage action [148] ::= COLLECT-GARBAGE
[154] copy action [148] ::= COPY, shelf reference [444], TO, shelf reference [444]
[155] copy and clear action [148] ::= COPY-CLEAR, shelf reference [444], TO, shelf reference [444]
[156] deactivate action [148] ::= DEACTIVATE, (shelf item reference [443], ((AND | "&"), shelf item reference [443])* | "(", shelf item reference [443], ((AND | "&"), shelf item reference [443])*, ")")
[157] decrement action [148] ::= DECREMENT, shelf item reference [443], (BY, numeric expression [236])?
[158] discard action [148] ::= DISCARD, shelf item reference [443], ((AND | "&"), shelf item reference [443])*
[159] exit action [148] ::= EXIT
[160] fail action [148] ::= FAIL
[161] flush action [148] ::= FLUSH, unmodified output stream set [162]
[162] unmodified output stream set [161] ::= unmodified output stream [163], ((AND | "&"), unmodified output stream [163])*
[163] unmodified output stream [162] ::=
built-in output stream shelf name [299]
| shelf item reference [443]
[164] halt action [148] ::= (HALT | HALT-EVERYTHING), (WITH, numeric expression [236])?
[165] increment action [148] ::= INCREMENT, shelf item reference [443], (BY, numeric expression [236])?
[166] log-message action [148] ::= LOG-MESSAGE, string expression [261], (CLASS, string expression [261])?, (SEVERITY, numeric expression [236])?
[167] new action [148] ::= NEW, new shelf item reference [442], ((AND | "&"), new shelf item reference [442])*
[168] next group action [148] ::= NEXT, GROUP, IS, (group name set [97] | "(", group name set [97], ")")
[169] not reached action [148] ::= NOT-REACHED, (MESSAGE, string expression [261])?
[170] open action [148] ::= OPEN, (shelf item reference [443] | new shelf item reference [442]), stream attachment modifier set [415]?, break modifier [425]?, AS, stream attachment [414]
[171] output action [148] ::= OUTPUT, string expression [261]
[172] output to action [148] ::= OUTPUT-TO, modified sink set [173]
[173] modified sink set [172] [201] ::= modified sink [174], ((AND | "&"), modified sink [174])*
[174] modified sink [173] ::=
built-in output stream shelf name [299]
| shelf item reference [443], stream output modifier set [419]?
| stream attachment [414], stream output modifier set [419]?
[175] put action [148] ::= PUT, modified output stream set [176], string expression [261]
[176] modified output stream set [175] ::= modified output stream [177], ((AND | "&"), modified output stream [177])*
[177] modified output stream [176] ::=
built-in output stream shelf name [299]
| shelf item reference [443], stream output modifier set [419]?
[178] remove action [148] ::= REMOVE, shelf item reference [443]
[179] remove key action [148] ::= REMOVE, (KEY | "^"), OF, shelf item reference [443]
[180] reopen action [148] ::= REOPEN, (shelf item reference [443], stream attachment modifier set [415]?, break modifier [425]?, (AS, stream attachment [414])? | new shelf item reference [442], stream attachment modifier set [415]?, break modifier [425]?, AS, stream attachment [414])
[181] reset action [148] ::= RESET, shelf item reference [443], (TO, numeric expression [236])?
[182] return action [148] ::= RETURN, expression [235]?
[183] set action [148] ::= SET, shelf item reference [443], TO, expression [235]
[184] set key action [148] ::= SET, (KEY | "^"), OF, shelf item reference [443], TO, string expression [261]
[185] set new action [148] ::= SET, NEW, new shelf item reference [442], protected set stream modifier set [417]?, TO, expression [235]
[186] set stream action [148] ::= SET, settable stream [187], protected set stream modifier set [417]?, TO, string expression [261]
[187] settable stream [186] ::=
stream attachment [414]
| THIS, REFERENT
[188] sgml in action [148] ::= SGML-IN, (string expression [261] | #NONE)
[189] sgml out action [148] ::= SGML-OUT, (string expression [261] | #NONE)
[190] signal action [148] ::= SIGNAL, catch invocation [412]
[191] submit action [148] ::= SUBMIT, string expression [261]
[192] succeed action [148] ::= SUCCEED
[193] suppress action [148] ::= SUPPRESS
[194] test system action [148] ::= TEST-SYSTEM, (WITH, string expression [261])?
[195] throw action [148] ::=
THROW, catch invocation [412]
| RETHROW
[196] using prefix [146] ::=
using attribute association prefix [197]
| using group prefix [198]
| using input prefix [199]
| using nested-referents prefix [200]
| using output prefix [201]
| using referents association prefix [202]
| using shelf item association prefix [203]
[197] using attribute association prefix [196] ::= USING, qualified attribute identifier [69], (AS, attribute name [77])?
The alias, attribute name [77], is required if the qualified attribute identifier [69] is a simple qualified attribute identifier [71] that doesn't have an ancestry qualifier [38] (if using ATTRIBUTE) and doesn't have an OF part (if using DATA-ATTRIBUTE).
[198] using group prefix [196] ::=
USING, GROUP, current group set [99]
| USING, GROUP, "(", current group set [99], ")"
[199] using input prefix [196] ::= USING, INPUT, AS, string expression [261]
[200] using nested-referents prefix [196] ::= USING, NESTED-REFERENTS
[201] using output prefix [196] ::= USING, OUTPUT, AS, modified sink set [173]
[202] using referents association prefix [196] ::= USING, REFERENTS, indexer [447]
[203] using shelf item association prefix [196] ::= USING, shelf item reference [443], AS, shelf name [446]
[204] do action [148] ::= DO, local scope [143], DONE
[205] do conditional action [148] ::= DO, condition [321], local scope [143], (ELSE, condition [321], local scope [143])*, (ELSE, local scope [143], DONE)?
[206] do markup parse action [148] ::=
do generic parse action [225]
| do sgml parse action [223]
| do xml parse action [226]
[207] do scan action [148] ::= DO, SCAN, string expression [261], match alternative [222]+, (ELSE, local scope [143])?, DONE
[208] do select action [148] ::= DO, SELECT, numeric expression [236], (CASE, constant numeric range set [209], local scope [143])+, (ELSE, local scope [143])?, DONE
[209] constant numeric range set [208] ::=
constant numeric range [210], ((OR | "|"), constant numeric range [210])*
| "(", constant numeric range [210], ((OR | "|"), constant numeric range [210])*, ")"
[210] constant numeric range [209] ::= constant numeric expression [249], (TO, constant numeric expression [249])?
[211] do select-type action [148] ::= DO, SELECT-TYPE, user-defined type expression [138], AS, shelf alias [445], (CASE, user-defined type name [137], local scope [143])+, (ELSE, local scope [143])?, DONE
[212] do skip action [148] ::= DO, SKIP, (OVER, pattern expression [338] | PAST, numeric expression [236], (OVER, pattern expression [338])?), local scope [143], (ELSE, local scope [143])?, DONE
[213] repeat action [148] ::= REPEAT, local scope [143], AGAIN
[214] repeat for action [148] ::= REPEAT, for part [215]?, from part [216]?, to part [217]?, by part [218]?, local scope [143], AGAIN
[215] for part [214] ::= FOR, INTEGER, shelf alias [445]
[216] from part [214] ::= FROM, numeric expression [236]
[217] to part [214] ::= TO, numeric expression [236]
[218] by part [214] ::= BY, numeric expression [236]
[219] repeat over action [148] ::= REPEAT, OVER, repeat over component [220], ((AND | "&"), repeat over component [220])*, local scope [143], AGAIN
[220] repeat over component [219] ::=
qualified attribute identifier [69], (AS, attribute alias [76])?
| qualified attribute set identifier [70], (AS, attribute alias [76])?
| shelf reference [444], (AS, shelf alias [445])?
| REFERENTS
| REVERSED?, CURRENT, ELEMENTS, ancestry qualifier [38]?, element alias [44]
[221] repeat scan action [148] ::= REPEAT, SCAN, string expression [261], match alternative [222]+, AGAIN
[222] match alternative [207] [221] ::= MATCH, UNANCHORED?, NULL?, pattern expression [338], condition [321]?, local scope [143]
[223] do sgml parse action [206] ::= DO, SGML-PARSE, sgml parse type [224], SCAN, sgml parse scanning source [233], local scope [143], DONE
[224] sgml parse type [223] ::=
(DOCUMENT | SUBDOCUMENT), (WITH, ID-CHECKING, boolean expression [322])?, (WITH, UTF-8, boolean expression [322])?, (CREATING, sgml dtd pseudo-shelf item [230])?
| INSTANCE, instance element specifier [228]?, sgml dtd specifier [229], (WITH, ID-CHECKING, boolean expression [322])?, (WITH, UTF-8, boolean expression [322])?
[225] do generic parse action [206] ::= DO, MARKUP-PARSE, void function call [390], local scope [143], DONE
[226] do xml parse action [206] ::= DO, XML-PARSE, xml parse type [227]?, SCAN, sgml parse scanning source [233], local scope [143], DONE
[227] xml parse type [226] ::=
DOCUMENT, (WITH, ID-CHECKING, boolean expression [322])?, (WITH, UTF-8, boolean expression [322])?, (CREATING, xml dtd pseudo-shelf item [232])?
| INSTANCE, instance element specifier [228]?, xml dtd specifier [231], (WITH, ID-CHECKING, boolean expression [322])?, (WITH, UTF-8, boolean expression [322])?
[228] instance element specifier [224] [227] ::= WITH, DOCUMENT-ELEMENT, string expression [261]
[229] sgml dtd specifier [224] ::= WITH, (sgml dtd pseudo-shelf item [230] | CURRENT, (DTD | SGML-DTD))
[230] sgml dtd pseudo-shelf item [224] [229] ::= (DTDS | SGML-DTDS), indexer [447]
[231] xml dtd specifier [227] ::= WITH, (xml dtd pseudo-shelf item [232] | CURRENT, XML-DTD)
[232] xml dtd pseudo-shelf item [227] [231] ::= XML-DTDS, indexer [447]
[233] sgml parse scanning source [223] [226] ::=
INPUT, void function call [390]
| string expression [261]
[234] dtd pool test primary [326] ::= (DTDS | SGML-DTDS | XML-DTDS), (HAS | HASNT), (KEY | "^"), string expression [261]
[235] expression [182] [183] [185] ::=
boolean expression [322]
| numeric expression [236]
| string expression [261]
| user-defined type expression [138]
[236] numeric expression [157] [164] [165] [166] [181] [208] [212] [216] [217] [218] [235] [245] [348] [374] [396] [440] [448] ::=
boolean term [324], "->", numeric expression [236], "|", numeric expression [236]
| numeric subexpression [237]
[237] numeric subexpression [236] [256] [257] [258] [259] [263] [264] [424] [425] ::= numeric term [239], (numeric additive operator [238], numeric term [239])*
[238] numeric additive operator [237] [249] ::=
PLUS
| "+"
| MINUS
| "-"
| UNION
| DIFFERENCE
[239] numeric term [237] ::= numeric factor [241], (numeric multiplicative operator [240], numeric factor [241])*
[240] numeric multiplicative operator [239] [250] ::=
TIMES
| "*"
| DIVIDE
| "/"
| MODULO
| MASK
| SHIFT
[241] numeric factor [239] ::= numeric tertiary [242], ("**", numeric factor [241])?
[242] numeric tertiary [241] ::=
numeric secondary [244]
| string secondary [265], (numeric conversion operator [243], numeric secondary [244])?
[243] numeric conversion operator [242] [252] ::=
BASE
| BINARY
[244] numeric secondary [242] ::=
argument primary [395], (user-defined infix function name [468], argument primary [395])+
| numeric primary [245]
[245] numeric primary [244] [395] [448] ::=
value function call [389]
| string primary [266]
| (NEGATE | "-"), numeric primary [245]
| COMPLEMENT, numeric primary [245]
| built-in read-only numeric shelf name [260]
| shelf item reference [443]
| BINARY, string primary [266]
| CHILDREN, ancestry qualifier [38]?
| (ITEM, OF | "@", OF), item-of reference [246]
| LENGTH, OF, string primary [266]
| (NUMBER, OF | NUMBER-OF), number-of reference [247]
| OCCURRENCE, ancestry qualifier [38]?
| SYSTEM-CALL, string primary [266]
| number [248]
| "(", numeric expression [236], ")"
[246] item-of reference [245] ::=
shelf item reference [443]
| simple qualified attribute set identifier [73], key indexer [449]
| REFERENTS, key indexer [449]
| THIS, REFERENT
[247] number-of reference [245] ::=
qualified attribute identifier [69]
| qualified attribute set identifier [70]
| shelf reference [444]
| CURRENT, ELEMENTS, ancestry qualifier [38]?
| CURRENT, SUBDOCUMENTS
| REFERENTS
[248] number [126] [245] [253] [284] [285] [306] [307] [308] [311] [312] [316] [317] [319] [320] [425] [459] [471] ::= digit [462]+
[249] constant numeric expression [117] [118] [126] [210] [253] [276] [437] [438] ::= constant numeric term [250], (numeric additive operator [238], constant numeric term [250])*
[250] constant numeric term [249] ::= constant numeric factor [251], (numeric multiplicative operator [240], constant numeric factor [251])*
[251] constant numeric factor [250] ::= constant numeric secondary [252], ("**", constant numeric factor [251])?
[252] constant numeric secondary [251] ::=
constant numeric primary [253]
| constant string primary [277], numeric conversion operator [243], constant numeric primary [253]
[253] constant numeric primary [252] [275] ::=
constant string primary [277]
| (NEGATE | "-"), constant numeric primary [253]
| COMPLEMENT, constant numeric primary [253]
| BINARY, constant string primary [277]
| LENGTH, OF, constant string primary [277]
| number [248]
| "(", constant numeric expression [249], ")"
[254] numeric test primary [326] ::= VALUE?, full numeric test [255]
[255] full numeric test [254] ::=
ascending numeric comparison [256]
| descending numeric comparison [257]
| equality numeric comparison [258]
| inequality numeric comparison [259]
[256] ascending numeric comparison [255] ::= numeric subexpression [237], (equality comparer [331], numeric subexpression [237])*, strongly ascending comparer [335], numeric subexpression [237], (weakly ascending comparer [333], numeric subexpression [237])*
[257] descending numeric comparison [255] ::= numeric subexpression [237], (equality comparer [331], numeric subexpression [237])*, strongly descending comparer [336], numeric subexpression [237], (weakly descending comparer [334], numeric subexpression [237])*
[258] equality numeric comparison [255] ::= numeric subexpression [237], (equality comparer [331], numeric subexpression [237])+
[259] inequality numeric comparison [255] ::= numeric subexpression [237], inequality comparer [332], numeric subexpression [237]
[260] built-in read-only numeric shelf name [245] ::=
#CLASS
| #ERROR-CODE
| #ITEM
| #LINE-NUMBER
| #MARKUP-ERROR-COUNT
| #MARKUP-ERROR-TOTAL
| #MARKUP-WARNING-COUNT
| #MARKUP-WARNING-TOTAL
| #SGML-ERROR-COUNT
| #SGML-ERROR-TOTAL
| #SGML-WARNING-COUNT
| #SGML-WARNING-TOTAL
[261] string expression [150] [166] [169] [171] [175] [184] [186] [188] [189] [191] [194] [199] [207] [221] [228] [233] [234] [235] [266] [295] [375] [376] [396] [414] [423] [441] [449] [472] [473] ::=
boolean term [324], "->", string expression [261], "|", string expression [261]
| string subexpression [262]
[262] string subexpression [261] [290] [291] [292] [293] [294] [295] ::= string term [263], ((JOIN | "||"), string term [263])*
[263] string term [262] ::=
string factor [264], ((REPEATED | "||*"), numeric subexpression [237])*
| string factor [264], TAKE, UNANCHORED?, pattern secondary [342]
| string factor [264], DROP, UNANCHORED?, pattern secondary [342]
| REFERENT, string primary [266]
| SILENT-REFERENT, string primary [266]
[264] string factor [263] ::= string secondary [265], ((FORMAT | "%"), (numeric subexpression [237] | string secondary [265]))*
[265] string secondary [242] [264] ::=
argument primary [395], (user-defined infix function name [468], argument primary [395])+
| string primary [266]
[266] string primary [84] [245] [263] [265] [296] [345] [395] [449] [451] ::=
stream input/output mode [269]?, value function call [389]
| SOURCE?, built-in read-only source shelf name [302]
| built-in read-only stream shelf name [300]
| built-in read-write stream shelf name [301]
| constant string value [278]
| external function association enquiry [399]
| pattern name [344]
| qualified attribute part identifier [68]
| referent item reference [267]
| shelf item reference [443]
| stream input/output mode [269]?, FILE, string primary [266]
| DATE, string primary [266]
| (KEY, OF | "^", OF), key-of reference [268]
| NAME, OF, shelf item reference [443]
| NAME, OF, specific element selector [40]
| XMLNS-NAME, (OF, specific element selector [40])?
| "~", string primary [266]
| string literal [270]
| "(", string expression [261], ")"
[267] referent item reference [266] ::=
REFERENTS, indexer [447]
| THIS, REFERENT
[268] key-of reference [266] ::=
qualified attribute identifier [69]
| shelf item reference [443]
| REFERENTS, item indexer [448]
| THIS, REFERENT
[269] stream input/output mode [266] ::=
(BUFFERED | UNBUFFERED), (TEXT-MODE | BINARY-MODE)?
| (TEXT-MODE | BINARY-MODE), (BUFFERED | UNBUFFERED)?
[270] string literal [266] [345] [459] ::= string literal part [271], ("_", string literal part [271])*
[271] string literal part [270] ::=
double-quoted string literal part [272]
| single-quoted string literal part [273]
[272] double-quoted string literal part [271] ::= """, (described character [284] | described substring [285] | escaped text [283] | format item [305] | unescaped character [470] | "'")*, """
[273] single-quoted string literal part [271] ::= "'", (described character [284] | described substring [285] | escaped text [283] | format item [305] | unescaped character [470] | """)*, "'"
[274] constant string expression [104] [107] [110] [120] [124] [125] [128] [129] [277] [303] [304] ::= constant string term [275], ((JOIN | "||"), constant string term [275])*
[275] constant string term [274] ::= constant string factor [276], ((REPEATED | "||*"), constant numeric primary [253])?
[276] constant string factor [275] ::= constant string primary [277], ((FORMAT | "%"), (constant numeric expression [249] | constant string primary [277]))*
[277] constant string primary [252] [253] [276] [278] [353] ::=
constant string value [278]
| constant string literal [279]
| "(", constant string expression [274], ")"
[278] constant string value [266] [277] ::= COMPILED-DATE, constant string primary [277]
[279] constant string literal [35] [37] [51] [67] [77] [98] [101] [102] [277] [424] ::= constant string literal part [280], ("_", constant string literal part [280])*
[280] constant string literal part [279] ::=
double-quoted constant string literal part [281]
| single-quoted constant string literal part [282]
[281] double-quoted constant string literal part [280] ::= """, (described character [284] | described substring [285] | escaped text [283] | unescaped character [470] | "'")*, """
[282] single-quoted constant string literal part [280] ::= "'", (described character [284] | described substring [285] | escaped text [283] | unescaped character [470] | """)*, "'"
[283] escaped text [272] [273] [281] [282] ::= escape [469], (escape [469] | """ | "'" | "#" | ")")
[284] described character [272] [273] [281] [282] ::=
escape [469], "_"
| escape [469], "n"
| escape [469], "t"
| escape [469], number [248], "#"
[285] described substring [272] [273] [281] [282] [471] ::= escape [469], number [248], "r", "{", describing number [471], (",", describing number [471])*, "}"
[286] stream test primary [326] ::=
shelf item reference [443], (HAS | HASNT), NAME
| shelf item reference [443], (IS | ISNT), stream type set [287]
| #CURRENT-OUTPUT, (IS | ISNT), ATTACHED
| OUTPUT, (IS | ISNT), stream type set [287]
| SGML, (IS | ISNT), stream type set [287]
The use of the OUTPUT and SGML keywords is deprecated in favour of #MAIN-OUTPUT and #SGML or #MARKUP-PARSER, respectively.
[287] stream type set [286] ::=
stream type [288]
| "(", stream type [288], ((AND | "&"), stream type [288])*, ")"
| "(", stream type [288], ((OR | "|"), stream type [288])*, ")"
[288] stream type [287] ::=
ATTACHED
| BUFFER
| CLOSED
| EXTERNAL
| FILE
| MARKUP-PARSER
| OPEN
| REFERENT
| SGML-PARSER
SGML-PARSER is deprecated in favour of the more general MARKUP-PARSER.
[289] string test primary [326] ::=
ascending string comparison [290]
| descending string comparison [291]
| equality string comparison [292]
| inequality string comparison [293]
| string match test primary [294]
| string set test primary [295]
[290] ascending string comparison [289] ::= string subexpression [262], (equality comparer [331], string subexpression [262])*, strongly ascending comparer [335], string subexpression [262], (weakly ascending comparer [333], string subexpression [262])*
[291] descending string comparison [289] ::= string subexpression [262], (equality comparer [331], string subexpression [262])*, strongly descending comparer [336], string subexpression [262], (weakly descending comparer [334], string subexpression [262])*
[292] equality string comparison [289] ::= string subexpression [262], (equality comparer [331], string subexpression [262])+
[293] inequality string comparison [289] ::= string subexpression [262], inequality comparer [332], string subexpression [262]
[294] string match test primary [289] ::= string subexpression [262], MATCHES, UNANCHORED?, pattern secondary [342]
[295] string set test primary [289] ::=
string subexpression [262], comparer [329], UL, string subexpression [262]
| string subexpression [262], comparer [329], UL?, "(", string expression [261], ((OR | "|"), string expression [261])*, ")"
[296] source test primary [326] ::=
FILE, string primary [266], EXISTS
| FILE, string primary [266], (IS | ISNT), file info enquiry set [297]
| #CURRENT-INPUT, (IS | ISNT), ATTACHED
[297] file info enquiry set [296] ::=
file info enquiry [298]
| "(", file info enquiry [298], ((AND | "&"), file info enquiry [298])*, ")"
[298] file info enquiry [297] ::=
DIRECTORY
| FILE
| READABLE
| WRITABLE
[299] built-in output stream shelf name [163] [174] [177] ::=
#CONSOLE
| #CURRENT-OUTPUT
| #ERROR
| #SUPPRESS
| #MAIN-OUTPUT
| #OUTPUT
| #SGML
| #MARKUP-PARSER
| OUTPUT
| SGML
The use of the OUTPUT and SGML keywords is deprecated in favour of #MAIN-OUTPUT and #SGML or #MARKUP-PARSER, respectively.
The use of the #OUTPUT keyword is deprecated in favour of #CURRENT-OUTPUT.
[300] built-in read-only stream shelf name [266] ::=
#ADDITIONAL-INFO
| #APPINFO
| #COMMAND-LINE-NAMES
| #ARGS
| #DOCTYPE
| #FILE-NAME
| #LANGUAGE-VERSION
| #MESSAGE
| #PLATFORM-INFO
| #RECOVERY-INFO
| #XMLNS-NAMES
[301] built-in read-write stream shelf name [266] ::=
#LIBPATH
| #LIBRARY
| #LIBVALUE
[302] built-in read-only source shelf name [266] ::=
#PROCESS-INPUT
| #MAIN-INPUT
[303] symbol declaration [115] ::= SYMBOL, constant string expression [274]+
[304] delimiter declaration [115] ::= DELIMITER, constant string expression [274]
[305] format item [272] [273] ::=
alphabetic format item [306]
| attribute format item [307]
| binary format item [308]
| break format item [309]
| content format item [310]
| current name format item [311]
| decimal format item [312]
| end break suppress format item [313]
| macro format item [314]
| other format item [315]
| pattern format item [316]
| roman format item [317]
| start break suppress format item [318]
| stream format item [319]
| symbol format item [320]
[306] alphabetic format item [305] ::= escape [469], (number [248], "f" | "j" | "k" | "l" | "u" | "w")*, "a", "(", shelf item reference [443], ")"
[307] attribute format item [305] ::= escape [469], (number [248], "f" | "k" | "e" | "h" | "l" | "o" | "p" | "s" | "u" | "z")*, "v", "(", attribute name [77], ")"
[308] binary format item [305] ::= escape [469], (number [248], "f" | number [248])*, "b", "(", shelf item reference [443], ")"
[309] break format item [305] ::= escape [469], "/"
[310] content format item [305] ::= escape [469], ("h" | "l" | "s" | "u" | "z")*, "c"
[311] current name format item [305] ::= escape [469], ("e" | number [248], "f" | "k" | "l" | "o" | "p" | "u")*, "q"
[312] decimal format item [305] ::= escape [469], (number [248], "f" | ("k" | "z") | "l" | number [248], "r" | "s" | "u" | number [248])*, "d", "(", shelf item reference [443], ")"
[313] end break suppress format item [305] ::= escape [469], "]"
[314] macro format item [305] ::= escape [469], ("u" | "l")?, "@", (escape [469] | "(", name [460], ")")
[315] other format item [305] ::=
escape [469], "s", "_"
| escape [469], "s", "n"
| escape [469], "s", "t"
| escape [469], "e", "n"
[316] pattern format item [305] ::= escape [469], (number [248], "f" | "k" | "h" | "l" | "s" | "u")*, "x", "(", pattern name [344], ")"
[317] roman format item [305] ::= escape [469], (number [248], "f" | "k" | "l" | "u")*, "i", "(", shelf item reference [443], ")"
[318] start break suppress format item [305] ::= escape [469], "["
[319] stream format item [305] ::= escape [469], (number [248], "f" | "k" | "l" | "u" | "e")*, "g", "(", (shelf item reference [443] | pattern name [344]), ")"
[320] symbol format item [305] ::= escape [469], (number [248], "f" | "k")*, "y", "(", shelf item reference [443], ")"
[321] condition [4] [5] [6] [8] [9] [10] [11] [12] [13] [14] [15] [16] [17] [18] [19] [20] [21] [22] [23] [24] [25] [26] [27] [86] [87] [88] [90] [128] [129] [147] [205] [222] [345] ::= (WHEN | UNLESS), boolean expression [322]
[322] boolean expression [150] [224] [227] [235] [321] [328] [373] [396] [439] ::= boolean conditional [323], ((OR | "|"), boolean conditional [323])*
[323] boolean conditional [322] ::=
boolean term [324], "->", boolean conditional [323], "|", boolean conditional [323]
| boolean term [324]
[324] boolean term [138] [236] [261] [323] ::= boolean factor [325], ((AND | "&"), boolean factor [325])*
[325] boolean factor [324] ::= (NOT | "!")?, boolean tertiary [326]
[326] boolean tertiary [325] ::=
argument test primary [401]
| attribute test primary [83]
| attributes test primary [84]
| catch test primary [413]
| dtd pool test primary [234]
| element test primary [45]
| entity test primary [52]
| numeric test primary [254]
| pattern test primary [355]
| shelf test primary [451]
| source test primary [296]
| stream test primary [286]
| string test primary [289]
| user-defined type test primary [141]
| boolean secondary [327], ((equality comparer [331], boolean secondary [327])+ | inequality comparer [332], boolean secondary [327])?
[327] boolean secondary [326] ::=
argument primary [395], (user-defined infix function name [468], argument primary [395])+
| boolean primary [328]
[328] boolean primary [327] [345] [395] ::=
built-in read-only switch shelf name [337]
| shelf item reference [443]
| value function call [389]
| FALSE
| TRUE
| "~", boolean primary [328]
| ACTIVE, boolean primary [328]
| "(", boolean expression [322], ")"
[329] comparer [295] ::=
equivalence comparer [330]
| strongly ascending comparer [335]
| strongly descending comparer [336]
[330] equivalence comparer [52] [329] ::=
equality comparer [331]
| inequality comparer [332]
[331] equality comparer [256] [257] [258] [290] [291] [292] [326] [330] [333] [334] ::=
IS, EQUAL
| "="
[332] inequality comparer [259] [293] [326] [330] ::=
ISNT, EQUAL
| "!", "="
[333] weakly ascending comparer [256] [290] ::=
equality comparer [331]
| strongly ascending comparer [335]
[334] weakly descending comparer [257] [291] ::=
equality comparer [331]
| strongly descending comparer [336]
[335] strongly ascending comparer [256] [290] [329] [333] ::=
IS, LESS-EQUAL
| ISNT, GREATER-THAN
| "<="
| IS, LESS-THAN
| ISNT, GREATER-EQUAL
| "<"
[336] strongly descending comparer [257] [291] [329] [334] ::=
IS, GREATER-EQUAL
| ISNT, LESS-THAN
| ">="
| IS, GREATER-THAN
| ISNT, LESS-EQUAL
| ">"
[337] built-in read-only switch shelf name [328] ::=
#FIRST
| #LAST
[338] pattern expression [26] [28] [87] [212] [222] [345] ::= pattern product [339], ((OR | "|"), pattern product [339])*
[339] pattern product [338] ::=
pattern factor [340], pattern product [339]?
| LOOKAHEAD, pattern product [339]
| NOT, pattern product [339]
| (character set [350] | character class name [349]), ("**" | "++"), ("=>", pattern name [344])?, pattern product [339]
[340] pattern factor [339] ::=
(pattern entity type [346] | pattern nonentity type [347])?, pattern tertiary [341]
| pattern entity type [346], NAMED, pattern tertiary [341], (VALUED, pattern tertiary [341])?
| pattern entity type [346], VALUED, pattern tertiary [341], (NAMED, pattern tertiary [341])?
| pattern nonentity type [347], VALUED, pattern tertiary [341]
[341] pattern tertiary [340] ::= pattern secondary [342], ("=>", pattern name [344])?
[342] pattern secondary [263] [294] [341] ::= pattern primary [343], occurrence indicator [348]?
[343] pattern primary [342] ::= UL?, ul pattern primary [345]
[344] pattern name [266] [316] [319] [339] [341] [345] [355] ::= name [460]
[345] ul pattern primary [343] ::=
character class name [349]
| character set [350]
| string literal [270]
| positional pattern [354]
| ANOTHER?, pattern name [344]
| value function call [389]
| "~", string primary [266]
| "~", boolean primary [328]
| "(", condition [321], ")"
| "(", pattern expression [338], condition [321]?, ")"
[346] pattern entity type [340] ::=
CDATA
| SDATA
| ENTITY
[347] pattern nonentity type [340] ::=
PCDATA
| NON-CDATA
| NON-SDATA
| TEXT
[348] occurrence indicator [342] ::=
"?"
| "+"
| "*"
| "{", numeric expression [236], "}"
| "{", numeric expression [236], TO, numeric expression [236], "}"
| "{", numeric expression [236], "}", "+"
[349] character class name [339] [345] [353] ::=
ANY
| ANY-TEXT
| BLANK
| DIGIT
| LC
| LETTER
| SPACE
| UC
| WHITE-SPACE
[350] character set [339] [345] ::=
"[", character set term [352], (character set exception operator [351], character set term [352])?, "]"
| "[", character set exception operator [351], character set term [352], "]"
[351] character set exception operator [350] ::=
"\"
| EXCEPT
[352] character set term [350] ::= character set product [353], ((OR | "|"), character set product [353])*
[353] character set product [352] ::=
character class name [349]
| constant string primary [277], (TO, constant string primary [277])?
[354] positional pattern [345] ::=
CONTENT-END
| CONTENT-START
| LINE-END
| LINE-START
| VALUE-END
| VALUE-START
| WORD-END
| WORD-START
[355] pattern test primary [326] ::= pattern name [344], (IS | ISNT), SPECIFIED
[356] function definition [116] ::=
external prefix function definition [357]
| external infix function definition [358]
| external conversion function definition [359]
| external markup-parser function definition [360]
| internal prefix function definition [361]
| internal infix function definition [362]
| internal conversion function definition [363]
[357] external prefix function definition [356] [371] ::= (DEFINE | EXPORT), function categorization kind [364]?, EXTERNAL, external passed type [365]?, (PREFIX-FUNCTION | FUNCTION), function name [366], function argument list definition [368]?, external function binding [387]
[358] external infix function definition [356] [371] ::= (DEFINE | EXPORT), OVERLOADED?, EXTERNAL, (first-class type [130] | SOURCE), INFIX-FUNCTION, (first-class type [130] | SOURCE), name [460], function name [366], (first-class type [130] | SOURCE), name [460], external function binding [387]
[359] external conversion function definition [356] [371] ::= (DEFINE | EXPORT), EXTERNAL, (first-class type [130] | SOURCE), CONVERSION-FUNCTION, function argument definition [371], external function binding [387]
[360] external markup-parser function definition [356] [372] ::= (DEFINE | EXPORT), EXTERNAL, MARKUP-PARSER, (PREFIX-FUNCTION | FUNCTION), function name [366], function argument list definition [368]?, external function binding [387]
[361] internal prefix function definition [356] [371] ::= (DEFINE | EXPORT), function categorization kind [364]?, (first-class type [130] | INPUT)?, (PREFIX-FUNCTION | FUNCTION), function name [366], function argument list definition [368]?, internal function binding [388]
[362] internal infix function definition [356] [371] ::= (DEFINE | EXPORT), OVERLOADED?, (first-class type [130] | INPUT), INFIX-FUNCTION, first-class type [130], name [460], function name [366], first-class type [130], name [460], internal function binding [388]
[363] internal conversion function definition [356] [371] ::= (DEFINE | EXPORT), (first-class type [130] | INPUT), CONVERSION-FUNCTION, function argument definition [371], internal function binding [388]
[364] function categorization kind [357] [361] ::=
DYNAMIC?, OVERLOADED
| OVERRIDING
[365] external passed type [357] [367] ::=
first-class type [130]
| OUTPUT
| SOURCE
[366] function name [357] [358] [360] [361] [362] [367] [400] ::= name [460]
[367] require function definition [116] ::= REQUIRE, (external passed type [365] | INPUT | MARKUP-PARSER)?, (PREFIX-FUNCTION | FUNCTION), function name [366], function argument list definition [368]?
[368] function argument list definition [357] [360] [361] [367] ::=
parenthesized function argument list definition [369]
| unparenthesized function argument list definition [370]
[369] parenthesized function argument list definition [368] ::=
"(", ")"
| "(", function argument definition [371], (argument separator [385], function argument definition [371])*, (argument separator [385], remainder shelf argument definition [381], (argument separator [385], ".", ".", ".")?, ")")?
| "(", remainder shelf argument definition [381], argument separator [385], ".", ".", ".", ")"
[370] unparenthesized function argument list definition [368] ::=
argument herald [386]?, function argument definition [371], (argument herald [386], function argument definition [371])*, (argument herald [386], remainder shelf argument definition [381], (argument herald [386], ".", ".", ".")?)?
| argument herald [386], remainder shelf argument definition [381], (argument herald [386], ".", ".", ".")?
| remainder shelf argument definition [381], argument herald [386], ".", ".", "."
[371] function argument definition [359] [363] [369] [370] ::=
expression argument definition [372]
| modifiable shelf argument definition [379]
| read-only shelf argument definition [380]
| write-only shelf argument definition [382]
| converting argument definition [383]
A converting argument definition [383] is only allowed as the first argument of an OVERLOADED external prefix function definition [357] or internal prefix function definition [361], as an argument of an OVERLOADED external infix function definition [358] or internal infix function definition [362], or as the argument of an external conversion function definition [359] or internal conversion function definition [363].
[372] expression argument definition [371] [408] ::=
boolean expression argument definition [373]
| numeric expression argument definition [374]
| parser-input expression argument definition [375]
| string expression argument definition [376]
| user-defined type expression argument definition [377]
| second-class expression argument definition [378]
A parser-input expression argument definition [375] is only allowed for an external markup-parser function definition [360].
A second-class expression argument definition [378] is only allowed for an EXTERNAL function.
[373] boolean expression argument definition [372] ::= VALUE, SWITCH, name [460], (OPTIONAL, (INITIAL, "{", boolean expression [322], "}")?)?
[374] numeric expression argument definition [372] ::= VALUE, (COUNTER | INTEGER | INT32), name [460], (OPTIONAL, (INITIAL, "{", numeric expression [236], "}")?)?
[375] parser-input expression argument definition [372] ::= VALUE, PARSER-INPUT, name [460], (OPTIONAL, (INITIAL, "{", string expression [261], "}")?)?
A parser-input expression argument definition [375] is only allowed as an argument for an EXTERNAL MARKUP-PARSER function.
[376] string expression argument definition [372] ::= VALUE, STREAM, name [460], (OPTIONAL, (INITIAL, "{", string expression [261], "}")?)?
[377] user-defined type expression argument definition [372] ::= VALUE, user-defined type name [137], name [460], OPTIONAL?
[378] second-class expression argument definition [372] ::= VALUE, (SOURCE | OUTPUT), name [460]
A second-class expression argument definition [378] is only allowed as an argument for an EXTERNAL function.
[379] modifiable shelf argument definition [371] ::= MODIFIABLE, first-class type [130], name [460], OPTIONAL?
[380] read-only shelf argument definition [371] [408] ::= READ-ONLY, first-class type [130], name [460], OPTIONAL?
[381] remainder shelf argument definition [369] [370] ::= REMAINDER, first-class type [130], name [460]
[382] write-only shelf argument definition [371] ::= WRITE-ONLY, first-class type [130], name [460]
[383] converting argument definition [371] ::=
VALUE, "(", ANY, INTO, first-class type [130], ")"
| VALUE, "(", source type name [384], ((OR | "|"), source type name [384])*, INTO, first-class type [130], ")"
[384] source type name [383] ::=
first-class type [130]
| SOURCE
| NUMERIC-LITERAL
A SOURCE argument is only allowed for an EXTERNAL function definition.
[385] argument separator [369] [391] [406] ::=
argument herald [386]
| ","
[386] argument herald [370] [385] [392] [393] [407] ::= name [460]
[387] external function binding [357] [358] [359] [360] ::= AS, system-specific function name [472], (IN, FUNCTION-LIBRARY, system-specific library name [473])?
[388] internal function binding [361] [362] [363] ::=
AS, local scope [143]
| ELSEWHERE
[389] value function call [140] [245] [266] [328] [345] [414] ::=
prefix function name [464], parenthesized call arguments [391]
| prefix function name [464], unparenthesized call arguments [392]
[390] void function call [148] [225] [233] ::=
prefix function name [464], parenthesized call arguments [391]
| prefix function name [464], void unparenthesized call arguments [393]
[391] parenthesized call arguments [389] [390] [412] ::= "(", (argument expression [394], (argument separator [385], argument expression [394])*)?, ")"
[392] unparenthesized call arguments [389] [412] ::= (argument herald [386]?, argument primary [395], (argument herald [386], argument primary [395])*)?
[393] void unparenthesized call arguments [390] ::= (argument herald [386]?, argument expression [394], (argument herald [386], argument expression [394])*)?
[394] argument expression [391] [393] ::=
argument shelf reference [397]
| argument value expression [396]
[395] argument primary [139] [244] [265] [327] [392] ::=
argument shelf reference [397]
| numeric primary [245]
| string primary [266]
| boolean primary [328]
| user-defined type primary [140]
[396] argument value expression [394] ::=
boolean expression [322]
| numeric expression [236]
| string expression [261]
| user-defined type expression [138]
[397] argument shelf reference [394] [395] [401] ::= shelf item reference [443]
[398] set external function association action [148] ::=
SET, external function identification [400], TO, system-specific function name [472]
| SET, FUNCTION-LIBRARY, OF, external function identification [400], TO, system-specific library name [473]
[399] external function association enquiry [266] ::= (FUNCTION-LIBRARY, OF)?, external function identification [400]
[400] external function identification [398] [399] ::=
(EXTERNAL-FUNCTION | EXTERNAL-OUTPUT-FUNCTION), function name [366]
| CREATOR, OF, user-defined type name [137]
[401] argument test primary [326] ::= argument shelf reference [397], (IS | ISNT), SPECIFIED
[402] catch definition [116] ::= (DECLARE | EXPORT | REQUIRE), catch signature [403]
[403] catch signature [402] ::= CATCH, catch name [404], catch argument list definition [405]?
[404] catch name [403] [412] [413] ::= name [460]
[405] catch argument list definition [403] ::=
parenthesized catch argument list definition [406]
| unparenthesized catch argument list definition [407]
[406] parenthesized catch argument list definition [405] ::=
"(", ")"
| "(", catch argument definition [408], (argument separator [385], catch argument definition [408])*, ")"
[407] unparenthesized catch argument list definition [405] ::= argument herald [386]?, catch argument definition [408], (argument herald [386], catch argument definition [408])*
[408] catch argument definition [406] [407] ::=
expression argument definition [372]
| read-only shelf argument definition [380]
[409] built-in catch invocation [145] ::=
external-exception invocation [410]
| program-error invocation [411]
[410] external-exception invocation [409] ::= #EXTERNAL-EXCEPTION, (IDENTITY, name [460])?, (MESSAGE, name [460])?, (LOCATION, name [460])?
[411] program-error invocation [409] ::= #PROGRAM-ERROR, (CODE, name [460])?, (MESSAGE, name [460])?, (LOCATION, name [460])?
[412] catch invocation [145] [190] [195] ::=
catch name [404], parenthesized call arguments [391]
| catch name [404], unparenthesized call arguments [392]
[413] catch test primary [326] ::= (catch name [404] | #EXTERNAL-EXCEPTION | #PROGRAM-ERROR), (IS | ISNT), (CATCHABLE | THROWN)
[414] stream attachment [170] [174] [180] [187] ::=
BUFFER
| FILE?, string expression [261]
| REFERENT, string expression [261]
| SINK, shelf item reference [443]
| value function call [389]
The use of the FILE keyword is optional, however its omission is deprecated.
[415] stream attachment modifier set [170] [180] ::= WITH, stream attachment modifier group [416], (WITH, stream attachment modifier group [416])*
[416] stream attachment modifier group [415] ::=
stream attachment modifier [421]
| "(", stream attachment modifier [421], ((AND | "&"), stream attachment modifier [421])*, ")"
[417] protected set stream modifier set [185] [186] ::= WITH, protected set stream modifier group [418], (WITH, protected set stream modifier group [418])*
[418] protected set stream modifier group [417] ::=
stream creation modifier [423]
| stream output modifier [424]
| "(", set stream modifier [422], ((AND | "&"), set stream modifier [422])*, ")"
[419] stream output modifier set [174] [177] ::= WITH, stream output modifier group [420], (WITH, stream output modifier group [420])*
[420] stream output modifier group [419] ::=
stream output modifier [424]
| "(", stream output modifier [424], ((AND | "&"), stream output modifier [424])*, ")"
[421] stream attachment modifier [416] ::=
set stream modifier [422]
| APPEND
[422] set stream modifier [418] [421] ::=
break modifier [425]
| stream creation modifier [423]
| stream output modifier [424]
[423] stream creation modifier [418] [422] ::=
BINARY-MODE
| BUFFERED
| DOMAIN-FREE
| REFERENTS-ALLOWED, (DEFAULTING, "{", string expression [261], (",", string expression [261])?, "}")?
| REFERENTS-DISPLAYED
| REFERENTS-NOT-ALLOWED
| TEXT-MODE
| UNBUFFERED
[424] stream output modifier [418] [420] [422] ::=
constant string literal [279]
| BINARY, numeric subexpression [237]
[425] break modifier [170] [180] [422] ::= BREAK-WIDTH, numeric subexpression [237], (number [248] | TO, numeric subexpression [237])?
[426] global shelf definition [116] ::= EXPORT?, (CONSTANT | GLOBAL), shelf declaration [432], ((AND | "&"), shelf declaration [432])*
[427] require shelf definition [116] ::= REQUIRE, (GLOBAL | CONSTANT), first-class type [130], shelf name [446]
[428] local declaration [143] ::=
global shelf save declaration [429]
| groups save declaration [430]
| local shelf declaration [431]
[429] global shelf save declaration [428] ::= (SAVE | SAVE-CLEAR), shelf name [446], ((AND | "&"), shelf name [446])*
[430] groups save declaration [428] ::= SAVE, GROUPS
[431] local shelf declaration [428] ::= LOCAL, shelf declaration [432], ((AND | "&"), shelf declaration [432])*
[432] shelf declaration [135] [426] [431] ::=
boolean shelf declaration [433]
| numeric shelf declaration [434]
| string shelf declaration [435]
| user-defined type shelf declaration [436]
[433] boolean shelf declaration [432] ::= SWITCH, shelf name [446], (fixed-size shelf declaration [438] | variable-size shelf declaration [437]), boolean shelf initializer [439]?
[434] numeric shelf declaration [432] ::= (COUNTER | INTEGER | INT32), shelf name [446], (fixed-size shelf declaration [438] | variable-size shelf declaration [437]), numeric shelf initializer [440]?
[435] string shelf declaration [432] ::= STREAM, shelf name [446], (fixed-size shelf declaration [438] | variable-size shelf declaration [437]), string shelf initializer [441]?
[436] user-defined type shelf declaration [432] ::= user-defined type name [137], shelf name [446], (fixed-size shelf declaration [438] | variable-size shelf declaration [437])
[437] variable-size shelf declaration [433] [434] [435] [436] ::= VARIABLE, (TO, constant numeric expression [249])?, (INITIAL-SIZE, constant numeric expression [249])?
[438] fixed-size shelf declaration [433] [434] [435] [436] ::= (SIZE, constant numeric expression [249])?
[439] boolean shelf initializer [433] ::= (INITIAL, "{", boolean expression [322], (",", boolean expression [322])*, "}")?
[440] numeric shelf initializer [434] ::= (INITIAL, "{", numeric expression [236], (",", numeric expression [236])*, "}")?
[441] string shelf initializer [435] ::= (INITIAL, "{", (string expression [261] | UNATTACHED), (",", (string expression [261] | UNATTACHED))*, "}")?
[442] new shelf item reference [167] [170] [180] [185] ::= shelf reference [444], key indexer [449]?, ((AFTER | BEFORE), indexer [447])?
[443] shelf item reference [140] [149] [152] [156] [157] [158] [163] [165] [170] [174] [177] [178] [179] [180] [181] [183] [184] [203] [245] [246] [266] [268] [286] [306] [308] [312] [317] [319] [320] [328] [397] [414] ::= shelf reference [444], indexer [447]?
[444] shelf reference [151] [154] [155] [220] [247] [442] [443] [451] ::= shelf name [446]
[445] shelf alias [211] [215] [220] ::= shelf name [446]
[446] shelf name [203] [427] [429] [433] [434] [435] [436] [444] [445] ::= name [460]
[447] indexer [72] [202] [230] [232] [267] [442] [443] ::=
item indexer [448]
| key indexer [449]
| lastmost indexer [450]
[448] item indexer [68] [268] [447] [451] ::=
ITEM, numeric primary [245]
| "@", numeric primary [245]
| "[", numeric expression [236], "]"
This use of the keywords ITEM and "@" is deprecated in favour of the more general "[" and "]" indexing form.
[449] key indexer [246] [442] [447] ::=
KEY, string primary [266]
| "^", string primary [266]
| "{", string expression [261], "}"
This use of the keywords KEY and "^" is deprecated in favour of the more general "{" and "}" indexing form.
[450] lastmost indexer [447] ::= LASTMOST
[451] shelf test primary [326] ::=
shelf reference [444], item indexer [448]?, (IS | ISNT), KEYED
| shelf reference [444], (HAS | HASNT), (KEY | "^"), string primary [266]
| REFERENTS, (HAS | HASNT), (KEY | "^"), string primary [266]
[452] macro definition [115] ::= MACRO, macro name [453], parameter template [454]*, IS, replacement template item [459]*, MACRO-END
[453] macro name [452] ::= macro token [456]+
[454] parameter template [452] ::=
ARG, macro parameter [455], macro token [456]+
| TOKEN, macro parameter [455], macro token [456]*
[455] macro parameter [454] [456] [459] ::=
delimiter token [457]
| name [460]
[456] macro token [453] [454] ::= LITERAL?, macro parameter [455]
[457] delimiter token [455] [459] ::=
infix function name [463]
| delimiter character [458]
[458] delimiter character [457] ::= "(" | ")" | "{" | "}" | "[" | "]" | "`" | ":" | "."
[459] replacement template item [452] ::=
macro parameter [455]
| LITERAL?, string literal [270]
| LITERAL?, delimiter token [457]
| LITERAL?, name [460]
| LITERAL?, number [248]
[460] name [35] [37] [44] [51] [67] [76] [77] [98] [102] [103] [104] [105] [106] [137] [314] [344] [358] [362] [366] [373] [374] [375] [376] [377] [378] [379] [380] [381] [382] [386] [404] [410] [411] [446] [455] [459] [463] [464] ::= (letter [461] | user-defined name character [474]), (digit [462] | letter [461] | user-defined name character [474] | "." | "-" | "_")*
[461] letter [460] ::= "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z" | "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z"
[462] digit [248] [460] ::= "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"
[463] infix function name [457] [468] ::= infix function start character [465], function following character [467]* | name [460]
[464] prefix function name [389] [390] ::= prefix function start character [466], function following character [467]* | name [460]
[465] infix function start character [463] ::= function following character [467] | prefix function start character [466]
[466] prefix function start character [464] [465] ::= "!" | "-" | "+" | "%" | "?" | "/" | "~" | "$" | "\" | "@" | "^" | ","
[467] function following character [463] [464] [465] ::= "*" | "=" | "|" | "<" | ">" | "&"
[468] user-defined infix function name [139] [244] [265] [327] ::= Any infix function name [463] defined in a program rather than by OmniMark, and which are not overloadings of operators defined by OmniMark to be overloadable.
[469] escape [283] [284] [285] [306] [307] [308] [309] [310] [311] [312] [313] [314] [315] [316] [317] [318] [319] [320] [470] ::= The escape [469] character is defined by an escape declaration [110]. If there is no escape declaration [110], the escape character is "%".
[470] unescaped character [272] [273] [281] [282] ::= An unescaped character [470] is any character that is not a "'", a """, a control character, or escape [469].
[471] describing number [285] ::= A describing number [471] is a number in the base indicated by the number [248] non-terminal in the described substring [285] production. The base can range from two to 36; the digits in each describing number [471] must be of the appropriate base, using letters (upper- or lower-case) for digit values over nine.
[472] system-specific function name [132] [387] [398] ::= A system-specific function name [472] is implemented as a string expression [261].
[473] system-specific library name [132] [387] [398] ::= A system-specific library name [473] is implemented as a string expression [261].
[474] user-defined name character [460] ::= A user-defined name character [474] is any character that appears in a LETTERS declaration that is not explicitly excluded from being a name character.
Copyright © Stilo Corporation, 2003-2004. All rights reserved.
ETR62, 2004/4/21