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