Pash (PowerShell-like) Grammar


Syntax


<statementSeparatorToken>
    ::= NewLine <statementSeparatorToken>
    |  

<statementListRule>
    ::= <statementRule>
    | <statementRule> <statementSeparatorToken> <statementListRule>

<statementBlockRule>
    ::= '{' <statementListRule> '}'

<statementRule>
    ::= <pipelineRule>
    | CommentToken
    | <ifStatementRule>
    | <foreachStatementRule>
    | <doWhileStatementRule>
    | <flowControlStatementRule>
    | <trapStatementRule>
    | <finallyStatementRule>

<pipelineRule>
    ::= <cmdletCall>
    | <cmdletCall> '|' <pipelineRule>
    | <assignmentStatementRule>
    | <assignmentStatementRule> '|' <pipelineRule>

<assignmentStatementRule>
    ::= <lvalueExpression> AssignmentOperatorToken <pipelineRule>

<lvalueExpression>
    ::= <lvalue>

<propertyOrArrayReferenceOperatorList>
    ::= <propertyOrArrayReferenceOperator>
    | <propertyOrArrayReferenceOperatorList> <propertyOrArrayReferenceOperator>

<lvalue>
    ::= VariableToken
    | AttributeSpecificationToken VariableToken
    | VariableToken <propertyOrArrayReferenceOperatorList>
    | AttributeSpecificationToken VariableToken <propertyOrArrayReferenceOperatorList>

<ParameterArgumentToken>
    ::= <valueRule>
    | AnyWordToken
    | ParameterToken

<cmletParamsList>
    ::= <ParameterArgumentToken> <cmletParamsList>
    | <ParameterArgumentToken>

<cmdletName>
    ::= AnyWordToken

<cmdletCall>
    ::= ExecCall <cmdletName> <cmletParamsList>
    | ExecCall <cmdletName>
    | <cmdletName> <cmletParamsList>
    | <cmdletName>
    | <expressionRule>

<elseIfBlockRule>
    ::= elseif '(' <pipelineRule> ')' <statementBlockRule>
    | elseif '(' <pipelineRule> ')' <statementBlockRule> <elseIfBlockRule>

<ifStatementRule>
    ::= if '(' <pipelineRule> ')' <statementBlockRule>
    | if '(' <pipelineRule> ')' <statementBlockRule> <elseIfBlockRule>
    | if '(' <pipelineRule> ')' <statementBlockRule> else <statementBlockRule>
    | if '(' <pipelineRule> ')' <statementBlockRule> <elseIfBlockRule> else <statementBlockRule>

<switchTypeStatementRule>
    ::= -regex
    | -wildcard
    | -exact
    |  

<switchCasesensitiveParameterRule>
    ::= -casesensitive
    |  

<switchParameterRule>
    ::= -file <propertyOrArrayReferenceRule>
    | '(' <pipelineRule> ')'

<switchSelectorStatementRule>
    ::= default
    | <ParameterArgumentToken>
    | <propertyOrArrayReferenceRule>
    | <statementBlockRule>

<switchBody>
    ::= <switchSelectorStatementRule> <statementBlockRule>
    | <switchSelectorStatementRule> <statementBlockRule> <switchBody>

<switchStatementRule>
    ::= switch <switchTypeStatementRule> <switchCasesensitiveParameterRule> <switchParameterRule> '{' <switchBody> '}'

<foreachStatementRule>
    ::= foreach '(' VariableToken in <pipelineRule> ')' <statementBlockRule>
    | LoopLabelToken foreach '(' VariableToken in <pipelineRule> ')' <statementBlockRule>

<doWhileStatementRule>
    ::= do <statementBlockRule> while '(' <pipelineRule> ')'
    | do <statementBlockRule> until '(' <pipelineRule> ')'
    | LoopLabelToken do <statementBlockRule> while '(' <pipelineRule> ')'
    | LoopLabelToken do <statementBlockRule> until '(' <pipelineRule> ')'

<trapStatementRule>
    ::= trap <statementBlockRule>
    | trap AttributeSpecificationToken <statementBlockRule>

<finallyStatementRule>
    ::= finally <statementBlockRule>

<flowControlPropertyBody>
    ::= <propertyOrArrayReferenceRule>

<flowControlStatementRule>
    ::= break
    | continue
    | break <flowControlPropertyBody>
    | continue <flowControlPropertyBody>
    | return <pipelineRule>

<expressionRule>
    ::= <logicalExpressionRule>

<logicalExpressionRule>
    ::= <bitwiseExpressionRule>
    | <bitwiseExpressionRule> LogicalOperatorToken <logicalExpressionRule>

<bitwiseExpressionRule>
    ::= <comparisonExpressionRule>
    | <comparisonExpressionRule> BitwiseOperatorToken <bitwiseExpressionRule>

<comparisonExpressionRule>
    ::= <addExpressionRule>
    | <addExpressionRule> ComparisonOperatorToken <comparisonExpressionRule>

<addExpressionRule>
    ::= <multiplyExpressionRule>
    | <multiplyExpressionRule> AdditionOperatorToken <addExpressionRule>

<multiplyExpressionRule>
    ::= <formatExpressionRule>
    | <formatExpressionRule> MultiplyOperatorToken <multiplyExpressionRule>

<formatExpressionRule>
    ::= <rangeExpressionRule>
    | <rangeExpressionRule> FormatOperatorToken <formatExpressionRule>

<rangeExpressionRule>
    ::= <arrayLiteralRule>
    | <arrayLiteralRule> RangeOperatorToken <rangeExpressionRule>

<arrayLiteralRule>
    ::= <postfixOperatorRule>
    | <postfixOperatorRule> CommaToken <arrayLiteralRule>

<postfixOperatorRule>
    ::= <lvalueExpression> PrePostfixOperatorToken
    | <propertyOrArrayReferenceRule>

<propertyOrArrayReferenceRule>
    ::= <valueRule>
    | <valueRule> <propertyOrArrayReferenceOperatorList>

<propertyOrArrayReferenceOperator>
    ::= '[' <expressionRule> ']' ReferenceOperatorToken AnyWordToken
    | '[' <expressionRule> ']' ReferenceOperatorToken AnyWordToken <parseCallRule>
    | '[' <expressionRule> ']' <valueRule>

<parseCallRule>
    ::= '(' <arrayLiteralRule> ')'

<valueRule>
    ::= '(' <assignmentStatementRule> ')'
    | '$(' <statementListRule> ')'
    | '@(' <statementListRule> ')'
    | UnaryOperatorToken <propertyOrArrayReferenceRule>
    | AttributeSpecificationToken <propertyOrArrayReferenceRule>
    | AttributeSpecificationToken
    | NumberToken
    | StringToken
    | ExpandableStringToken
    | VariableToken


Grammar


Grammar
"Name"            = 'Pash (PowerShell-like) Grammar'
"Author"          = 'IgorM'
"Version"         = '1.0'
"About"           = 'Pash Script grammar.'

"Case Sensitive"  = False
"Start Symbol"    = <statementListRule>

! Grammar was taken from the Appendix C: Windows PowerShell in Action book (http://www.manning.com/payette/)

!===============================
! Character sets
!===============================

! Special comment definition
Comment Start = '/*'
Comment End = '*/'
Comment Line   = '#'

NewLine = {CR}{LF}
        | {CR}
        | {LF}
{WS} = {Whitespace} - {CR} - {LF}
Whitespace = {WS}+

!ExecCall = [&\.]
ExecCall = [&]

{StringTokenCharSet1} = {Printable} - [''] + {CR} + {LF}
{StringTokenCharSet2} = {Printable} - ["] + {CR} + {LF}

{SimpleTextCharSet} = {Printable} - {Whitespace} - [''|$()']''['"+=#.,:]
{SimpleTextCharSetNoDashAndNumber} = {SimpleTextCharSet} - [-] - {Number}

{HexNumber} = {Number} + [abcdefABCDEF]

{SimpleAlphaNumeric} = {AlphaNumeric}

! ########################################
!     Tokenized Rules
! ########################################

ComparisonOperatorToken = '-eq' | '-ne' | '-ge' | '-gt' | '-lt' | '-le'
                        | '-ieq' | '-ine' | '-ige' | '-igt' | '-ilt' | '-ile'
                        | '-ceq' | '-cne' | '-cge' | '-cgt' | '-clt' | '-cle'
                        | '-like' | '-notlike' | '-match' | '-notmatch'
                        | '-ilike' | '-inotlike' | '-imatch' | '-inotmatch'
                        | '-clike' | '-cnotlike' | '-cmatch' | '-cnotmatch'
                        | '-contains' | '-notcontains'
                        | '-icontains' | '-inotcontains'
                        | '-ccontains' | '-cnotcontains'
                        | '-isnot' | '-is' | '-as'
                        | '-replace' | '-ireplace' | '-creplace'

AssignmentOperatorToken = '=' | '+=' | '-=' | '*=' | '/=' | '%='

LogicalOperatorToken = '-and' | '-or'

BitwiseOperatorToken = '-band' | '-bor'

RedirectionOperatorToken = '2>&1' | '>>' | '>' | '<<' | '<' | '>|' | '2>' | '2>>' | '1>>'

FunctionDeclarationToken = 'function' | 'filter'

! <ExpandableStringToken> = ".*"
ExpandableStringToken = '.*'

! <StringToken> = '.*'
StringToken = ''{StringTokenCharSet1}*''
            | ["]{StringTokenCharSet2}*["]

! <VariableToken> = \$[:alnum:]+ | \${.+}
VariableToken = '$'{SimpleAlphaNumeric}+

! <ParameterToken> = -[:letter:]+[:]{0 |1}
ParameterToken = [-]{Letter}{AlphaNumeric}*':'?

! <CallArguementSeparatorToken> = ' |'

! <CommaToken> = ' |'
CommaToken = ','

!MinusMinusToken = '--'

RangeOperatorToken = '..'

! <NumberToken> = C# number pattern...
NumberToken = {Number}+
            | '0'[xX]{HexNumber}+
            | {Number}+'.'{Number}+

! <ReferenceOperatorToken> = "." | "::" | "["
ReferenceOperatorToken = '.' 
                       | '::'

! <ParameterArgumentToken> = [^-($0-9].*[^ \t]
!ParameterArgumentToken = {ParameterArgumentTokenCharSet}+

! <UnaryOperatorToken> = "!" | "-not" | "+" | "-" | "-bnot" | <attributeSpecificationToken>
UnaryOperatorToken = '!' | '-not' | '-bnot' | attributeSpecificationToken | AdditionOperatorToken 

FormatOperatorToken = '-f'

LoopLabelToken = {Letter}{AlphaNumeric}*':'

! ParameterToken = 'param'

! PrePostfixOperatorToken> = '++' | MinusMinusToken
PrePostfixOperatorToken = '++' | '--'

MultiplyOperatorToken = '*' | '/' | '%'

! <AdditionOperatorToken> = '+' | '-' | emDash | enDash | horizontalBar
AdditionOperatorToken = '+' | '-'

! <AttributeSpecificationToken> = \[..*\]
AttributeSpecificationToken = '['{Printable}+']'

! <StatementSeparatorToken> = ';' | '&&' | '||' | <end-of-line>

! TODO: <CmdletNameToken> = [^$0-9(@"'][^ \t]*
!CmdletNameToken = {Letter}+[-]?{Letter}+

AnyWordToken = {SimpleTextCharSetNoDashAndNumber}{SimpleTextCharSet}+

! TODO: why the general comment declaration is not working?
CommentToken = '#'{Printable}+

! ########################################
!     Statement
! ########################################

! <statementListRule> = <statementRule> [ <statementSeparatorToken> <statementRule> ]*

<statementSeparatorToken> ::= NewLine <statementSeparatorToken>
                            | 

<statementListRule> ::= <statementRule>
                      | <statementRule> <statementSeparatorToken> <statementListRule>

<statementBlockRule> ::= '{' <statementListRule> '}'

<statementRule> ::= <pipelineRule>
                  | CommentToken
                  | <ifStatementRule>
!                  | <switchStatementRule>
                  | <foreachStatementRule>
!                  | <forWhileStatementRule>
                  | <doWhileStatementRule>
!                  | <functionDeclarationRule>
!                  | <parameterDeclarationRule>
                  | <flowControlStatementRule>
                  | <trapStatementRule>
                  | <finallyStatementRule>                    

! ########################################
!     Pipeline
! ########################################

! <pipelineRule> ::= <assignmentStatement> | <firstPipelineElement> [ '|' <cmdletCall> ]*
!<pipelineRule> ::= <firstPipelineElement>
!                 | <firstPipelineElement> '|' <cmdletCall>
<pipelineRule> ::= <cmdletCall>
                  | <cmdletCall> '|' <pipelineRule>
                  | <assignmentStatementRule>
                  | <assignmentStatementRule> '|' <pipelineRule>

<assignmentStatementRule> ::= <lvalueExpression> AssignmentOperatorToken <pipelineRule>

! <lvalueExpression> ::= <lvalue> [? |? <lvalue>]*
<lvalueExpression> ::= <lvalue>

! <lvalue> ::= <simpleLvalue> <propertyOrArrayReferenceOperator>*
<propertyOrArrayReferenceOperatorList> ::= <propertyOrArrayReferenceOperator>
                                         | <propertyOrArrayReferenceOperatorList> <propertyOrArrayReferenceOperator>
!<lvalue> ::= <simpleLvalue>
!           | <simpleLvalue> <propertyOrArrayReferenceOperatorList>

<lvalue> ::= variableToken
           | AttributeSpecificationToken variableToken
           | variableToken <propertyOrArrayReferenceOperatorList>
           | AttributeSpecificationToken variableToken <propertyOrArrayReferenceOperatorList>

! <simpleLvalue> ::= <AttributeSpecificationToken>* <variableToken>
!<simpleLvalue> ::= variableToken
!                 | AttributeSpecificationToken variableToken

!<firstPipelineElement> ::= <expressionRule> 
!                         | <cmdletCall>

! TODO: <cmdletCall> ::= [ '&' | '.' | <empty> ] [ <name> | <expressionRule> ] [ <parameterToken> | <parameterArgumentToken> | <postfixOperatorRule> | <redirectionRule> ]*

<ParameterArgumentToken> ::= <valueRule> | AnyWordToken | ParameterToken
<cmletParamsList> ::= <ParameterArgumentToken> <cmletParamsList>
                    | <ParameterArgumentToken> 

<cmdletName> ::= AnyWordToken
<cmdletCall> ::= ExecCall <cmdletName> <cmletParamsList>
               | ExecCall <cmdletName>
               | <cmdletName> <cmletParamsList>
               | <cmdletName>
               | <expressionRule>

! <redirectionRule> = <redirectionOperatorToken> <propertyOrArrayReferenceRule>

! ########################################
!     Language constructs
! ########################################

!*
<ifStatementRule> =
'if' '(' <pipelineRule> ')' <statementBlockRule> [
'elseif' '(' <pipelineRule> ')' <statementBlockRule> ]*
[ 'else' <statementBlockRule> ]{0|1}
*!

<elseIfBlockRule> ::= 'elseif' '(' <pipelineRule> ')' <statementBlockRule>
                    | 'elseif' '(' <pipelineRule> ')' <statementBlockRule> <elseIfBlockRule>
<ifStatementRule> ::= 'if' '(' <pipelineRule> ')' <statementBlockRule>
                    | 'if' '(' <pipelineRule> ')' <statementBlockRule> <elseIfBlockRule>
                    | 'if' '(' <pipelineRule> ')' <statementBlockRule> 'else' <statementBlockRule>
                    | 'if' '(' <pipelineRule> ')' <statementBlockRule> <elseIfBlockRule> 'else' <statementBlockRule>

<switchTypeStatementRule> ::= '-regex'
                            | '-wildcard'
                            | '-exact'
                            |
<switchCasesensitiveParameterRule> ::= '-casesensitive'
                            |
<switchParameterRule> ::= '-file' <propertyOrArrayReferenceRule>
                        | '(' <pipelineRule> ')'
<switchSelectorStatementRule> ::= 'default' | <ParameterArgumentToken> | <propertyOrArrayReferenceRule> | <statementBlockRule>
<switchBody> ::= <switchSelectorStatementRule> <statementBlockRule>
               | <switchSelectorStatementRule> <statementBlockRule> <switchBody>
<switchStatementRule> ::= 'switch' <switchTypeStatementRule> <switchCasesensitiveParameterRule> <switchParameterRule> '{' <switchBody> '}'


<foreachStatementRule> ::= 'foreach' '(' variableToken 'in' <pipelineRule> ')' <statementBlockRule>
                         | LoopLabelToken 'foreach' '(' variableToken 'in' <pipelineRule> ')' <statementBlockRule>

!*
<forWhileStatementRule> = <LoopLabelToken>{0 |1} 'while' '(' <pipelineRule> ')' <statementBlockRule> | <LoopLabelToken>{0 |1} 
                          'for' '(' <pipelineRule>{0 |1} ';' <pipelineRule>{0 |1} ';' <pipelineRule>{0 |1} ')' <statementBlockRule>
*!

<doWhileStatementRule> ::= 'do' <statementBlockRule> 'while' '('<pipelineRule> ')'
                         | 'do' <statementBlockRule> 'until' '('<pipelineRule> ')'
                         | LoopLabelToken 'do' <statementBlockRule> 'while' '('<pipelineRule> ')'
                         | LoopLabelToken 'do' <statementBlockRule> 'until' '('<pipelineRule> ')'

<trapStatementRule> ::= 'trap' <statementBlockRule>
                      | 'trap' AttributeSpecificationToken <statementBlockRule>

<finallyStatementRule> ::= 'finally' <statementBlockRule>

! What is <propertyNameToken> ?
!<flowControlPropertyBody> ::= <propertyNameToken> | <propertyOrArrayReferenceRule>
<flowControlPropertyBody> ::= <propertyOrArrayReferenceRule>
<flowControlStatementRule> ::= 'break' 
                            | 'continue'
                            | 'break' <flowControlPropertyBody>
                            | 'continue'  <flowControlPropertyBody>
                            | 'return' <pipelineRule>

!*
<functionDeclarationRule> = <FunctionDeclarationToken> <ParameterArgumentToken> [ '(' <parameterDeclarationExpressionRule> ')' ] <cmdletBodyRule>

<cmdletBodyRule> = '{' [ '(' <parameterDeclarationExpressionRule> ')' ] ( [ 'begin' <statementBlock> | 'process' <statementBlock> | 'end' <statementBlock> ]* | <statementList> '}'
*!

!*
<parameterDeclarationRule> = <ParameterDeclarationToken> '(' <parameterDeclarationExpressionRule> ')'

<parameterDeclarationExpressionRule> = <parameterWithIntializer> [ <CommaToken> <parameterWithIntializer> ]*

<parameterWithIntializer> = <simpleLvalue> [ '=' <expressionRule> ]
*!
!<parameterDeclarationExpressionRule> ::= <parameterWithIntializer>
!                                       | <parameterWithIntializer> CommaToken <parameterDeclarationExpressionRule>
!<parameterWithIntializer> ::= <simpleLvalue> '=' <expressionRule>


! ########################################
!     Expression
! ########################################

<expressionRule> ::= <logicalExpressionRule>

<logicalExpressionRule> ::= <bitwiseExpressionRule>
                          | <bitwiseExpressionRule> LogicalOperatorToken <logicalExpressionRule>

<bitwiseExpressionRule> ::= <comparisonExpressionRule>
                          | <comparisonExpressionRule> BitwiseOperatorToken <bitwiseExpressionRule>

<comparisonExpressionRule> ::= <addExpressionRule>
                             | <addExpressionRule> ComparisonOperatorToken <comparisonExpressionRule>

<addExpressionRule> ::= <multiplyExpressionRule>
                      | <multiplyExpressionRule> AdditionOperatorToken <addExpressionRule>

<multiplyExpressionRule> ::= <formatExpressionRule>
                           | <formatExpressionRule> MultiplyOperatorToken <multiplyExpressionRule>

<formatExpressionRule> ::= <rangeExpressionRule>
                         | <rangeExpressionRule> FormatOperatorToken <formatExpressionRule>

<rangeExpressionRule> ::= <arrayLiteralRule>
                        | <arrayLiteralRule> RangeOperatorToken <rangeExpressionRule>

<arrayLiteralRule> ::= <postfixOperatorRule>
                     | <postfixOperatorRule> CommaToken <arrayLiteralRule>

<postfixOperatorRule> ::= <lvalueExpression> PrePostfixOperatorToken
                        | <propertyOrArrayReferenceRule>

<propertyOrArrayReferenceRule> ::= <valueRule>
                                 | <valueRule> <propertyOrArrayReferenceOperatorList>

! <propertyOrArrayReferenceOperator> = '[' <expressionRule> ']' ] | '.' [ <PropertyNameToken> <parseCallRule>{0|1} | <valueRule> ]
<propertyOrArrayReferenceOperator> ::= '[' <expressionRule> ']' ReferenceOperatorToken AnyWordToken
                                     | '[' <expressionRule> ']' ReferenceOperatorToken AnyWordToken <parseCallRule>
                                     | '[' <expressionRule> ']' <valueRule>

<parseCallRule> ::= '(' <arrayLiteralRule> ')'

! ########################################
!     Value
! ########################################

<valueRule> ::= '(' <assignmentStatementRule> ')' 
| '$(' <statementListRule> ')' 
| '@(' <statementListRule> ')' 
! | <cmdletBodyRule> 
! | '@{' <hashLiteralRule> '}' 
| unaryOperatorToken <propertyOrArrayReferenceRule> 
| AttributeSpecificationToken <propertyOrArrayReferenceRule> 
| AttributeSpecificationToken
! | PrePostfixOperatorToken <lvalue> 
| NumberToken
| StringToken
| ExpandableStringToken
| variableToken  

! <hashLiteralRule> = <keyExpression> '=' <pipelineRule> [ <statementSeparatorToken> <hashLiteralRule> ]*


Data Tables


Parameters
Name Value
Name Pash (PowerShell-like) Grammar
Version 1.0
Author IgorM
About Pash Script grammar.
Start Symbol statementListRule
Auto Whitespace True
Character Mapping Windows-1252
Case Sensitive False


Terminals
Index Name
0 (EOF)
1 (Error)
2 (Whitespace)
3 (Comment End)
4 (Comment Line)
5 (Comment Start)
6 '$('
7 '('
8 ')'
9 '@('
10 '['
11 ']'
12 '{'
13 '|'
14 '}'
15 AdditionOperatorToken
16 AnyWordToken
17 AssignmentOperatorToken
18 AttributeSpecificationToken
19 BitwiseOperatorToken
20 break
21 -casesensitive
22 CommaToken
23 CommentToken
24 ComparisonOperatorToken
25 continue
26 default
27 do
28 else
29 elseif
30 -exact
31 ExecCall
32 ExpandableStringToken
33 -file
34 finally
35 foreach
36 FormatOperatorToken
37 FunctionDeclarationToken
38 if
39 in
40 LogicalOperatorToken
41 LoopLabelToken
42 MultiplyOperatorToken
43 NewLine
44 NumberToken
45 ParameterToken
46 PrePostfixOperatorToken
47 RangeOperatorToken
48 RedirectionOperatorToken
49 ReferenceOperatorToken
50 -regex
51 return
52 StringToken
53 switch
54 trap
55 UnaryOperatorToken
56 until
57 VariableToken
58 while
59 -wildcard


Nonterminals
Index Name
60 <addExpressionRule>
61 <arrayLiteralRule>
62 <assignmentStatementRule>
63 <bitwiseExpressionRule>
64 <cmdletCall>
65 <cmdletName>
66 <cmletParamsList>
67 <comparisonExpressionRule>
68 <doWhileStatementRule>
69 <elseIfBlockRule>
70 <expressionRule>
71 <finallyStatementRule>
72 <flowControlPropertyBody>
73 <flowControlStatementRule>
74 <foreachStatementRule>
75 <formatExpressionRule>
76 <ifStatementRule>
77 <logicalExpressionRule>
78 <lvalue>
79 <lvalueExpression>
80 <multiplyExpressionRule>
81 <ParameterArgumentToken>
82 <parseCallRule>
83 <pipelineRule>
84 <postfixOperatorRule>
85 <propertyOrArrayReferenceOperator>
86 <propertyOrArrayReferenceOperatorList>
87 <propertyOrArrayReferenceRule>
88 <rangeExpressionRule>
89 <statementBlockRule>
90 <statementListRule>
91 <statementRule>
92 <statementSeparatorToken>
93 <switchBody>
94 <switchCasesensitiveParameterRule>
95 <switchParameterRule>
96 <switchSelectorStatementRule>
97 <switchStatementRule>
98 <switchTypeStatementRule>
99 <trapStatementRule>
100 <valueRule>


Defined Character Sets
Name Characters
{WS} {HT}{VT}{FF}{Space}{NBSP}
{StringTokenCharSet1} {LF}{CR}{Space}!"#$%&()*+,-./0123456789:;<=>?@ABCD EFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvw xyz{|}~{NBSP}
{StringTokenCharSet2} {LF}{CR}{Space}!#$%&'()*+,-./0123456789:;<=>?@ABCD EFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvw xyz{|}~{NBSP}
{SimpleTextCharSet} !%&*-/0123456789;<>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ\^_ `abcdefghijklmnopqrstuvwxyz{}~
{SimpleTextCharSetNoDashAndNumber} !%&*/;<>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ\^_`abcdefghij klmnopqrstuvwxyz{}~
{HexNumber} 0123456789ABCDEFabcdef
{SimpleAlphaNumeric} 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz


Rules
Index Name ::= Definition
0 <statementSeparatorToken> ::= NewLine <statementSeparatorToken>
1 <statementSeparatorToken> ::=  
2 <statementListRule> ::= <statementRule>
3 <statementListRule> ::= <statementRule> <statementSeparatorToken> <statementListRule>
4 <statementBlockRule> ::= '{' <statementListRule> '}'
5 <statementRule> ::= <pipelineRule>
6 <statementRule> ::= CommentToken
7 <statementRule> ::= <ifStatementRule>
8 <statementRule> ::= <foreachStatementRule>
9 <statementRule> ::= <doWhileStatementRule>
10 <statementRule> ::= <flowControlStatementRule>
11 <statementRule> ::= <trapStatementRule>
12 <statementRule> ::= <finallyStatementRule>
13 <pipelineRule> ::= <cmdletCall>
14 <pipelineRule> ::= <cmdletCall> '|' <pipelineRule>
15 <pipelineRule> ::= <assignmentStatementRule>
16 <pipelineRule> ::= <assignmentStatementRule> '|' <pipelineRule>
17 <assignmentStatementRule> ::= <lvalueExpression> AssignmentOperatorToken <pipelineRule>
18 <lvalueExpression> ::= <lvalue>
19 <propertyOrArrayReferenceOperatorList> ::= <propertyOrArrayReferenceOperator>
20 <propertyOrArrayReferenceOperatorList> ::= <propertyOrArrayReferenceOperatorList> <propertyOrArrayReferenceOperator>
21 <lvalue> ::= VariableToken
22 <lvalue> ::= AttributeSpecificationToken VariableToken
23 <lvalue> ::= VariableToken <propertyOrArrayReferenceOperatorList>
24 <lvalue> ::= AttributeSpecificationToken VariableToken <propertyOrArrayReferenceOperatorList>
25 <ParameterArgumentToken> ::= <valueRule>
26 <ParameterArgumentToken> ::= AnyWordToken
27 <ParameterArgumentToken> ::= ParameterToken
28 <cmletParamsList> ::= <ParameterArgumentToken> <cmletParamsList>
29 <cmletParamsList> ::= <ParameterArgumentToken>
30 <cmdletName> ::= AnyWordToken
31 <cmdletCall> ::= ExecCall <cmdletName> <cmletParamsList>
32 <cmdletCall> ::= ExecCall <cmdletName>
33 <cmdletCall> ::= <cmdletName> <cmletParamsList>
34 <cmdletCall> ::= <cmdletName>
35 <cmdletCall> ::= <expressionRule>
36 <elseIfBlockRule> ::= elseif '(' <pipelineRule> ')' <statementBlockRule>
37 <elseIfBlockRule> ::= elseif '(' <pipelineRule> ')' <statementBlockRule> <elseIfBlockRule>
38 <ifStatementRule> ::= if '(' <pipelineRule> ')' <statementBlockRule>
39 <ifStatementRule> ::= if '(' <pipelineRule> ')' <statementBlockRule> <elseIfBlockRule>
40 <ifStatementRule> ::= if '(' <pipelineRule> ')' <statementBlockRule> else <statementBlockRule>
41 <ifStatementRule> ::= if '(' <pipelineRule> ')' <statementBlockRule> <elseIfBlockRule> else <statementBlockRule>
42 <switchTypeStatementRule> ::= -regex
43 <switchTypeStatementRule> ::= -wildcard
44 <switchTypeStatementRule> ::= -exact
45 <switchTypeStatementRule> ::=  
46 <switchCasesensitiveParameterRule> ::= -casesensitive
47 <switchCasesensitiveParameterRule> ::=  
48 <switchParameterRule> ::= -file <propertyOrArrayReferenceRule>
49 <switchParameterRule> ::= '(' <pipelineRule> ')'
50 <switchSelectorStatementRule> ::= default
51 <switchSelectorStatementRule> ::= <ParameterArgumentToken>
52 <switchSelectorStatementRule> ::= <propertyOrArrayReferenceRule>
53 <switchSelectorStatementRule> ::= <statementBlockRule>
54 <switchBody> ::= <switchSelectorStatementRule> <statementBlockRule>
55 <switchBody> ::= <switchSelectorStatementRule> <statementBlockRule> <switchBody>
56 <switchStatementRule> ::= switch <switchTypeStatementRule> <switchCasesensitiveParameterRule> <switchParameterRule> '{' <switchBody> '}'
57 <foreachStatementRule> ::= foreach '(' VariableToken in <pipelineRule> ')' <statementBlockRule>
58 <foreachStatementRule> ::= LoopLabelToken foreach '(' VariableToken in <pipelineRule> ')' <statementBlockRule>
59 <doWhileStatementRule> ::= do <statementBlockRule> while '(' <pipelineRule> ')'
60 <doWhileStatementRule> ::= do <statementBlockRule> until '(' <pipelineRule> ')'
61 <doWhileStatementRule> ::= LoopLabelToken do <statementBlockRule> while '(' <pipelineRule> ')'
62 <doWhileStatementRule> ::= LoopLabelToken do <statementBlockRule> until '(' <pipelineRule> ')'
63 <trapStatementRule> ::= trap <statementBlockRule>
64 <trapStatementRule> ::= trap AttributeSpecificationToken <statementBlockRule>
65 <finallyStatementRule> ::= finally <statementBlockRule>
66 <flowControlPropertyBody> ::= <propertyOrArrayReferenceRule>
67 <flowControlStatementRule> ::= break
68 <flowControlStatementRule> ::= continue
69 <flowControlStatementRule> ::= break <flowControlPropertyBody>
70 <flowControlStatementRule> ::= continue <flowControlPropertyBody>
71 <flowControlStatementRule> ::= return <pipelineRule>
72 <expressionRule> ::= <logicalExpressionRule>
73 <logicalExpressionRule> ::= <bitwiseExpressionRule>
74 <logicalExpressionRule> ::= <bitwiseExpressionRule> LogicalOperatorToken <logicalExpressionRule>
75 <bitwiseExpressionRule> ::= <comparisonExpressionRule>
76 <bitwiseExpressionRule> ::= <comparisonExpressionRule> BitwiseOperatorToken <bitwiseExpressionRule>
77 <comparisonExpressionRule> ::= <addExpressionRule>
78 <comparisonExpressionRule> ::= <addExpressionRule> ComparisonOperatorToken <comparisonExpressionRule>
79 <addExpressionRule> ::= <multiplyExpressionRule>
80 <addExpressionRule> ::= <multiplyExpressionRule> AdditionOperatorToken <addExpressionRule>
81 <multiplyExpressionRule> ::= <formatExpressionRule>
82 <multiplyExpressionRule> ::= <formatExpressionRule> MultiplyOperatorToken <multiplyExpressionRule>
83 <formatExpressionRule> ::= <rangeExpressionRule>
84 <formatExpressionRule> ::= <rangeExpressionRule> FormatOperatorToken <formatExpressionRule>
85 <rangeExpressionRule> ::= <arrayLiteralRule>
86 <rangeExpressionRule> ::= <arrayLiteralRule> RangeOperatorToken <rangeExpressionRule>
87 <arrayLiteralRule> ::= <postfixOperatorRule>
88 <arrayLiteralRule> ::= <postfixOperatorRule> CommaToken <arrayLiteralRule>
89 <postfixOperatorRule> ::= <lvalueExpression> PrePostfixOperatorToken
90 <postfixOperatorRule> ::= <propertyOrArrayReferenceRule>
91 <propertyOrArrayReferenceRule> ::= <valueRule>
92 <propertyOrArrayReferenceRule> ::= <valueRule> <propertyOrArrayReferenceOperatorList>
93 <propertyOrArrayReferenceOperator> ::= '[' <expressionRule> ']' ReferenceOperatorToken AnyWordToken
94 <propertyOrArrayReferenceOperator> ::= '[' <expressionRule> ']' ReferenceOperatorToken AnyWordToken <parseCallRule>
95 <propertyOrArrayReferenceOperator> ::= '[' <expressionRule> ']' <valueRule>
96 <parseCallRule> ::= '(' <arrayLiteralRule> ')'
97 <valueRule> ::= '(' <assignmentStatementRule> ')'
98 <valueRule> ::= '$(' <statementListRule> ')'
99 <valueRule> ::= '@(' <statementListRule> ')'
100 <valueRule> ::= UnaryOperatorToken <propertyOrArrayReferenceRule>
101 <valueRule> ::= AttributeSpecificationToken <propertyOrArrayReferenceRule>
102 <valueRule> ::= AttributeSpecificationToken
103 <valueRule> ::= NumberToken
104 <valueRule> ::= StringToken
105 <valueRule> ::= ExpandableStringToken
106 <valueRule> ::= VariableToken


DFA States


DFA State 0
Action Characters
Goto 1 {HT}{VT}{FF}{Space}{NBSP}
Goto 2 (
Goto 3 )
Goto 4 ]
Goto 5 |
Goto 6 ;?\^_`~
Goto 8 =
Goto 9 ,
Goto 10 {LF}
Goto 11 :
Goto 13 '
Goto 16 "
Goto 19 {CR}
Goto 21 !
Goto 22 #
Goto 24 $
Goto 27 %
Goto 29 &
Goto 30 *
Goto 33 +
Goto 36 -
Goto 249 .
Goto 252 /
Goto 255 0
Goto 261 1
Goto 264 2
Goto 260 3456789
Goto 269 <
Goto 271 >
Goto 274 @
Goto 276 Aa
Goto 325 Bb
Goto 330 Cc
Goto 338 Dd
Goto 346 Ee
Goto 352 Ff
Goto 376 GHJKLMNOPQVXYZghjklmnopqvxyz
Goto 377 Ii
Goto 380 Rr
Goto 386 Ss
Goto 392 Tt
Goto 396 Uu
Goto 401 Ww
Goto 406 [
Goto 409 {
Goto 410 }

DFA State 1
Action Characters
Goto 1 {HT}{VT}{FF}{Space}{NBSP}
Accept (Whitespace)  

DFA State 2
Action Characters
Accept '('  

DFA State 3
Action Characters
Accept ')'  

DFA State 4
Action Characters
Accept ']'  

DFA State 5
Action Characters
Accept '|'  

DFA State 6
Action Characters
Goto 7 !%&*-/0123456789;<>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ\^_ `abcdefghijklmnopqrstuvwxyz{}~

DFA State 7
Action Characters
Goto 7 !%&*-/0123456789;<>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ\^_ `abcdefghijklmnopqrstuvwxyz{}~
Accept AnyWordToken  

DFA State 8
Action Characters
Accept AssignmentOperatorToken  

DFA State 9
Action Characters
Accept CommaToken  

DFA State 10
Action Characters
Accept NewLine  

DFA State 11
Action Characters
Goto 12 :

DFA State 12
Action Characters
Accept ReferenceOperatorToken  

DFA State 13
Action Characters
Goto 14 {LF}{CR}{Space}!"#$%&()*+,-./0123456789:;<=>?@ABCD EFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvw xyz{|}~{NBSP}
Goto 15 '

DFA State 14
Action Characters
Goto 14 {LF}{CR}{Space}!"#$%&()*+,-./0123456789:;<=>?@ABCD EFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvw xyz{|}~{NBSP}
Goto 15 '

DFA State 15
Action Characters
Accept StringToken  

DFA State 16
Action Characters
Goto 17 {LF}{CR}{Space}!#$%&'()*+,-./0123456789:;<=>?@ABCD EFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvw xyz{|}~{NBSP}
Goto 18 "

DFA State 17
Action Characters
Goto 17 {LF}{CR}{Space}!#$%&'()*+,-./0123456789:;<=>?@ABCD EFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvw xyz{|}~{NBSP}
Goto 18 "

DFA State 18
Action Characters
Accept StringToken  

DFA State 19
Action Characters
Goto 20 {LF}
Accept NewLine  

DFA State 20
Action Characters
Accept NewLine  

DFA State 21
Action Characters
Goto 7 !%&*-/0123456789;<>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ\^_ `abcdefghijklmnopqrstuvwxyz{}~
Accept UnaryOperatorToken  

DFA State 22
Action Characters
Goto 23 {Space}!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJK LMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ {NBSP}
Accept (Comment Line)  

DFA State 23
Action Characters
Goto 23 {Space}!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJK LMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ {NBSP}
Accept CommentToken  

DFA State 24
Action Characters
Goto 25 (
Goto 26 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz

DFA State 25
Action Characters
Accept '$('  

DFA State 26
Action Characters
Goto 26 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Accept VariableToken  

DFA State 27
Action Characters
Goto 7 !%&*-/0123456789;<>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ\^_ `abcdefghijklmnopqrstuvwxyz{}~
Goto 28 =
Accept MultiplyOperatorToken  

DFA State 28
Action Characters
Accept AssignmentOperatorToken  

DFA State 29
Action Characters
Goto 7 !%&*-/0123456789;<>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ\^_ `abcdefghijklmnopqrstuvwxyz{}~
Accept ExecCall  

DFA State 30
Action Characters
Goto 7 !%&*-0123456789;<>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ\^_` abcdefghijklmnopqrstuvwxyz{}~
Goto 31 =
Goto 32 /
Accept MultiplyOperatorToken  

DFA State 31
Action Characters
Accept AssignmentOperatorToken  

DFA State 32
Action Characters
Goto 7 !%&*-/0123456789;<>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ\^_ `abcdefghijklmnopqrstuvwxyz{}~
Accept (Comment End)  

DFA State 33
Action Characters
Goto 34 =
Goto 35 +
Accept AdditionOperatorToken  

DFA State 34
Action Characters
Accept AssignmentOperatorToken  

DFA State 35
Action Characters
Accept PrePostfixOperatorToken  

DFA State 36
Action Characters
Goto 37 =
Goto 38 DHJKPQSTUVXYZdhjkpqstuvxyz
Goto 41 -
Goto 42 Aa
Goto 46 Bb
Goto 55 Cc
Goto 127 Ee
Goto 133 Ff
Goto 137 Gg
Goto 140 Ii
Goto 197 Ll
Goto 203 Mm
Goto 208 Nn
Goto 229 Oo
Goto 231 Rr
Goto 241 Ww
Accept AdditionOperatorToken  

DFA State 37
Action Characters
Accept AssignmentOperatorToken  

DFA State 38
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept ParameterToken  

DFA State 39
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept ParameterToken  

DFA State 40
Action Characters
Accept ParameterToken  

DFA State 41
Action Characters
Accept PrePostfixOperatorToken  

DFA State 42
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMOPQRTUVWXYZabcdefghijklmopq rtuvwxyz
Goto 40 :
Goto 43 Nn
Goto 45 Ss
Accept ParameterToken  

DFA State 43
Action Characters
Goto 39 0123456789ABCEFGHIJKLMNOPQRSTUVWXYZabcefghijklmnop qrstuvwxyz
Goto 40 :
Goto 44 Dd
Accept ParameterToken  

DFA State 44
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept LogicalOperatorToken  

DFA State 45
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept ComparisonOperatorToken  

DFA State 46
Action Characters
Goto 39 0123456789BCDEFGHIJKLMPQRSTUVWXYZbcdefghijklmpqrst uvwxyz
Goto 40 :
Goto 47 Aa
Goto 50 Nn
Goto 53 Oo
Accept ParameterToken  

DFA State 47
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMOPQRSTUVWXYZabcdefghijklmop qrstuvwxyz
Goto 40 :
Goto 48 Nn
Accept ParameterToken  

DFA State 48
Action Characters
Goto 39 0123456789ABCEFGHIJKLMNOPQRSTUVWXYZabcefghijklmnop qrstuvwxyz
Goto 40 :
Goto 49 Dd
Accept ParameterToken  

DFA State 49
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept BitwiseOperatorToken  

DFA State 50
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNPQRSTUVWXYZabcdefghijklmnp qrstuvwxyz
Goto 40 :
Goto 51 Oo
Accept ParameterToken  

DFA State 51
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSUVWXYZabcdefghijklmno pqrsuvwxyz
Goto 40 :
Goto 52 Tt
Accept ParameterToken  

DFA State 52
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept UnaryOperatorToken  

DFA State 53
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQSTUVWXYZabcdefghijklmno pqstuvwxyz
Goto 40 :
Goto 54 Rr
Accept ParameterToken  

DFA State 54
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept BitwiseOperatorToken  

DFA State 55
Action Characters
Goto 39 0123456789BDFHIJKPQSTUVWXYZbdfhijkpqstuvwxyz
Goto 40 :
Goto 56 Aa
Goto 68 Cc
Goto 76 Ee
Goto 78 Gg
Goto 81 Ll
Goto 87 Mm
Goto 92 Nn
Goto 113 Oo
Goto 120 Rr
Accept ParameterToken  

DFA State 56
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRTUVWXYZabcdefghijklmno pqrtuvwxyz
Goto 40 :
Goto 57 Ss
Accept ParameterToken  

DFA State 57
Action Characters
Goto 39 0123456789ABCDFGHIJKLMNOPQRSTUVWXYZabcdfghijklmnop qrstuvwxyz
Goto 40 :
Goto 58 Ee
Accept ParameterToken  

DFA State 58
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRTUVWXYZabcdefghijklmno pqrtuvwxyz
Goto 40 :
Goto 59 Ss
Accept ParameterToken  

DFA State 59
Action Characters
Goto 39 0123456789ABCDFGHIJKLMNOPQRSTUVWXYZabcdfghijklmnop qrstuvwxyz
Goto 40 :
Goto 60 Ee
Accept ParameterToken  

DFA State 60
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMOPQRSTUVWXYZabcdefghijklmop qrstuvwxyz
Goto 40 :
Goto 61 Nn
Accept ParameterToken  

DFA State 61
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRTUVWXYZabcdefghijklmno pqrtuvwxyz
Goto 40 :
Goto 62 Ss
Accept ParameterToken  

DFA State 62
Action Characters
Goto 39 0123456789ABCDEFGHJKLMNOPQRSTUVWXYZabcdefghjklmnop qrstuvwxyz
Goto 40 :
Goto 63 Ii
Accept ParameterToken  

DFA State 63
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSUVWXYZabcdefghijklmno pqrsuvwxyz
Goto 40 :
Goto 64 Tt
Accept ParameterToken  

DFA State 64
Action Characters
Goto 39 0123456789ABCDEFGHJKLMNOPQRSTUVWXYZabcdefghjklmnop qrstuvwxyz
Goto 40 :
Goto 65 Ii
Accept ParameterToken  

DFA State 65
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUWXYZabcdefghijklmno pqrstuwxyz
Goto 40 :
Goto 66 Vv
Accept ParameterToken  

DFA State 66
Action Characters
Goto 39 0123456789ABCDFGHIJKLMNOPQRSTUVWXYZabcdfghijklmnop qrstuvwxyz
Goto 40 :
Goto 67 Ee
Accept ParameterToken  

DFA State 67
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept -casesensitive  

DFA State 68
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNPQRSTUVWXYZabcdefghijklmnp qrstuvwxyz
Goto 40 :
Goto 69 Oo
Accept ParameterToken  

DFA State 69
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMOPQRSTUVWXYZabcdefghijklmop qrstuvwxyz
Goto 40 :
Goto 70 Nn
Accept ParameterToken  

DFA State 70
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSUVWXYZabcdefghijklmno pqrsuvwxyz
Goto 40 :
Goto 71 Tt
Accept ParameterToken  

DFA State 71
Action Characters
Goto 39 0123456789BCDEFGHIJKLMNOPQRSTUVWXYZbcdefghijklmnop qrstuvwxyz
Goto 40 :
Goto 72 Aa
Accept ParameterToken  

DFA State 72
Action Characters
Goto 39 0123456789ABCDEFGHJKLMNOPQRSTUVWXYZabcdefghjklmnop qrstuvwxyz
Goto 40 :
Goto 73 Ii
Accept ParameterToken  

DFA State 73
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMOPQRSTUVWXYZabcdefghijklmop qrstuvwxyz
Goto 40 :
Goto 74 Nn
Accept ParameterToken  

DFA State 74
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRTUVWXYZabcdefghijklmno pqrtuvwxyz
Goto 40 :
Goto 75 Ss
Accept ParameterToken  

DFA State 75
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept ComparisonOperatorToken  

DFA State 76
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPRSTUVWXYZabcdefghijklmno prstuvwxyz
Goto 40 :
Goto 77 Qq
Accept ParameterToken  

DFA State 77
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept ComparisonOperatorToken  

DFA State 78
Action Characters
Goto 39 0123456789ABCDFGHIJKLMNOPQRSUVWXYZabcdfghijklmnopq rsuvwxyz
Goto 40 :
Goto 79 Ee
Goto 80 Tt
Accept ParameterToken  

DFA State 79
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept ComparisonOperatorToken  

DFA State 80
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept ComparisonOperatorToken  

DFA State 81
Action Characters
Goto 39 0123456789ABCDFGHJKLMNOPQRSUVWXYZabcdfghjklmnopqrs uvwxyz
Goto 40 :
Goto 82 Ee
Goto 83 Ii
Goto 86 Tt
Accept ParameterToken  

DFA State 82
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept ComparisonOperatorToken  

DFA State 83
Action Characters
Goto 39 0123456789ABCDEFGHIJLMNOPQRSTUVWXYZabcdefghijlmnop qrstuvwxyz
Goto 40 :
Goto 84 Kk
Accept ParameterToken  

DFA State 84
Action Characters
Goto 39 0123456789ABCDFGHIJKLMNOPQRSTUVWXYZabcdfghijklmnop qrstuvwxyz
Goto 40 :
Goto 85 Ee
Accept ParameterToken  

DFA State 85
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept ComparisonOperatorToken  

DFA State 86
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept ComparisonOperatorToken  

DFA State 87
Action Characters
Goto 39 0123456789BCDEFGHIJKLMNOPQRSTUVWXYZbcdefghijklmnop qrstuvwxyz
Goto 40 :
Goto 88 Aa
Accept ParameterToken  

DFA State 88
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSUVWXYZabcdefghijklmno pqrsuvwxyz
Goto 40 :
Goto 89 Tt
Accept ParameterToken  

DFA State 89
Action Characters
Goto 39 0123456789ABDEFGHIJKLMNOPQRSTUVWXYZabdefghijklmnop qrstuvwxyz
Goto 40 :
Goto 90 Cc
Accept ParameterToken  

DFA State 90
Action Characters
Goto 39 0123456789ABCDEFGIJKLMNOPQRSTUVWXYZabcdefgijklmnop qrstuvwxyz
Goto 40 :
Goto 91 Hh
Accept ParameterToken  

DFA State 91
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept ComparisonOperatorToken  

DFA State 92
Action Characters
Goto 39 0123456789ABCDFGHIJKLMNPQRSTUVWXYZabcdfghijklmnpqr stuvwxyz
Goto 40 :
Goto 93 Ee
Goto 94 Oo
Accept ParameterToken  

DFA State 93
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept ComparisonOperatorToken  

DFA State 94
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSUVWXYZabcdefghijklmno pqrsuvwxyz
Goto 40 :
Goto 95 Tt
Accept ParameterToken  

DFA State 95
Action Characters
Goto 39 0123456789ABDEFGHIJKNOPQRSTUVWXYZabdefghijknopqrst uvwxyz
Goto 40 :
Goto 96 Cc
Goto 104 Ll
Goto 108 Mm
Accept ParameterToken  

DFA State 96
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNPQRSTUVWXYZabcdefghijklmnp qrstuvwxyz
Goto 40 :
Goto 97 Oo
Accept ParameterToken  

DFA State 97
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMOPQRSTUVWXYZabcdefghijklmop qrstuvwxyz
Goto 40 :
Goto 98 Nn
Accept ParameterToken  

DFA State 98
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSUVWXYZabcdefghijklmno pqrsuvwxyz
Goto 40 :
Goto 99 Tt
Accept ParameterToken  

DFA State 99
Action Characters
Goto 39 0123456789BCDEFGHIJKLMNOPQRSTUVWXYZbcdefghijklmnop qrstuvwxyz
Goto 40 :
Goto 100 Aa
Accept ParameterToken  

DFA State 100
Action Characters
Goto 39 0123456789ABCDEFGHJKLMNOPQRSTUVWXYZabcdefghjklmnop qrstuvwxyz
Goto 40 :
Goto 101 Ii
Accept ParameterToken  

DFA State 101
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMOPQRSTUVWXYZabcdefghijklmop qrstuvwxyz
Goto 40 :
Goto 102 Nn
Accept ParameterToken  

DFA State 102
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRTUVWXYZabcdefghijklmno pqrtuvwxyz
Goto 40 :
Goto 103 Ss
Accept ParameterToken  

DFA State 103
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept ComparisonOperatorToken  

DFA State 104
Action Characters
Goto 39 0123456789ABCDEFGHJKLMNOPQRSTUVWXYZabcdefghjklmnop qrstuvwxyz
Goto 40 :
Goto 105 Ii
Accept ParameterToken  

DFA State 105
Action Characters
Goto 39 0123456789ABCDEFGHIJLMNOPQRSTUVWXYZabcdefghijlmnop qrstuvwxyz
Goto 40 :
Goto 106 Kk
Accept ParameterToken  

DFA State 106
Action Characters
Goto 39 0123456789ABCDFGHIJKLMNOPQRSTUVWXYZabcdfghijklmnop qrstuvwxyz
Goto 40 :
Goto 107 Ee
Accept ParameterToken  

DFA State 107
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept ComparisonOperatorToken  

DFA State 108
Action Characters
Goto 39 0123456789BCDEFGHIJKLMNOPQRSTUVWXYZbcdefghijklmnop qrstuvwxyz
Goto 40 :
Goto 109 Aa
Accept ParameterToken  

DFA State 109
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSUVWXYZabcdefghijklmno pqrsuvwxyz
Goto 40 :
Goto 110 Tt
Accept ParameterToken  

DFA State 110
Action Characters
Goto 39 0123456789ABDEFGHIJKLMNOPQRSTUVWXYZabdefghijklmnop qrstuvwxyz
Goto 40 :
Goto 111 Cc
Accept ParameterToken  

DFA State 111
Action Characters
Goto 39 0123456789ABCDEFGIJKLMNOPQRSTUVWXYZabcdefgijklmnop qrstuvwxyz
Goto 40 :
Goto 112 Hh
Accept ParameterToken  

DFA State 112
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept ComparisonOperatorToken  

DFA State 113
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMOPQRSTUVWXYZabcdefghijklmop qrstuvwxyz
Goto 40 :
Goto 114 Nn
Accept ParameterToken  

DFA State 114
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSUVWXYZabcdefghijklmno pqrsuvwxyz
Goto 40 :
Goto 115 Tt
Accept ParameterToken  

DFA State 115
Action Characters
Goto 39 0123456789BCDEFGHIJKLMNOPQRSTUVWXYZbcdefghijklmnop qrstuvwxyz
Goto 40 :
Goto 116 Aa
Accept ParameterToken  

DFA State 116
Action Characters
Goto 39 0123456789ABCDEFGHJKLMNOPQRSTUVWXYZabcdefghjklmnop qrstuvwxyz
Goto 40 :
Goto 117 Ii
Accept ParameterToken  

DFA State 117
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMOPQRSTUVWXYZabcdefghijklmop qrstuvwxyz
Goto 40 :
Goto 118 Nn
Accept ParameterToken  

DFA State 118
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRTUVWXYZabcdefghijklmno pqrtuvwxyz
Goto 40 :
Goto 119 Ss
Accept ParameterToken  

DFA State 119
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept ComparisonOperatorToken  

DFA State 120
Action Characters
Goto 39 0123456789ABCDFGHIJKLMNOPQRSTUVWXYZabcdfghijklmnop qrstuvwxyz
Goto 40 :
Goto 121 Ee
Accept ParameterToken  

DFA State 121
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOQRSTUVWXYZabcdefghijklmno qrstuvwxyz
Goto 40 :
Goto 122 Pp
Accept ParameterToken  

DFA State 122
Action Characters
Goto 39 0123456789ABCDEFGHIJKMNOPQRSTUVWXYZabcdefghijkmnop qrstuvwxyz
Goto 40 :
Goto 123 Ll
Accept ParameterToken  

DFA State 123
Action Characters
Goto 39 0123456789BCDEFGHIJKLMNOPQRSTUVWXYZbcdefghijklmnop qrstuvwxyz
Goto 40 :
Goto 124 Aa
Accept ParameterToken  

DFA State 124
Action Characters
Goto 39 0123456789ABDEFGHIJKLMNOPQRSTUVWXYZabdefghijklmnop qrstuvwxyz
Goto 40 :
Goto 125 Cc
Accept ParameterToken  

DFA State 125
Action Characters
Goto 39 0123456789ABCDFGHIJKLMNOPQRSTUVWXYZabcdfghijklmnop qrstuvwxyz
Goto 40 :
Goto 126 Ee
Accept ParameterToken  

DFA State 126
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept ComparisonOperatorToken  

DFA State 127
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPRSTUVWYZabcdefghijklmnop rstuvwyz
Goto 40 :
Goto 128 Qq
Goto 129 Xx
Accept ParameterToken  

DFA State 128
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept ComparisonOperatorToken  

DFA State 129
Action Characters
Goto 39 0123456789BCDEFGHIJKLMNOPQRSTUVWXYZbcdefghijklmnop qrstuvwxyz
Goto 40 :
Goto 130 Aa
Accept ParameterToken  

DFA State 130
Action Characters
Goto 39 0123456789ABDEFGHIJKLMNOPQRSTUVWXYZabdefghijklmnop qrstuvwxyz
Goto 40 :
Goto 131 Cc
Accept ParameterToken  

DFA State 131
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSUVWXYZabcdefghijklmno pqrsuvwxyz
Goto 40 :
Goto 132 Tt
Accept ParameterToken  

DFA State 132
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept -exact  

DFA State 133
Action Characters
Goto 39 0123456789ABCDEFGHJKLMNOPQRSTUVWXYZabcdefghjklmnop qrstuvwxyz
Goto 40 :
Goto 134 Ii
Accept FormatOperatorToken  

DFA State 134
Action Characters
Goto 39 0123456789ABCDEFGHIJKMNOPQRSTUVWXYZabcdefghijkmnop qrstuvwxyz
Goto 40 :
Goto 135 Ll
Accept ParameterToken  

DFA State 135
Action Characters
Goto 39 0123456789ABCDFGHIJKLMNOPQRSTUVWXYZabcdfghijklmnop qrstuvwxyz
Goto 40 :
Goto 136 Ee
Accept ParameterToken  

DFA State 136
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept -file  

DFA State 137
Action Characters
Goto 39 0123456789ABCDFGHIJKLMNOPQRSUVWXYZabcdfghijklmnopq rsuvwxyz
Goto 40 :
Goto 138 Ee
Goto 139 Tt
Accept ParameterToken  

DFA State 138
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept ComparisonOperatorToken  

DFA State 139
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept ComparisonOperatorToken  

DFA State 140
Action Characters
Goto 39 0123456789ABDFHIJKOPQTUVWXYZabdfhijkopqtuvwxyz
Goto 40 :
Goto 141 Cc
Goto 149 Ee
Goto 151 Gg
Goto 154 Ll
Goto 160 Mm
Goto 165 Nn
Goto 186 Rr
Goto 193 Ss
Accept ParameterToken  

DFA State 141
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNPQRSTUVWXYZabcdefghijklmnp qrstuvwxyz
Goto 40 :
Goto 142 Oo
Accept ParameterToken  

DFA State 142
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMOPQRSTUVWXYZabcdefghijklmop qrstuvwxyz
Goto 40 :
Goto 143 Nn
Accept ParameterToken  

DFA State 143
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSUVWXYZabcdefghijklmno pqrsuvwxyz
Goto 40 :
Goto 144 Tt
Accept ParameterToken  

DFA State 144
Action Characters
Goto 39 0123456789BCDEFGHIJKLMNOPQRSTUVWXYZbcdefghijklmnop qrstuvwxyz
Goto 40 :
Goto 145 Aa
Accept ParameterToken  

DFA State 145
Action Characters
Goto 39 0123456789ABCDEFGHJKLMNOPQRSTUVWXYZabcdefghjklmnop qrstuvwxyz
Goto 40 :
Goto 146 Ii
Accept ParameterToken  

DFA State 146
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMOPQRSTUVWXYZabcdefghijklmop qrstuvwxyz
Goto 40 :
Goto 147 Nn
Accept ParameterToken  

DFA State 147
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRTUVWXYZabcdefghijklmno pqrtuvwxyz
Goto 40 :
Goto 148 Ss
Accept ParameterToken  

DFA State 148
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept ComparisonOperatorToken  

DFA State 149
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPRSTUVWXYZabcdefghijklmno prstuvwxyz
Goto 40 :
Goto 150 Qq
Accept ParameterToken  

DFA State 150
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept ComparisonOperatorToken  

DFA State 151
Action Characters
Goto 39 0123456789ABCDFGHIJKLMNOPQRSUVWXYZabcdfghijklmnopq rsuvwxyz
Goto 40 :
Goto 152 Ee
Goto 153 Tt
Accept ParameterToken  

DFA State 152
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept ComparisonOperatorToken  

DFA State 153
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept ComparisonOperatorToken  

DFA State 154
Action Characters
Goto 39 0123456789ABCDFGHJKLMNOPQRSUVWXYZabcdfghjklmnopqrs uvwxyz
Goto 40 :
Goto 155 Ee
Goto 156 Ii
Goto 159 Tt
Accept ParameterToken  

DFA State 155
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept ComparisonOperatorToken  

DFA State 156
Action Characters
Goto 39 0123456789ABCDEFGHIJLMNOPQRSTUVWXYZabcdefghijlmnop qrstuvwxyz
Goto 40 :
Goto 157 Kk
Accept ParameterToken  

DFA State 157
Action Characters
Goto 39 0123456789ABCDFGHIJKLMNOPQRSTUVWXYZabcdfghijklmnop qrstuvwxyz
Goto 40 :
Goto 158 Ee
Accept ParameterToken  

DFA State 158
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept ComparisonOperatorToken  

DFA State 159
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept ComparisonOperatorToken  

DFA State 160
Action Characters
Goto 39 0123456789BCDEFGHIJKLMNOPQRSTUVWXYZbcdefghijklmnop qrstuvwxyz
Goto 40 :
Goto 161 Aa
Accept ParameterToken  

DFA State 161
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSUVWXYZabcdefghijklmno pqrsuvwxyz
Goto 40 :
Goto 162 Tt
Accept ParameterToken  

DFA State 162
Action Characters
Goto 39 0123456789ABDEFGHIJKLMNOPQRSTUVWXYZabdefghijklmnop qrstuvwxyz
Goto 40 :
Goto 163 Cc
Accept ParameterToken  

DFA State 163
Action Characters
Goto 39 0123456789ABCDEFGIJKLMNOPQRSTUVWXYZabcdefgijklmnop qrstuvwxyz
Goto 40 :
Goto 164 Hh
Accept ParameterToken  

DFA State 164
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept ComparisonOperatorToken  

DFA State 165
Action Characters
Goto 39 0123456789ABCDFGHIJKLMNPQRSTUVWXYZabcdfghijklmnpqr stuvwxyz
Goto 40 :
Goto 166 Ee
Goto 167 Oo
Accept ParameterToken  

DFA State 166
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept ComparisonOperatorToken  

DFA State 167
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSUVWXYZabcdefghijklmno pqrsuvwxyz
Goto 40 :
Goto 168 Tt
Accept ParameterToken  

DFA State 168
Action Characters
Goto 39 0123456789ABDEFGHIJKNOPQRSTUVWXYZabdefghijknopqrst uvwxyz
Goto 40 :
Goto 169 Cc
Goto 177 Ll
Goto 181 Mm
Accept ParameterToken  

DFA State 169
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNPQRSTUVWXYZabcdefghijklmnp qrstuvwxyz
Goto 40 :
Goto 170 Oo
Accept ParameterToken  

DFA State 170
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMOPQRSTUVWXYZabcdefghijklmop qrstuvwxyz
Goto 40 :
Goto 171 Nn
Accept ParameterToken  

DFA State 171
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSUVWXYZabcdefghijklmno pqrsuvwxyz
Goto 40 :
Goto 172 Tt
Accept ParameterToken  

DFA State 172
Action Characters
Goto 39 0123456789BCDEFGHIJKLMNOPQRSTUVWXYZbcdefghijklmnop qrstuvwxyz
Goto 40 :
Goto 173 Aa
Accept ParameterToken  

DFA State 173
Action Characters
Goto 39 0123456789ABCDEFGHJKLMNOPQRSTUVWXYZabcdefghjklmnop qrstuvwxyz
Goto 40 :
Goto 174 Ii
Accept ParameterToken  

DFA State 174
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMOPQRSTUVWXYZabcdefghijklmop qrstuvwxyz
Goto 40 :
Goto 175 Nn
Accept ParameterToken  

DFA State 175
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRTUVWXYZabcdefghijklmno pqrtuvwxyz
Goto 40 :
Goto 176 Ss
Accept ParameterToken  

DFA State 176
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept ComparisonOperatorToken  

DFA State 177
Action Characters
Goto 39 0123456789ABCDEFGHJKLMNOPQRSTUVWXYZabcdefghjklmnop qrstuvwxyz
Goto 40 :
Goto 178 Ii
Accept ParameterToken  

DFA State 178
Action Characters
Goto 39 0123456789ABCDEFGHIJLMNOPQRSTUVWXYZabcdefghijlmnop qrstuvwxyz
Goto 40 :
Goto 179 Kk
Accept ParameterToken  

DFA State 179
Action Characters
Goto 39 0123456789ABCDFGHIJKLMNOPQRSTUVWXYZabcdfghijklmnop qrstuvwxyz
Goto 40 :
Goto 180 Ee
Accept ParameterToken  

DFA State 180
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept ComparisonOperatorToken  

DFA State 181
Action Characters
Goto 39 0123456789BCDEFGHIJKLMNOPQRSTUVWXYZbcdefghijklmnop qrstuvwxyz
Goto 40 :
Goto 182 Aa
Accept ParameterToken  

DFA State 182
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSUVWXYZabcdefghijklmno pqrsuvwxyz
Goto 40 :
Goto 183 Tt
Accept ParameterToken  

DFA State 183
Action Characters
Goto 39 0123456789ABDEFGHIJKLMNOPQRSTUVWXYZabdefghijklmnop qrstuvwxyz
Goto 40 :
Goto 184 Cc
Accept ParameterToken  

DFA State 184
Action Characters
Goto 39 0123456789ABCDEFGIJKLMNOPQRSTUVWXYZabcdefgijklmnop qrstuvwxyz
Goto 40 :
Goto 185 Hh
Accept ParameterToken  

DFA State 185
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept ComparisonOperatorToken  

DFA State 186
Action Characters
Goto 39 0123456789ABCDFGHIJKLMNOPQRSTUVWXYZabcdfghijklmnop qrstuvwxyz
Goto 40 :
Goto 187 Ee
Accept ParameterToken  

DFA State 187
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOQRSTUVWXYZabcdefghijklmno qrstuvwxyz
Goto 40 :
Goto 188 Pp
Accept ParameterToken  

DFA State 188
Action Characters
Goto 39 0123456789ABCDEFGHIJKMNOPQRSTUVWXYZabcdefghijkmnop qrstuvwxyz
Goto 40 :
Goto 189 Ll
Accept ParameterToken  

DFA State 189
Action Characters
Goto 39 0123456789BCDEFGHIJKLMNOPQRSTUVWXYZbcdefghijklmnop qrstuvwxyz
Goto 40 :
Goto 190 Aa
Accept ParameterToken  

DFA State 190
Action Characters
Goto 39 0123456789ABDEFGHIJKLMNOPQRSTUVWXYZabdefghijklmnop qrstuvwxyz
Goto 40 :
Goto 191 Cc
Accept ParameterToken  

DFA State 191
Action Characters
Goto 39 0123456789ABCDFGHIJKLMNOPQRSTUVWXYZabcdfghijklmnop qrstuvwxyz
Goto 40 :
Goto 192 Ee
Accept ParameterToken  

DFA State 192
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept ComparisonOperatorToken  

DFA State 193
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMOPQRSTUVWXYZabcdefghijklmop qrstuvwxyz
Goto 40 :
Goto 194 Nn
Accept ComparisonOperatorToken  

DFA State 194
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNPQRSTUVWXYZabcdefghijklmnp qrstuvwxyz
Goto 40 :
Goto 195 Oo
Accept ParameterToken  

DFA State 195
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSUVWXYZabcdefghijklmno pqrsuvwxyz
Goto 40 :
Goto 196 Tt
Accept ParameterToken  

DFA State 196
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept ComparisonOperatorToken  

DFA State 197
Action Characters
Goto 39 0123456789ABCDFGHJKLMNOPQRSUVWXYZabcdfghjklmnopqrs uvwxyz
Goto 40 :
Goto 198 Ee
Goto 199 Ii
Goto 202 Tt
Accept ParameterToken  

DFA State 198
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept ComparisonOperatorToken  

DFA State 199
Action Characters
Goto 39 0123456789ABCDEFGHIJLMNOPQRSTUVWXYZabcdefghijlmnop qrstuvwxyz
Goto 40 :
Goto 200 Kk
Accept ParameterToken  

DFA State 200
Action Characters
Goto 39 0123456789ABCDFGHIJKLMNOPQRSTUVWXYZabcdfghijklmnop qrstuvwxyz
Goto 40 :
Goto 201 Ee
Accept ParameterToken  

DFA State 201
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept ComparisonOperatorToken  

DFA State 202
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept ComparisonOperatorToken  

DFA State 203
Action Characters
Goto 39 0123456789BCDEFGHIJKLMNOPQRSTUVWXYZbcdefghijklmnop qrstuvwxyz
Goto 40 :
Goto 204 Aa
Accept ParameterToken  

DFA State 204
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSUVWXYZabcdefghijklmno pqrsuvwxyz
Goto 40 :
Goto 205 Tt
Accept ParameterToken  

DFA State 205
Action Characters
Goto 39 0123456789ABDEFGHIJKLMNOPQRSTUVWXYZabdefghijklmnop qrstuvwxyz
Goto 40 :
Goto 206 Cc
Accept ParameterToken  

DFA State 206
Action Characters
Goto 39 0123456789ABCDEFGIJKLMNOPQRSTUVWXYZabcdefgijklmnop qrstuvwxyz
Goto 40 :
Goto 207 Hh
Accept ParameterToken  

DFA State 207
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept ComparisonOperatorToken  

DFA State 208
Action Characters
Goto 39 0123456789ABCDFGHIJKLMNPQRSTUVWXYZabcdfghijklmnpqr stuvwxyz
Goto 40 :
Goto 209 Ee
Goto 210 Oo
Accept ParameterToken  

DFA State 209
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept ComparisonOperatorToken  

DFA State 210
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSUVWXYZabcdefghijklmno pqrsuvwxyz
Goto 40 :
Goto 211 Tt
Accept ParameterToken  

DFA State 211
Action Characters
Goto 39 0123456789ABDEFGHIJKNOPQRSTUVWXYZabdefghijknopqrst uvwxyz
Goto 40 :
Goto 212 Cc
Goto 220 Ll
Goto 224 Mm
Accept UnaryOperatorToken  

DFA State 212
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNPQRSTUVWXYZabcdefghijklmnp qrstuvwxyz
Goto 40 :
Goto 213 Oo
Accept ParameterToken  

DFA State 213
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMOPQRSTUVWXYZabcdefghijklmop qrstuvwxyz
Goto 40 :
Goto 214 Nn
Accept ParameterToken  

DFA State 214
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSUVWXYZabcdefghijklmno pqrsuvwxyz
Goto 40 :
Goto 215 Tt
Accept ParameterToken  

DFA State 215
Action Characters
Goto 39 0123456789BCDEFGHIJKLMNOPQRSTUVWXYZbcdefghijklmnop qrstuvwxyz
Goto 40 :
Goto 216 Aa
Accept ParameterToken  

DFA State 216
Action Characters
Goto 39 0123456789ABCDEFGHJKLMNOPQRSTUVWXYZabcdefghjklmnop qrstuvwxyz
Goto 40 :
Goto 217 Ii
Accept ParameterToken  

DFA State 217
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMOPQRSTUVWXYZabcdefghijklmop qrstuvwxyz
Goto 40 :
Goto 218 Nn
Accept ParameterToken  

DFA State 218
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRTUVWXYZabcdefghijklmno pqrtuvwxyz
Goto 40 :
Goto 219 Ss
Accept ParameterToken  

DFA State 219
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept ComparisonOperatorToken  

DFA State 220
Action Characters
Goto 39 0123456789ABCDEFGHJKLMNOPQRSTUVWXYZabcdefghjklmnop qrstuvwxyz
Goto 40 :
Goto 221 Ii
Accept ParameterToken  

DFA State 221
Action Characters
Goto 39 0123456789ABCDEFGHIJLMNOPQRSTUVWXYZabcdefghijlmnop qrstuvwxyz
Goto 40 :
Goto 222 Kk
Accept ParameterToken  

DFA State 222
Action Characters
Goto 39 0123456789ABCDFGHIJKLMNOPQRSTUVWXYZabcdfghijklmnop qrstuvwxyz
Goto 40 :
Goto 223 Ee
Accept ParameterToken  

DFA State 223
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept ComparisonOperatorToken  

DFA State 224
Action Characters
Goto 39 0123456789BCDEFGHIJKLMNOPQRSTUVWXYZbcdefghijklmnop qrstuvwxyz
Goto 40 :
Goto 225 Aa
Accept ParameterToken  

DFA State 225
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSUVWXYZabcdefghijklmno pqrsuvwxyz
Goto 40 :
Goto 226 Tt
Accept ParameterToken  

DFA State 226
Action Characters
Goto 39 0123456789ABDEFGHIJKLMNOPQRSTUVWXYZabdefghijklmnop qrstuvwxyz
Goto 40 :
Goto 227 Cc
Accept ParameterToken  

DFA State 227
Action Characters
Goto 39 0123456789ABCDEFGIJKLMNOPQRSTUVWXYZabcdefgijklmnop qrstuvwxyz
Goto 40 :
Goto 228 Hh
Accept ParameterToken  

DFA State 228
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept ComparisonOperatorToken  

DFA State 229
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQSTUVWXYZabcdefghijklmno pqstuvwxyz
Goto 40 :
Goto 230 Rr
Accept ParameterToken  

DFA State 230
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept LogicalOperatorToken  

DFA State 231
Action Characters
Goto 39 0123456789ABCDFGHIJKLMNOPQRSTUVWXYZabcdfghijklmnop qrstuvwxyz
Goto 40 :
Goto 232 Ee
Accept ParameterToken  

DFA State 232
Action Characters
Goto 39 0123456789ABCDEFHIJKLMNOQRSTUVWXYZabcdefhijklmnoqr stuvwxyz
Goto 40 :
Goto 233 Gg
Goto 236 Pp
Accept ParameterToken  

DFA State 233
Action Characters
Goto 39 0123456789ABCDFGHIJKLMNOPQRSTUVWXYZabcdfghijklmnop qrstuvwxyz
Goto 40 :
Goto 234 Ee
Accept ParameterToken  

DFA State 234
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWYZabcdefghijklmno pqrstuvwyz
Goto 40 :
Goto 235 Xx
Accept ParameterToken  

DFA State 235
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept -regex  

DFA State 236
Action Characters
Goto 39 0123456789ABCDEFGHIJKMNOPQRSTUVWXYZabcdefghijkmnop qrstuvwxyz
Goto 40 :
Goto 237 Ll
Accept ParameterToken  

DFA State 237
Action Characters
Goto 39 0123456789BCDEFGHIJKLMNOPQRSTUVWXYZbcdefghijklmnop qrstuvwxyz
Goto 40 :
Goto 238 Aa
Accept ParameterToken  

DFA State 238
Action Characters
Goto 39 0123456789ABDEFGHIJKLMNOPQRSTUVWXYZabdefghijklmnop qrstuvwxyz
Goto 40 :
Goto 239 Cc
Accept ParameterToken  

DFA State 239
Action Characters
Goto 39 0123456789ABCDFGHIJKLMNOPQRSTUVWXYZabcdfghijklmnop qrstuvwxyz
Goto 40 :
Goto 240 Ee
Accept ParameterToken  

DFA State 240
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept ComparisonOperatorToken  

DFA State 241
Action Characters
Goto 39 0123456789ABCDEFGHJKLMNOPQRSTUVWXYZabcdefghjklmnop qrstuvwxyz
Goto 40 :
Goto 242 Ii
Accept ParameterToken  

DFA State 242
Action Characters
Goto 39 0123456789ABCDEFGHIJKMNOPQRSTUVWXYZabcdefghijkmnop qrstuvwxyz
Goto 40 :
Goto 243 Ll
Accept ParameterToken  

DFA State 243
Action Characters
Goto 39 0123456789ABCEFGHIJKLMNOPQRSTUVWXYZabcefghijklmnop qrstuvwxyz
Goto 40 :
Goto 244 Dd
Accept ParameterToken  

DFA State 244
Action Characters
Goto 39 0123456789ABDEFGHIJKLMNOPQRSTUVWXYZabdefghijklmnop qrstuvwxyz
Goto 40 :
Goto 245 Cc
Accept ParameterToken  

DFA State 245
Action Characters
Goto 39 0123456789BCDEFGHIJKLMNOPQRSTUVWXYZbcdefghijklmnop qrstuvwxyz
Goto 40 :
Goto 246 Aa
Accept ParameterToken  

DFA State 246
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQSTUVWXYZabcdefghijklmno pqstuvwxyz
Goto 40 :
Goto 247 Rr
Accept ParameterToken  

DFA State 247
Action Characters
Goto 39 0123456789ABCEFGHIJKLMNOPQRSTUVWXYZabcefghijklmnop qrstuvwxyz
Goto 40 :
Goto 248 Dd
Accept ParameterToken  

DFA State 248
Action Characters
Goto 39 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Goto 40 :
Accept -wildcard  

DFA State 249
Action Characters
Goto 250 *
Goto 251 .
Accept ReferenceOperatorToken  

DFA State 250
Action Characters
Accept ExpandableStringToken  

DFA State 251
Action Characters
Accept RangeOperatorToken  

DFA State 252
Action Characters
Goto 7 !%&-/0123456789;<>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ\^_` abcdefghijklmnopqrstuvwxyz{}~
Goto 253 =
Goto 254 *
Accept MultiplyOperatorToken  

DFA State 253
Action Characters
Accept AssignmentOperatorToken  

DFA State 254
Action Characters
Goto 7 !%&*-/0123456789;<>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ\^_ `abcdefghijklmnopqrstuvwxyz{}~
Accept (Comment Start)  

DFA State 255
Action Characters
Goto 256 Xx
Goto 258 .
Goto 260 0123456789
Accept NumberToken  

DFA State 256
Action Characters
Goto 257 0123456789ABCDEFabcdef

DFA State 257
Action Characters
Goto 257 0123456789ABCDEFabcdef
Accept NumberToken  

DFA State 258
Action Characters
Goto 259 0123456789

DFA State 259
Action Characters
Goto 259 0123456789
Accept NumberToken  

DFA State 260
Action Characters
Goto 258 .
Goto 260 0123456789
Accept NumberToken  

DFA State 261
Action Characters
Goto 258 .
Goto 262 >
Goto 260 0123456789
Accept NumberToken  

DFA State 262
Action Characters
Goto 263 >

DFA State 263
Action Characters
Accept RedirectionOperatorToken  

DFA State 264
Action Characters
Goto 258 .
Goto 260 0123456789
Goto 265 >
Accept NumberToken  

DFA State 265
Action Characters
Goto 266 &
Goto 268 >
Accept RedirectionOperatorToken  

DFA State 266
Action Characters
Goto 267 1

DFA State 267
Action Characters
Accept RedirectionOperatorToken  

DFA State 268
Action Characters
Accept RedirectionOperatorToken  

DFA State 269
Action Characters
Goto 7 !%&*-/0123456789;>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ\^_` abcdefghijklmnopqrstuvwxyz{}~
Goto 270 <
Accept RedirectionOperatorToken  

DFA State 270
Action Characters
Goto 7 !%&*-/0123456789;<>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ\^_ `abcdefghijklmnopqrstuvwxyz{}~
Accept RedirectionOperatorToken  

DFA State 271
Action Characters
Goto 7 !%&*-/0123456789;
Goto 272 |
Goto 273 >
Accept RedirectionOperatorToken  

DFA State 272
Action Characters
Accept RedirectionOperatorToken  

DFA State 273
Action Characters
Goto 7 !%&*-/0123456789;<>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ\^_ `abcdefghijklmnopqrstuvwxyz{}~
Accept RedirectionOperatorToken  

DFA State 274
Action Characters
Goto 275 (
Goto 7 !%&*-/0123456789;<>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ\^_ `abcdefghijklmnopqrstuvwxyz{}~

DFA State 275
Action Characters
Accept '@('  

DFA State 276
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCEFGHIJKLMNOPQRSUVWXYZabcefghijklmnopq rsuvwxyz
Goto 279 Dd
Goto 299 Tt

DFA State 277
Action Characters
Accept LoopLabelToken  

DFA State 278
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Accept AnyWordToken  

DFA State 279
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCEFGHIJKLMNOPQRSTUVWXYZabcefghijklmnop qrstuvwxyz
Goto 280 Dd
Accept AnyWordToken  

DFA State 280
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHJKLMNOPQRSTUVWXYZabcdefghjklmnop qrstuvwxyz
Goto 281 Ii
Accept AnyWordToken  

DFA State 281
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQRSUVWXYZabcdefghijklmno pqrsuvwxyz
Goto 282 Tt
Accept AnyWordToken  

DFA State 282
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHJKLMNOPQRSTUVWXYZabcdefghjklmnop qrstuvwxyz
Goto 283 Ii
Accept AnyWordToken  

DFA State 283
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNPQRSTUVWXYZabcdefghijklmnp qrstuvwxyz
Goto 284 Oo
Accept AnyWordToken  

DFA State 284
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMOPQRSTUVWXYZabcdefghijklmop qrstuvwxyz
Goto 285 Nn
Accept AnyWordToken  

DFA State 285
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNPQRSTUVWXYZabcdefghijklmnp qrstuvwxyz
Goto 286 Oo
Accept AnyWordToken  

DFA State 286
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOQRSTUVWXYZabcdefghijklmno qrstuvwxyz
Goto 287 Pp
Accept AnyWordToken  

DFA State 287
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDFGHIJKLMNOPQRSTUVWXYZabcdfghijklmnop qrstuvwxyz
Goto 288 Ee
Accept AnyWordToken  

DFA State 288
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQSTUVWXYZabcdefghijklmno pqstuvwxyz
Goto 289 Rr
Accept AnyWordToken  

DFA State 289
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789BCDEFGHIJKLMNOPQRSTUVWXYZbcdefghijklmnop qrstuvwxyz
Goto 290 Aa
Accept AnyWordToken  

DFA State 290
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQRSUVWXYZabcdefghijklmno pqrsuvwxyz
Goto 291 Tt
Accept AnyWordToken  

DFA State 291
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNPQRSTUVWXYZabcdefghijklmnp qrstuvwxyz
Goto 292 Oo
Accept AnyWordToken  

DFA State 292
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQSTUVWXYZabcdefghijklmno pqstuvwxyz
Goto 293 Rr
Accept AnyWordToken  

DFA State 293
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQRSUVWXYZabcdefghijklmno pqrsuvwxyz
Goto 294 Tt
Accept AnyWordToken  

DFA State 294
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNPQRSTUVWXYZabcdefghijklmnp qrstuvwxyz
Goto 295 Oo
Accept AnyWordToken  

DFA State 295
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJLMNOPQRSTUVWXYZabcdefghijlmnop qrstuvwxyz
Goto 296 Kk
Accept AnyWordToken  

DFA State 296
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDFGHIJKLMNOPQRSTUVWXYZabcdfghijklmnop qrstuvwxyz
Goto 297 Ee
Accept AnyWordToken  

DFA State 297
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMOPQRSTUVWXYZabcdefghijklmop qrstuvwxyz
Goto 298 Nn
Accept AnyWordToken  

DFA State 298
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Accept UnaryOperatorToken  

DFA State 299
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQRSUVWXYZabcdefghijklmno pqrsuvwxyz
Goto 300 Tt
Accept AnyWordToken  

DFA State 300
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQSTUVWXYZabcdefghijklmno pqstuvwxyz
Goto 301 Rr
Accept AnyWordToken  

DFA State 301
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHJKLMNOPQRSTUVWXYZabcdefghjklmnop qrstuvwxyz
Goto 302 Ii
Accept AnyWordToken  

DFA State 302
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ACDEFGHIJKLMNOPQRSTUVWXYZacdefghijklmnop qrstuvwxyz
Goto 303 Bb
Accept AnyWordToken  

DFA State 303
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQRSTVWXYZabcdefghijklmno pqrstvwxyz
Goto 304 Uu
Accept AnyWordToken  

DFA State 304
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQRSUVWXYZabcdefghijklmno pqrsuvwxyz
Goto 305 Tt
Accept AnyWordToken  

DFA State 305
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDFGHIJKLMNOPQRSTUVWXYZabcdfghijklmnop qrstuvwxyz
Goto 306 Ee
Accept AnyWordToken  

DFA State 306
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQRTUVWXYZabcdefghijklmno pqrtuvwxyz
Goto 307 Ss
Accept AnyWordToken  

DFA State 307
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOQRSTUVWXYZabcdefghijklmno qrstuvwxyz
Goto 308 Pp
Accept AnyWordToken  

DFA State 308
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDFGHIJKLMNOPQRSTUVWXYZabcdfghijklmnop qrstuvwxyz
Goto 309 Ee
Accept AnyWordToken  

DFA State 309
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABDEFGHIJKLMNOPQRSTUVWXYZabdefghijklmnop qrstuvwxyz
Goto 310 Cc
Accept AnyWordToken  

DFA State 310
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHJKLMNOPQRSTUVWXYZabcdefghjklmnop qrstuvwxyz
Goto 311 Ii
Accept AnyWordToken  

DFA State 311
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEGHIJKLMNOPQRSTUVWXYZabcdeghijklmnop qrstuvwxyz
Goto 312 Ff
Accept AnyWordToken  

DFA State 312
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHJKLMNOPQRSTUVWXYZabcdefghjklmnop qrstuvwxyz
Goto 313 Ii
Accept AnyWordToken  

DFA State 313
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABDEFGHIJKLMNOPQRSTUVWXYZabdefghijklmnop qrstuvwxyz
Goto 314 Cc
Accept AnyWordToken  

DFA State 314
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789BCDEFGHIJKLMNOPQRSTUVWXYZbcdefghijklmnop qrstuvwxyz
Goto 315 Aa
Accept AnyWordToken  

DFA State 315
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQRSUVWXYZabcdefghijklmno pqrsuvwxyz
Goto 316 Tt
Accept AnyWordToken  

DFA State 316
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHJKLMNOPQRSTUVWXYZabcdefghjklmnop qrstuvwxyz
Goto 317 Ii
Accept AnyWordToken  

DFA State 317
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNPQRSTUVWXYZabcdefghijklmnp qrstuvwxyz
Goto 318 Oo
Accept AnyWordToken  

DFA State 318
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMOPQRSTUVWXYZabcdefghijklmop qrstuvwxyz
Goto 319 Nn
Accept AnyWordToken  

DFA State 319
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQRSUVWXYZabcdefghijklmno pqrsuvwxyz
Goto 320 Tt
Accept AnyWordToken  

DFA State 320
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNPQRSTUVWXYZabcdefghijklmnp qrstuvwxyz
Goto 321 Oo
Accept AnyWordToken  

DFA State 321
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJLMNOPQRSTUVWXYZabcdefghijlmnop qrstuvwxyz
Goto 322 Kk
Accept AnyWordToken  

DFA State 322
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDFGHIJKLMNOPQRSTUVWXYZabcdfghijklmnop qrstuvwxyz
Goto 323 Ee
Accept AnyWordToken  

DFA State 323
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMOPQRSTUVWXYZabcdefghijklmop qrstuvwxyz
Goto 324 Nn
Accept AnyWordToken  

DFA State 324
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Accept UnaryOperatorToken  

DFA State 325
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQSTUVWXYZabcdefghijklmno pqstuvwxyz
Goto 326 Rr

DFA State 326
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDFGHIJKLMNOPQRSTUVWXYZabcdfghijklmnop qrstuvwxyz
Goto 327 Ee
Accept AnyWordToken  

DFA State 327
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789BCDEFGHIJKLMNOPQRSTUVWXYZbcdefghijklmnop qrstuvwxyz
Goto 328 Aa
Accept AnyWordToken  

DFA State 328
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJLMNOPQRSTUVWXYZabcdefghijlmnop qrstuvwxyz
Goto 329 Kk
Accept AnyWordToken  

DFA State 329
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Accept break  

DFA State 330
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNPQRSTUVWXYZabcdefghijklmnp qrstuvwxyz
Goto 331 Oo

DFA State 331
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMOPQRSTUVWXYZabcdefghijklmop qrstuvwxyz
Goto 332 Nn
Accept AnyWordToken  

DFA State 332
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQRSUVWXYZabcdefghijklmno pqrsuvwxyz
Goto 333 Tt
Accept AnyWordToken  

DFA State 333
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHJKLMNOPQRSTUVWXYZabcdefghjklmnop qrstuvwxyz
Goto 334 Ii
Accept AnyWordToken  

DFA State 334
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMOPQRSTUVWXYZabcdefghijklmop qrstuvwxyz
Goto 335 Nn
Accept AnyWordToken  

DFA State 335
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQRSTVWXYZabcdefghijklmno pqrstvwxyz
Goto 336 Uu
Accept AnyWordToken  

DFA State 336
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDFGHIJKLMNOPQRSTUVWXYZabcdfghijklmnop qrstuvwxyz
Goto 337 Ee
Accept AnyWordToken  

DFA State 337
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Accept continue  

DFA State 338
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDFGHIJKLMNPQRSTUVWXYZabcdfghijklmnpqr stuvwxyz
Goto 339 Ee
Goto 345 Oo

DFA State 339
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEGHIJKLMNOPQRSTUVWXYZabcdeghijklmnop qrstuvwxyz
Goto 340 Ff
Accept AnyWordToken  

DFA State 340
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789BCDEFGHIJKLMNOPQRSTUVWXYZbcdefghijklmnop qrstuvwxyz
Goto 341 Aa
Accept AnyWordToken  

DFA State 341
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQRSTVWXYZabcdefghijklmno pqrstvwxyz
Goto 342 Uu
Accept AnyWordToken  

DFA State 342
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKMNOPQRSTUVWXYZabcdefghijkmnop qrstuvwxyz
Goto 343 Ll
Accept AnyWordToken  

DFA State 343
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQRSUVWXYZabcdefghijklmno pqrsuvwxyz
Goto 344 Tt
Accept AnyWordToken  

DFA State 344
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Accept default  

DFA State 345
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Accept do  

DFA State 346
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKMNOPQRSTUVWXYZabcdefghijkmnop qrstuvwxyz
Goto 347 Ll

DFA State 347
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQRTUVWXYZabcdefghijklmno pqrtuvwxyz
Goto 348 Ss
Accept AnyWordToken  

DFA State 348
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDFGHIJKLMNOPQRSTUVWXYZabcdfghijklmnop qrstuvwxyz
Goto 349 Ee
Accept AnyWordToken  

DFA State 349
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHJKLMNOPQRSTUVWXYZabcdefghjklmnop qrstuvwxyz
Goto 350 Ii
Accept else  

DFA State 350
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEGHIJKLMNOPQRSTUVWXYZabcdeghijklmnop qrstuvwxyz
Goto 351 Ff
Accept AnyWordToken  

DFA State 351
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Accept elseif  

DFA State 352
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHJKLMNPQRSTVWXYZabcdefghjklmnpqrs tvwxyz
Goto 353 Ii
Goto 363 Oo
Goto 369 Uu

DFA State 353
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKMOPQRSTUVWXYZabcdefghijkmopqr stuvwxyz
Goto 354 Ll
Goto 358 Nn
Accept AnyWordToken  

DFA State 354
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQRSUVWXYZabcdefghijklmno pqrsuvwxyz
Goto 355 Tt
Accept AnyWordToken  

DFA State 355
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDFGHIJKLMNOPQRSTUVWXYZabcdfghijklmnop qrstuvwxyz
Goto 356 Ee
Accept AnyWordToken  

DFA State 356
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQSTUVWXYZabcdefghijklmno pqstuvwxyz
Goto 357 Rr
Accept AnyWordToken  

DFA State 357
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Accept FunctionDeclarationToken  

DFA State 358
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789BCDEFGHIJKLMNOPQRSTUVWXYZbcdefghijklmnop qrstuvwxyz
Goto 359 Aa
Accept AnyWordToken  

DFA State 359
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKMNOPQRSTUVWXYZabcdefghijkmnop qrstuvwxyz
Goto 360 Ll
Accept AnyWordToken  

DFA State 360
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKMNOPQRSTUVWXYZabcdefghijkmnop qrstuvwxyz
Goto 361 Ll
Accept AnyWordToken  

DFA State 361
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQRSTUVWXZabcdefghijklmno pqrstuvwxz
Goto 362 Yy
Accept AnyWordToken  

DFA State 362
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Accept finally  

DFA State 363
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQSTUVWXYZabcdefghijklmno pqstuvwxyz
Goto 364 Rr
Accept AnyWordToken  

DFA State 364
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDFGHIJKLMNOPQRSTUVWXYZabcdfghijklmnop qrstuvwxyz
Goto 365 Ee
Accept AnyWordToken  

DFA State 365
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789BCDEFGHIJKLMNOPQRSTUVWXYZbcdefghijklmnop qrstuvwxyz
Goto 366 Aa
Accept AnyWordToken  

DFA State 366
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABDEFGHIJKLMNOPQRSTUVWXYZabdefghijklmnop qrstuvwxyz
Goto 367 Cc
Accept AnyWordToken  

DFA State 367
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGIJKLMNOPQRSTUVWXYZabcdefgijklmnop qrstuvwxyz
Goto 368 Hh
Accept AnyWordToken  

DFA State 368
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Accept foreach  

DFA State 369
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMOPQRSTUVWXYZabcdefghijklmop qrstuvwxyz
Goto 370 Nn
Accept AnyWordToken  

DFA State 370
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABDEFGHIJKLMNOPQRSTUVWXYZabdefghijklmnop qrstuvwxyz
Goto 371 Cc
Accept AnyWordToken  

DFA State 371
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQRSUVWXYZabcdefghijklmno pqrsuvwxyz
Goto 372 Tt
Accept AnyWordToken  

DFA State 372
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHJKLMNOPQRSTUVWXYZabcdefghjklmnop qrstuvwxyz
Goto 373 Ii
Accept AnyWordToken  

DFA State 373
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNPQRSTUVWXYZabcdefghijklmnp qrstuvwxyz
Goto 374 Oo
Accept AnyWordToken  

DFA State 374
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMOPQRSTUVWXYZabcdefghijklmop qrstuvwxyz
Goto 375 Nn
Accept AnyWordToken  

DFA State 375
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Accept FunctionDeclarationToken  

DFA State 376
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz

DFA State 377
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEGHIJKLMOPQRSTUVWXYZabcdeghijklmopqr stuvwxyz
Goto 378 Ff
Goto 379 Nn

DFA State 378
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Accept if  

DFA State 379
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Accept in  

DFA State 380
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDFGHIJKLMNOPQRSTUVWXYZabcdfghijklmnop qrstuvwxyz
Goto 381 Ee

DFA State 381
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQRSUVWXYZabcdefghijklmno pqrsuvwxyz
Goto 382 Tt
Accept AnyWordToken  

DFA State 382
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQRSTVWXYZabcdefghijklmno pqrstvwxyz
Goto 383 Uu
Accept AnyWordToken  

DFA State 383
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQSTUVWXYZabcdefghijklmno pqstuvwxyz
Goto 384 Rr
Accept AnyWordToken  

DFA State 384
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMOPQRSTUVWXYZabcdefghijklmop qrstuvwxyz
Goto 385 Nn
Accept AnyWordToken  

DFA State 385
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Accept return  

DFA State 386
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmno pqrstuvxyz
Goto 387 Ww

DFA State 387
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHJKLMNOPQRSTUVWXYZabcdefghjklmnop qrstuvwxyz
Goto 388 Ii
Accept AnyWordToken  

DFA State 388
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQRSUVWXYZabcdefghijklmno pqrsuvwxyz
Goto 389 Tt
Accept AnyWordToken  

DFA State 389
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABDEFGHIJKLMNOPQRSTUVWXYZabdefghijklmnop qrstuvwxyz
Goto 390 Cc
Accept AnyWordToken  

DFA State 390
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGIJKLMNOPQRSTUVWXYZabcdefgijklmnop qrstuvwxyz
Goto 391 Hh
Accept AnyWordToken  

DFA State 391
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Accept switch  

DFA State 392
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQSTUVWXYZabcdefghijklmno pqstuvwxyz
Goto 393 Rr

DFA State 393
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789BCDEFGHIJKLMNOPQRSTUVWXYZbcdefghijklmnop qrstuvwxyz
Goto 394 Aa
Accept AnyWordToken  

DFA State 394
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOQRSTUVWXYZabcdefghijklmno qrstuvwxyz
Goto 395 Pp
Accept AnyWordToken  

DFA State 395
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Accept trap  

DFA State 396
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMOPQRSTUVWXYZabcdefghijklmop qrstuvwxyz
Goto 397 Nn

DFA State 397
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQRSUVWXYZabcdefghijklmno pqrsuvwxyz
Goto 398 Tt
Accept AnyWordToken  

DFA State 398
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHJKLMNOPQRSTUVWXYZabcdefghjklmnop qrstuvwxyz
Goto 399 Ii
Accept AnyWordToken  

DFA State 399
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKMNOPQRSTUVWXYZabcdefghijkmnop qrstuvwxyz
Goto 400 Ll
Accept AnyWordToken  

DFA State 400
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Accept until  

DFA State 401
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGIJKLMNOPQRSTUVWXYZabcdefgijklmnop qrstuvwxyz
Goto 402 Hh

DFA State 402
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHJKLMNOPQRSTUVWXYZabcdefghjklmnop qrstuvwxyz
Goto 403 Ii
Accept AnyWordToken  

DFA State 403
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKMNOPQRSTUVWXYZabcdefghijkmnop qrstuvwxyz
Goto 404 Ll
Accept AnyWordToken  

DFA State 404
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDFGHIJKLMNOPQRSTUVWXYZabcdfghijklmnop qrstuvwxyz
Goto 405 Ee
Accept AnyWordToken  

DFA State 405
Action Characters
Goto 7 !%&*-/;<>?@\^_`{}~
Goto 277 :
Goto 278 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmn opqrstuvwxyz
Accept while  

DFA State 406
Action Characters
Goto 407 {Space}!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJK LMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ {NBSP}
Accept '['  

DFA State 407
Action Characters
Goto 407 {Space}!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJK LMNOPQRSTUVWXYZ[\^_`abcdefghijklmnopqrstuvwxyz{|}~ {NBSP}
Goto 408 ]

DFA State 408
Action Characters
Goto 407 {Space}!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJK LMNOPQRSTUVWXYZ[\^_`abcdefghijklmnopqrstuvwxyz{|}~ {NBSP}
Goto 408 ]
Accept AttributeSpecificationToken  

DFA State 409
Action Characters
Goto 7 !%&*-/0123456789;<>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ\^_ `abcdefghijklmnopqrstuvwxyz{}~
Accept '{'  

DFA State 410
Action Characters
Goto 7 !%&*-/0123456789;<>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ\^_ `abcdefghijklmnopqrstuvwxyz{}~
Accept '}'  



LALR States


LALR State 0
Configuration Lookahead
<S'> ::= · <statementListRule> (EOF)  
<statementListRule> ::= · <statementRule> EOF
<statementListRule> ::= · <statementRule> <statementSeparatorToken> <statementListRule> EOF
<statementRule> ::= · <pipelineRule> EOF $( ( @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<statementRule> ::= · CommentToken EOF $( ( @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<statementRule> ::= · <ifStatementRule> EOF $( ( @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<statementRule> ::= · <foreachStatementRule> EOF $( ( @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<statementRule> ::= · <doWhileStatementRule> EOF $( ( @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<statementRule> ::= · <flowControlStatementRule> EOF $( ( @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<statementRule> ::= · <trapStatementRule> EOF $( ( @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<statementRule> ::= · <finallyStatementRule> EOF $( ( @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<pipelineRule> ::= · <cmdletCall> EOF $( ( @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<pipelineRule> ::= · <cmdletCall> '|' <pipelineRule> EOF $( ( @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<pipelineRule> ::= · <assignmentStatementRule> EOF $( ( @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<pipelineRule> ::= · <assignmentStatementRule> '|' <pipelineRule> EOF $( ( @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<assignmentStatementRule> ::= · <lvalueExpression> AssignmentOperatorToken <pipelineRule> EOF $( ( @( | AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<lvalueExpression> ::= · <lvalue> AssignmentOperatorToken PrePostfixOperatorToken
<lvalue> ::= · VariableToken AssignmentOperatorToken PrePostfixOperatorToken
<lvalue> ::= · AttributeSpecificationToken VariableToken AssignmentOperatorToken PrePostfixOperatorToken
<lvalue> ::= · VariableToken <propertyOrArrayReferenceOperatorList> AssignmentOperatorToken PrePostfixOperatorToken
<lvalue> ::= · AttributeSpecificationToken VariableToken <propertyOrArrayReferenceOperatorList> AssignmentOperatorToken PrePostfixOperatorToken
<cmdletName> ::= · AnyWordToken EOF $( ( @( | AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
<cmdletCall> ::= · ExecCall <cmdletName> <cmletParamsList> EOF $( ( @( | AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<cmdletCall> ::= · ExecCall <cmdletName> EOF $( ( @( | AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<cmdletCall> ::= · <cmdletName> <cmletParamsList> EOF $( ( @( | AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<cmdletCall> ::= · <cmdletName> EOF $( ( @( | AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<cmdletCall> ::= · <expressionRule> EOF $( ( @( | AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<ifStatementRule> ::= · if '(' <pipelineRule> ')' <statementBlockRule> EOF $( ( @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<ifStatementRule> ::= · if '(' <pipelineRule> ')' <statementBlockRule> <elseIfBlockRule> EOF $( ( @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<ifStatementRule> ::= · if '(' <pipelineRule> ')' <statementBlockRule> else <statementBlockRule> EOF $( ( @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<ifStatementRule> ::= · if '(' <pipelineRule> ')' <statementBlockRule> <elseIfBlockRule> else <statementBlockRule> EOF $( ( @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<foreachStatementRule> ::= · foreach '(' VariableToken in <pipelineRule> ')' <statementBlockRule> EOF $( ( @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<foreachStatementRule> ::= · LoopLabelToken foreach '(' VariableToken in <pipelineRule> ')' <statementBlockRule> EOF $( ( @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<doWhileStatementRule> ::= · do <statementBlockRule> while '(' <pipelineRule> ')' EOF $( ( @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<doWhileStatementRule> ::= · do <statementBlockRule> until '(' <pipelineRule> ')' EOF $( ( @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<doWhileStatementRule> ::= · LoopLabelToken do <statementBlockRule> while '(' <pipelineRule> ')' EOF $( ( @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<doWhileStatementRule> ::= · LoopLabelToken do <statementBlockRule> until '(' <pipelineRule> ')' EOF $( ( @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<trapStatementRule> ::= · trap <statementBlockRule> EOF $( ( @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<trapStatementRule> ::= · trap AttributeSpecificationToken <statementBlockRule> EOF $( ( @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<finallyStatementRule> ::= · finally <statementBlockRule> EOF $( ( @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<flowControlStatementRule> ::= · break EOF $( ( @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<flowControlStatementRule> ::= · continue EOF $( ( @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<flowControlStatementRule> ::= · break <flowControlPropertyBody> EOF $( ( @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<flowControlStatementRule> ::= · continue <flowControlPropertyBody> EOF $( ( @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<flowControlStatementRule> ::= · return <pipelineRule> EOF $( ( @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<expressionRule> ::= · <logicalExpressionRule> EOF $( ( @( | AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<logicalExpressionRule> ::= · <bitwiseExpressionRule> EOF $( ( @( | AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<logicalExpressionRule> ::= · <bitwiseExpressionRule> LogicalOperatorToken <logicalExpressionRule> EOF $( ( @( | AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<bitwiseExpressionRule> ::= · <comparisonExpressionRule> EOF $( ( @( | AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<bitwiseExpressionRule> ::= · <comparisonExpressionRule> BitwiseOperatorToken <bitwiseExpressionRule> EOF $( ( @( | AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<comparisonExpressionRule> ::= · <addExpressionRule> EOF $( ( @( | AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<comparisonExpressionRule> ::= · <addExpressionRule> ComparisonOperatorToken <comparisonExpressionRule> EOF $( ( @( | AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<addExpressionRule> ::= · <multiplyExpressionRule> EOF $( ( @( | AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<addExpressionRule> ::= · <multiplyExpressionRule> AdditionOperatorToken <addExpressionRule> EOF $( ( @( | AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<multiplyExpressionRule> ::= · <formatExpressionRule> EOF $( ( @( | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<multiplyExpressionRule> ::= · <formatExpressionRule> MultiplyOperatorToken <multiplyExpressionRule> EOF $( ( @( | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<formatExpressionRule> ::= · <rangeExpressionRule> EOF $( ( @( | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<formatExpressionRule> ::= · <rangeExpressionRule> FormatOperatorToken <formatExpressionRule> EOF $( ( @( | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<rangeExpressionRule> ::= · <arrayLiteralRule> EOF $( ( @( | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<rangeExpressionRule> ::= · <arrayLiteralRule> RangeOperatorToken <rangeExpressionRule> EOF $( ( @( | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<arrayLiteralRule> ::= · <postfixOperatorRule> EOF $( ( @( | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<arrayLiteralRule> ::= · <postfixOperatorRule> CommaToken <arrayLiteralRule> EOF $( ( @( | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<postfixOperatorRule> ::= · <lvalueExpression> PrePostfixOperatorToken EOF $( ( @( | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<postfixOperatorRule> ::= · <propertyOrArrayReferenceRule> EOF $( ( @( | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<propertyOrArrayReferenceRule> ::= · <valueRule> EOF $( ( @( | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<propertyOrArrayReferenceRule> ::= · <valueRule> <propertyOrArrayReferenceOperatorList> EOF $( ( @( | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '(' <assignmentStatementRule> ')' EOF $( ( @( [ | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '$(' <statementListRule> ')' EOF $( ( @( [ | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '@(' <statementListRule> ')' EOF $( ( @( [ | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · UnaryOperatorToken <propertyOrArrayReferenceRule> EOF $( ( @( [ | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · AttributeSpecificationToken <propertyOrArrayReferenceRule> EOF $( ( @( [ | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · AttributeSpecificationToken EOF $( ( @( [ | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · NumberToken EOF $( ( @( [ | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · StringToken EOF $( ( @( [ | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · ExpandableStringToken EOF $( ( @( [ | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · VariableToken EOF $( ( @( [ | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
Actions
'$(' Shift 1
'(' Shift 2
'@(' Shift 3
AnyWordToken Shift 4
AttributeSpecificationToken Shift 5
break Shift 6
CommentToken Shift 7
continue Shift 8
do Shift 9
ExecCall Shift 10
ExpandableStringToken Shift 11
finally Shift 12
foreach Shift 13
if Shift 14
LoopLabelToken Shift 15
NumberToken Shift 16
return Shift 17
StringToken Shift 18
trap Shift 19
UnaryOperatorToken Shift 20
VariableToken Shift 21
<addExpressionRule> Goto 22
<arrayLiteralRule> Goto 23
<assignmentStatementRule> Goto 24
<bitwiseExpressionRule> Goto 25
<cmdletCall> Goto 26
<cmdletName> Goto 27
<comparisonExpressionRule> Goto 28
<doWhileStatementRule> Goto 29
<expressionRule> Goto 30
<finallyStatementRule> Goto 31
<flowControlStatementRule> Goto 32
<foreachStatementRule> Goto 33
<formatExpressionRule> Goto 34
<ifStatementRule> Goto 35
<logicalExpressionRule> Goto 36
<lvalue> Goto 37
<lvalueExpression> Goto 38
<multiplyExpressionRule> Goto 39
<pipelineRule> Goto 40
<postfixOperatorRule> Goto 41
<propertyOrArrayReferenceRule> Goto 42
<rangeExpressionRule> Goto 43
<statementListRule> Goto 44
<statementRule> Goto 45
<trapStatementRule> Goto 46
<valueRule> Goto 47

LALR State 1
Configuration Lookahead
<valueRule> ::= '$(' · <statementListRule> ')' EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<statementListRule> ::= · <statementRule> )
<statementListRule> ::= · <statementRule> <statementSeparatorToken> <statementListRule> )
<statementRule> ::= · <pipelineRule> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<statementRule> ::= · CommentToken $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<statementRule> ::= · <ifStatementRule> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<statementRule> ::= · <foreachStatementRule> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<statementRule> ::= · <doWhileStatementRule> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<statementRule> ::= · <flowControlStatementRule> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<statementRule> ::= · <trapStatementRule> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<statementRule> ::= · <finallyStatementRule> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<pipelineRule> ::= · <cmdletCall> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<pipelineRule> ::= · <cmdletCall> '|' <pipelineRule> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<pipelineRule> ::= · <assignmentStatementRule> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<pipelineRule> ::= · <assignmentStatementRule> '|' <pipelineRule> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<assignmentStatementRule> ::= · <lvalueExpression> AssignmentOperatorToken <pipelineRule> $( ( ) @( | AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<lvalueExpression> ::= · <lvalue> AssignmentOperatorToken PrePostfixOperatorToken
<lvalue> ::= · VariableToken AssignmentOperatorToken PrePostfixOperatorToken
<lvalue> ::= · AttributeSpecificationToken VariableToken AssignmentOperatorToken PrePostfixOperatorToken
<lvalue> ::= · VariableToken <propertyOrArrayReferenceOperatorList> AssignmentOperatorToken PrePostfixOperatorToken
<lvalue> ::= · AttributeSpecificationToken VariableToken <propertyOrArrayReferenceOperatorList> AssignmentOperatorToken PrePostfixOperatorToken
<cmdletName> ::= · AnyWordToken $( ( ) @( | AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
<cmdletCall> ::= · ExecCall <cmdletName> <cmletParamsList> $( ( ) @( | AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<cmdletCall> ::= · ExecCall <cmdletName> $( ( ) @( | AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<cmdletCall> ::= · <cmdletName> <cmletParamsList> $( ( ) @( | AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<cmdletCall> ::= · <cmdletName> $( ( ) @( | AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<cmdletCall> ::= · <expressionRule> $( ( ) @( | AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<ifStatementRule> ::= · if '(' <pipelineRule> ')' <statementBlockRule> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<ifStatementRule> ::= · if '(' <pipelineRule> ')' <statementBlockRule> <elseIfBlockRule> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<ifStatementRule> ::= · if '(' <pipelineRule> ')' <statementBlockRule> else <statementBlockRule> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<ifStatementRule> ::= · if '(' <pipelineRule> ')' <statementBlockRule> <elseIfBlockRule> else <statementBlockRule> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<foreachStatementRule> ::= · foreach '(' VariableToken in <pipelineRule> ')' <statementBlockRule> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<foreachStatementRule> ::= · LoopLabelToken foreach '(' VariableToken in <pipelineRule> ')' <statementBlockRule> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<doWhileStatementRule> ::= · do <statementBlockRule> while '(' <pipelineRule> ')' $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<doWhileStatementRule> ::= · do <statementBlockRule> until '(' <pipelineRule> ')' $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<doWhileStatementRule> ::= · LoopLabelToken do <statementBlockRule> while '(' <pipelineRule> ')' $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<doWhileStatementRule> ::= · LoopLabelToken do <statementBlockRule> until '(' <pipelineRule> ')' $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<trapStatementRule> ::= · trap <statementBlockRule> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<trapStatementRule> ::= · trap AttributeSpecificationToken <statementBlockRule> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<finallyStatementRule> ::= · finally <statementBlockRule> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<flowControlStatementRule> ::= · break $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<flowControlStatementRule> ::= · continue $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<flowControlStatementRule> ::= · break <flowControlPropertyBody> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<flowControlStatementRule> ::= · continue <flowControlPropertyBody> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<flowControlStatementRule> ::= · return <pipelineRule> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<expressionRule> ::= · <logicalExpressionRule> $( ( ) @( | AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<logicalExpressionRule> ::= · <bitwiseExpressionRule> $( ( ) @( | AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<logicalExpressionRule> ::= · <bitwiseExpressionRule> LogicalOperatorToken <logicalExpressionRule> $( ( ) @( | AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<bitwiseExpressionRule> ::= · <comparisonExpressionRule> $( ( ) @( | AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<bitwiseExpressionRule> ::= · <comparisonExpressionRule> BitwiseOperatorToken <bitwiseExpressionRule> $( ( ) @( | AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<comparisonExpressionRule> ::= · <addExpressionRule> $( ( ) @( | AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<comparisonExpressionRule> ::= · <addExpressionRule> ComparisonOperatorToken <comparisonExpressionRule> $( ( ) @( | AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<addExpressionRule> ::= · <multiplyExpressionRule> $( ( ) @( | AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<addExpressionRule> ::= · <multiplyExpressionRule> AdditionOperatorToken <addExpressionRule> $( ( ) @( | AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<multiplyExpressionRule> ::= · <formatExpressionRule> $( ( ) @( | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<multiplyExpressionRule> ::= · <formatExpressionRule> MultiplyOperatorToken <multiplyExpressionRule> $( ( ) @( | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<formatExpressionRule> ::= · <rangeExpressionRule> $( ( ) @( | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<formatExpressionRule> ::= · <rangeExpressionRule> FormatOperatorToken <formatExpressionRule> $( ( ) @( | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<rangeExpressionRule> ::= · <arrayLiteralRule> $( ( ) @( | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<rangeExpressionRule> ::= · <arrayLiteralRule> RangeOperatorToken <rangeExpressionRule> $( ( ) @( | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<arrayLiteralRule> ::= · <postfixOperatorRule> $( ( ) @( | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<arrayLiteralRule> ::= · <postfixOperatorRule> CommaToken <arrayLiteralRule> $( ( ) @( | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<postfixOperatorRule> ::= · <lvalueExpression> PrePostfixOperatorToken $( ( ) @( | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<postfixOperatorRule> ::= · <propertyOrArrayReferenceRule> $( ( ) @( | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<propertyOrArrayReferenceRule> ::= · <valueRule> $( ( ) @( | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<propertyOrArrayReferenceRule> ::= · <valueRule> <propertyOrArrayReferenceOperatorList> $( ( ) @( | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '(' <assignmentStatementRule> ')' $( ( ) @( [ | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '$(' <statementListRule> ')' $( ( ) @( [ | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '@(' <statementListRule> ')' $( ( ) @( [ | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · UnaryOperatorToken <propertyOrArrayReferenceRule> $( ( ) @( [ | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · AttributeSpecificationToken <propertyOrArrayReferenceRule> $( ( ) @( [ | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · AttributeSpecificationToken $( ( ) @( [ | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · NumberToken $( ( ) @( [ | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · StringToken $( ( ) @( [ | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · ExpandableStringToken $( ( ) @( [ | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · VariableToken $( ( ) @( [ | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
Actions
'$(' Shift 1
'(' Shift 2
'@(' Shift 3
AnyWordToken Shift 4
AttributeSpecificationToken Shift 5
break Shift 6
CommentToken Shift 7
continue Shift 8
do Shift 9
ExecCall Shift 10
ExpandableStringToken Shift 11
finally Shift 12
foreach Shift 13
if Shift 14
LoopLabelToken Shift 15
NumberToken Shift 16
return Shift 17
StringToken Shift 18
trap Shift 19
UnaryOperatorToken Shift 20
VariableToken Shift 21
<addExpressionRule> Goto 22
<arrayLiteralRule> Goto 23
<assignmentStatementRule> Goto 24
<bitwiseExpressionRule> Goto 25
<cmdletCall> Goto 26
<cmdletName> Goto 27
<comparisonExpressionRule> Goto 28
<doWhileStatementRule> Goto 29
<expressionRule> Goto 30
<finallyStatementRule> Goto 31
<flowControlStatementRule> Goto 32
<foreachStatementRule> Goto 33
<formatExpressionRule> Goto 34
<ifStatementRule> Goto 35
<logicalExpressionRule> Goto 36
<lvalue> Goto 37
<lvalueExpression> Goto 38
<multiplyExpressionRule> Goto 39
<pipelineRule> Goto 40
<postfixOperatorRule> Goto 41
<propertyOrArrayReferenceRule> Goto 42
<rangeExpressionRule> Goto 43
<statementListRule> Goto 48
<statementRule> Goto 45
<trapStatementRule> Goto 46
<valueRule> Goto 47

LALR State 2
Configuration Lookahead
<valueRule> ::= '(' · <assignmentStatementRule> ')' EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<assignmentStatementRule> ::= · <lvalueExpression> AssignmentOperatorToken <pipelineRule> )
<lvalueExpression> ::= · <lvalue> AssignmentOperatorToken
<lvalue> ::= · VariableToken AssignmentOperatorToken
<lvalue> ::= · AttributeSpecificationToken VariableToken AssignmentOperatorToken
<lvalue> ::= · VariableToken <propertyOrArrayReferenceOperatorList> AssignmentOperatorToken
<lvalue> ::= · AttributeSpecificationToken VariableToken <propertyOrArrayReferenceOperatorList> AssignmentOperatorToken
Actions
AttributeSpecificationToken Shift 49
VariableToken Shift 50
<assignmentStatementRule> Goto 51
<lvalue> Goto 37
<lvalueExpression> Goto 52

LALR State 3
Configuration Lookahead
<valueRule> ::= '@(' · <statementListRule> ')' EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<statementListRule> ::= · <statementRule> )
<statementListRule> ::= · <statementRule> <statementSeparatorToken> <statementListRule> )
<statementRule> ::= · <pipelineRule> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<statementRule> ::= · CommentToken $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<statementRule> ::= · <ifStatementRule> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<statementRule> ::= · <foreachStatementRule> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<statementRule> ::= · <doWhileStatementRule> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<statementRule> ::= · <flowControlStatementRule> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<statementRule> ::= · <trapStatementRule> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<statementRule> ::= · <finallyStatementRule> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<pipelineRule> ::= · <cmdletCall> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<pipelineRule> ::= · <cmdletCall> '|' <pipelineRule> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<pipelineRule> ::= · <assignmentStatementRule> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<pipelineRule> ::= · <assignmentStatementRule> '|' <pipelineRule> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<assignmentStatementRule> ::= · <lvalueExpression> AssignmentOperatorToken <pipelineRule> $( ( ) @( | AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<lvalueExpression> ::= · <lvalue> AssignmentOperatorToken PrePostfixOperatorToken
<lvalue> ::= · VariableToken AssignmentOperatorToken PrePostfixOperatorToken
<lvalue> ::= · AttributeSpecificationToken VariableToken AssignmentOperatorToken PrePostfixOperatorToken
<lvalue> ::= · VariableToken <propertyOrArrayReferenceOperatorList> AssignmentOperatorToken PrePostfixOperatorToken
<lvalue> ::= · AttributeSpecificationToken VariableToken <propertyOrArrayReferenceOperatorList> AssignmentOperatorToken PrePostfixOperatorToken
<cmdletName> ::= · AnyWordToken $( ( ) @( | AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
<cmdletCall> ::= · ExecCall <cmdletName> <cmletParamsList> $( ( ) @( | AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<cmdletCall> ::= · ExecCall <cmdletName> $( ( ) @( | AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<cmdletCall> ::= · <cmdletName> <cmletParamsList> $( ( ) @( | AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<cmdletCall> ::= · <cmdletName> $( ( ) @( | AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<cmdletCall> ::= · <expressionRule> $( ( ) @( | AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<ifStatementRule> ::= · if '(' <pipelineRule> ')' <statementBlockRule> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<ifStatementRule> ::= · if '(' <pipelineRule> ')' <statementBlockRule> <elseIfBlockRule> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<ifStatementRule> ::= · if '(' <pipelineRule> ')' <statementBlockRule> else <statementBlockRule> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<ifStatementRule> ::= · if '(' <pipelineRule> ')' <statementBlockRule> <elseIfBlockRule> else <statementBlockRule> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<foreachStatementRule> ::= · foreach '(' VariableToken in <pipelineRule> ')' <statementBlockRule> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<foreachStatementRule> ::= · LoopLabelToken foreach '(' VariableToken in <pipelineRule> ')' <statementBlockRule> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<doWhileStatementRule> ::= · do <statementBlockRule> while '(' <pipelineRule> ')' $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<doWhileStatementRule> ::= · do <statementBlockRule> until '(' <pipelineRule> ')' $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<doWhileStatementRule> ::= · LoopLabelToken do <statementBlockRule> while '(' <pipelineRule> ')' $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<doWhileStatementRule> ::= · LoopLabelToken do <statementBlockRule> until '(' <pipelineRule> ')' $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<trapStatementRule> ::= · trap <statementBlockRule> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<trapStatementRule> ::= · trap AttributeSpecificationToken <statementBlockRule> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<finallyStatementRule> ::= · finally <statementBlockRule> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<flowControlStatementRule> ::= · break $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<flowControlStatementRule> ::= · continue $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<flowControlStatementRule> ::= · break <flowControlPropertyBody> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<flowControlStatementRule> ::= · continue <flowControlPropertyBody> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<flowControlStatementRule> ::= · return <pipelineRule> $( ( ) @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<expressionRule> ::= · <logicalExpressionRule> $( ( ) @( | AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<logicalExpressionRule> ::= · <bitwiseExpressionRule> $( ( ) @( | AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<logicalExpressionRule> ::= · <bitwiseExpressionRule> LogicalOperatorToken <logicalExpressionRule> $( ( ) @( | AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<bitwiseExpressionRule> ::= · <comparisonExpressionRule> $( ( ) @( | AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<bitwiseExpressionRule> ::= · <comparisonExpressionRule> BitwiseOperatorToken <bitwiseExpressionRule> $( ( ) @( | AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<comparisonExpressionRule> ::= · <addExpressionRule> $( ( ) @( | AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<comparisonExpressionRule> ::= · <addExpressionRule> ComparisonOperatorToken <comparisonExpressionRule> $( ( ) @( | AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<addExpressionRule> ::= · <multiplyExpressionRule> $( ( ) @( | AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<addExpressionRule> ::= · <multiplyExpressionRule> AdditionOperatorToken <addExpressionRule> $( ( ) @( | AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<multiplyExpressionRule> ::= · <formatExpressionRule> $( ( ) @( | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<multiplyExpressionRule> ::= · <formatExpressionRule> MultiplyOperatorToken <multiplyExpressionRule> $( ( ) @( | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<formatExpressionRule> ::= · <rangeExpressionRule> $( ( ) @( | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<formatExpressionRule> ::= · <rangeExpressionRule> FormatOperatorToken <formatExpressionRule> $( ( ) @( | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<rangeExpressionRule> ::= · <arrayLiteralRule> $( ( ) @( | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<rangeExpressionRule> ::= · <arrayLiteralRule> RangeOperatorToken <rangeExpressionRule> $( ( ) @( | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<arrayLiteralRule> ::= · <postfixOperatorRule> $( ( ) @( | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<arrayLiteralRule> ::= · <postfixOperatorRule> CommaToken <arrayLiteralRule> $( ( ) @( | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<postfixOperatorRule> ::= · <lvalueExpression> PrePostfixOperatorToken $( ( ) @( | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<postfixOperatorRule> ::= · <propertyOrArrayReferenceRule> $( ( ) @( | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<propertyOrArrayReferenceRule> ::= · <valueRule> $( ( ) @( | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<propertyOrArrayReferenceRule> ::= · <valueRule> <propertyOrArrayReferenceOperatorList> $( ( ) @( | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '(' <assignmentStatementRule> ')' $( ( ) @( [ | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '$(' <statementListRule> ')' $( ( ) @( [ | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '@(' <statementListRule> ')' $( ( ) @( [ | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · UnaryOperatorToken <propertyOrArrayReferenceRule> $( ( ) @( [ | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · AttributeSpecificationToken <propertyOrArrayReferenceRule> $( ( ) @( [ | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · AttributeSpecificationToken $( ( ) @( [ | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · NumberToken $( ( ) @( [ | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · StringToken $( ( ) @( [ | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · ExpandableStringToken $( ( ) @( [ | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · VariableToken $( ( ) @( [ | AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
Actions
'$(' Shift 1
'(' Shift 2
'@(' Shift 3
AnyWordToken Shift 4
AttributeSpecificationToken Shift 5
break Shift 6
CommentToken Shift 7
continue Shift 8
do Shift 9
ExecCall Shift 10
ExpandableStringToken Shift 11
finally Shift 12
foreach Shift 13
if Shift 14
LoopLabelToken Shift 15
NumberToken Shift 16
return Shift 17
StringToken Shift 18
trap Shift 19
UnaryOperatorToken Shift 20
VariableToken Shift 21
<addExpressionRule> Goto 22
<arrayLiteralRule> Goto 23
<assignmentStatementRule> Goto 24
<bitwiseExpressionRule> Goto 25
<cmdletCall> Goto 26
<cmdletName> Goto 27
<comparisonExpressionRule> Goto 28
<doWhileStatementRule> Goto 29
<expressionRule> Goto 30
<finallyStatementRule> Goto 31
<flowControlStatementRule> Goto 32
<foreachStatementRule> Goto 33
<formatExpressionRule> Goto 34
<ifStatementRule> Goto 35
<logicalExpressionRule> Goto 36
<lvalue> Goto 37
<lvalueExpression> Goto 38
<multiplyExpressionRule> Goto 39
<pipelineRule> Goto 40
<postfixOperatorRule> Goto 41
<propertyOrArrayReferenceRule> Goto 42
<rangeExpressionRule> Goto 43
<statementListRule> Goto 53
<statementRule> Goto 45
<trapStatementRule> Goto 46
<valueRule> Goto 47

LALR State 4
Configuration Lookahead
<cmdletName> ::= AnyWordToken · EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
Actions
(EOF) Reduce Rule 30
'$(' Reduce Rule 30
'(' Reduce Rule 30
')' Reduce Rule 30
'@(' Reduce Rule 30
'|' Reduce Rule 30
'}' Reduce Rule 30
AnyWordToken Reduce Rule 30
AttributeSpecificationToken Reduce Rule 30
break Reduce Rule 30
CommentToken Reduce Rule 30
continue Reduce Rule 30
do Reduce Rule 30
ExecCall Reduce Rule 30
ExpandableStringToken Reduce Rule 30
finally Reduce Rule 30
foreach Reduce Rule 30
if Reduce Rule 30
LoopLabelToken Reduce Rule 30
NewLine Reduce Rule 30
NumberToken Reduce Rule 30
ParameterToken Reduce Rule 30
return Reduce Rule 30
StringToken Reduce Rule 30
trap Reduce Rule 30
UnaryOperatorToken Reduce Rule 30
VariableToken Reduce Rule 30

LALR State 5
Notes
WARNING: A SHIFT-REDUCE CONFLICT WAS FIXED: '$(', '(', '@(', AttributeSpecificationToken, ExpandableStringToken, NumberToken, StringToken, UnaryOperatorToken, VariableToken
Configuration Lookahead
<lvalue> ::= AttributeSpecificationToken · VariableToken AssignmentOperatorToken PrePostfixOperatorToken
<lvalue> ::= AttributeSpecificationToken · VariableToken <propertyOrArrayReferenceOperatorList> AssignmentOperatorToken PrePostfixOperatorToken
<valueRule> ::= AttributeSpecificationToken · <propertyOrArrayReferenceRule> EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= AttributeSpecificationToken · EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<propertyOrArrayReferenceRule> ::= · <valueRule> EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<propertyOrArrayReferenceRule> ::= · <valueRule> <propertyOrArrayReferenceOperatorList> EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '(' <assignmentStatementRule> ')' EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '$(' <statementListRule> ')' EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '@(' <statementListRule> ')' EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · UnaryOperatorToken <propertyOrArrayReferenceRule> EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · AttributeSpecificationToken <propertyOrArrayReferenceRule> EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · AttributeSpecificationToken EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · NumberToken EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · StringToken EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · ExpandableStringToken EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · VariableToken EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
Actions
'$(' Shift 1
'(' Shift 2
'@(' Shift 3
AttributeSpecificationToken Shift 54
ExpandableStringToken Shift 11
NumberToken Shift 16
StringToken Shift 18
UnaryOperatorToken Shift 20
VariableToken Shift 55
<propertyOrArrayReferenceRule> Goto 56
<valueRule> Goto 47
(EOF) Reduce Rule 102
')' Reduce Rule 102
'[' Reduce Rule 102
']' Reduce Rule 102
'|' Reduce Rule 102
'}' Reduce Rule 102
AdditionOperatorToken Reduce Rule 102
AnyWordToken Reduce Rule 102
BitwiseOperatorToken Reduce Rule 102
break Reduce Rule 102
CommaToken Reduce Rule 102
CommentToken Reduce Rule 102
ComparisonOperatorToken Reduce Rule 102
continue Reduce Rule 102
do Reduce Rule 102
ExecCall Reduce Rule 102
finally Reduce Rule 102
foreach Reduce Rule 102
FormatOperatorToken Reduce Rule 102
if Reduce Rule 102
LogicalOperatorToken Reduce Rule 102
LoopLabelToken Reduce Rule 102
MultiplyOperatorToken Reduce Rule 102
NewLine Reduce Rule 102
RangeOperatorToken Reduce Rule 102
return Reduce Rule 102
trap Reduce Rule 102

LALR State 6
Notes
WARNING: A SHIFT-REDUCE CONFLICT WAS FIXED: '$(', '(', '@(', AttributeSpecificationToken, ExpandableStringToken, NumberToken, StringToken, UnaryOperatorToken, VariableToken
Configuration Lookahead
<flowControlStatementRule> ::= break · EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<flowControlStatementRule> ::= break · <flowControlPropertyBody> EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<flowControlPropertyBody> ::= · <propertyOrArrayReferenceRule> EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<propertyOrArrayReferenceRule> ::= · <valueRule> EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<propertyOrArrayReferenceRule> ::= · <valueRule> <propertyOrArrayReferenceOperatorList> EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '(' <assignmentStatementRule> ')' EOF $( ( ) @( [ } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '$(' <statementListRule> ')' EOF $( ( ) @( [ } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '@(' <statementListRule> ')' EOF $( ( ) @( [ } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · UnaryOperatorToken <propertyOrArrayReferenceRule> EOF $( ( ) @( [ } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · AttributeSpecificationToken <propertyOrArrayReferenceRule> EOF $( ( ) @( [ } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · AttributeSpecificationToken EOF $( ( ) @( [ } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · NumberToken EOF $( ( ) @( [ } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · StringToken EOF $( ( ) @( [ } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · ExpandableStringToken EOF $( ( ) @( [ } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · VariableToken EOF $( ( ) @( [ } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
Actions
'$(' Shift 1
'(' Shift 2
'@(' Shift 3
AttributeSpecificationToken Shift 54
ExpandableStringToken Shift 11
NumberToken Shift 16
StringToken Shift 18
UnaryOperatorToken Shift 20
VariableToken Shift 57
<flowControlPropertyBody> Goto 58
<propertyOrArrayReferenceRule> Goto 59
<valueRule> Goto 47
(EOF) Reduce Rule 67
')' Reduce Rule 67
'}' Reduce Rule 67
AnyWordToken Reduce Rule 67
break Reduce Rule 67
CommentToken Reduce Rule 67
continue Reduce Rule 67
do Reduce Rule 67
ExecCall Reduce Rule 67
finally Reduce Rule 67
foreach Reduce Rule 67
if Reduce Rule 67
LoopLabelToken Reduce Rule 67
NewLine Reduce Rule 67
return Reduce Rule 67
trap Reduce Rule 67

LALR State 7
Configuration Lookahead
<statementRule> ::= CommentToken · EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
Actions
(EOF) Reduce Rule 6
'$(' Reduce Rule 6
'(' Reduce Rule 6
')' Reduce Rule 6
'@(' Reduce Rule 6
'}' Reduce Rule 6
AnyWordToken Reduce Rule 6
AttributeSpecificationToken Reduce Rule 6
break Reduce Rule 6
CommentToken Reduce Rule 6
continue Reduce Rule 6
do Reduce Rule 6
ExecCall Reduce Rule 6
ExpandableStringToken Reduce Rule 6
finally Reduce Rule 6
foreach Reduce Rule 6
if Reduce Rule 6
LoopLabelToken Reduce Rule 6
NewLine Reduce Rule 6
NumberToken Reduce Rule 6
return Reduce Rule 6
StringToken Reduce Rule 6
trap Reduce Rule 6
UnaryOperatorToken Reduce Rule 6
VariableToken Reduce Rule 6

LALR State 8
Notes
WARNING: A SHIFT-REDUCE CONFLICT WAS FIXED: '$(', '(', '@(', AttributeSpecificationToken, ExpandableStringToken, NumberToken, StringToken, UnaryOperatorToken, VariableToken
Configuration Lookahead
<flowControlStatementRule> ::= continue · EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<flowControlStatementRule> ::= continue · <flowControlPropertyBody> EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<flowControlPropertyBody> ::= · <propertyOrArrayReferenceRule> EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<propertyOrArrayReferenceRule> ::= · <valueRule> EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<propertyOrArrayReferenceRule> ::= · <valueRule> <propertyOrArrayReferenceOperatorList> EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '(' <assignmentStatementRule> ')' EOF $( ( ) @( [ } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '$(' <statementListRule> ')' EOF $( ( ) @( [ } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '@(' <statementListRule> ')' EOF $( ( ) @( [ } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · UnaryOperatorToken <propertyOrArrayReferenceRule> EOF $( ( ) @( [ } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · AttributeSpecificationToken <propertyOrArrayReferenceRule> EOF $( ( ) @( [ } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · AttributeSpecificationToken EOF $( ( ) @( [ } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · NumberToken EOF $( ( ) @( [ } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · StringToken EOF $( ( ) @( [ } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · ExpandableStringToken EOF $( ( ) @( [ } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · VariableToken EOF $( ( ) @( [ } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
Actions
'$(' Shift 1
'(' Shift 2
'@(' Shift 3
AttributeSpecificationToken Shift 54
ExpandableStringToken Shift 11
NumberToken Shift 16
StringToken Shift 18
UnaryOperatorToken Shift 20
VariableToken Shift 57
<flowControlPropertyBody> Goto 60
<propertyOrArrayReferenceRule> Goto 59
<valueRule> Goto 47
(EOF) Reduce Rule 68
')' Reduce Rule 68
'}' Reduce Rule 68
AnyWordToken Reduce Rule 68
break Reduce Rule 68
CommentToken Reduce Rule 68
continue Reduce Rule 68
do Reduce Rule 68
ExecCall Reduce Rule 68
finally Reduce Rule 68
foreach Reduce Rule 68
if Reduce Rule 68
LoopLabelToken Reduce Rule 68
NewLine Reduce Rule 68
return Reduce Rule 68
trap Reduce Rule 68

LALR State 9
Configuration Lookahead
<doWhileStatementRule> ::= do · <statementBlockRule> while '(' <pipelineRule> ')' EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<doWhileStatementRule> ::= do · <statementBlockRule> until '(' <pipelineRule> ')' EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<statementBlockRule> ::= · '{' <statementListRule> '}' until while
Actions
'{' Shift 61
<statementBlockRule> Goto 62

LALR State 10
Configuration Lookahead
<cmdletCall> ::= ExecCall · <cmdletName> <cmletParamsList> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<cmdletCall> ::= ExecCall · <cmdletName> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<cmdletName> ::= · AnyWordToken EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
Actions
AnyWordToken Shift 4
<cmdletName> Goto 63

LALR State 11
Configuration Lookahead
<valueRule> ::= ExpandableStringToken · EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
Actions
(EOF) Reduce Rule 105
'$(' Reduce Rule 105
'(' Reduce Rule 105
')' Reduce Rule 105
'@(' Reduce Rule 105
'[' Reduce Rule 105
']' Reduce Rule 105
'|' Reduce Rule 105
'}' Reduce Rule 105
AdditionOperatorToken Reduce Rule 105
AnyWordToken Reduce Rule 105
AssignmentOperatorToken Reduce Rule 105
AttributeSpecificationToken Reduce Rule 105
BitwiseOperatorToken Reduce Rule 105
break Reduce Rule 105
CommaToken Reduce Rule 105
CommentToken Reduce Rule 105
ComparisonOperatorToken Reduce Rule 105
continue Reduce Rule 105
do Reduce Rule 105
ExecCall Reduce Rule 105
ExpandableStringToken Reduce Rule 105
finally Reduce Rule 105
foreach Reduce Rule 105
FormatOperatorToken Reduce Rule 105
if Reduce Rule 105
LogicalOperatorToken Reduce Rule 105
LoopLabelToken Reduce Rule 105
MultiplyOperatorToken Reduce Rule 105
NewLine Reduce Rule 105
NumberToken Reduce Rule 105
ParameterToken Reduce Rule 105
PrePostfixOperatorToken Reduce Rule 105
RangeOperatorToken Reduce Rule 105
return Reduce Rule 105
StringToken Reduce Rule 105
trap Reduce Rule 105
UnaryOperatorToken Reduce Rule 105
VariableToken Reduce Rule 105

LALR State 12
Configuration Lookahead
<finallyStatementRule> ::= finally · <statementBlockRule> EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<statementBlockRule> ::= · '{' <statementListRule> '}' EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
Actions
'{' Shift 61
<statementBlockRule> Goto 64

LALR State 13
Configuration Lookahead
<foreachStatementRule> ::= foreach · '(' VariableToken in <pipelineRule> ')' <statementBlockRule> EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
Actions
'(' Shift 65

LALR State 14
Configuration Lookahead
<ifStatementRule> ::= if · '(' <pipelineRule> ')' <statementBlockRule> EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<ifStatementRule> ::= if · '(' <pipelineRule> ')' <statementBlockRule> <elseIfBlockRule> EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<ifStatementRule> ::= if · '(' <pipelineRule> ')' <statementBlockRule> else <statementBlockRule> EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<ifStatementRule> ::= if · '(' <pipelineRule> ')' <statementBlockRule> <elseIfBlockRule> else <statementBlockRule> EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
Actions
'(' Shift 66

LALR State 15
Configuration Lookahead
<foreachStatementRule> ::= LoopLabelToken · foreach '(' VariableToken in <pipelineRule> ')' <statementBlockRule> EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<doWhileStatementRule> ::= LoopLabelToken · do <statementBlockRule> while '(' <pipelineRule> ')' EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<doWhileStatementRule> ::= LoopLabelToken · do <statementBlockRule> until '(' <pipelineRule> ')' EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
Actions
do Shift 67
foreach Shift 68

LALR State 16
Configuration Lookahead
<valueRule> ::= NumberToken · EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
Actions
(EOF) Reduce Rule 103
'$(' Reduce Rule 103
'(' Reduce Rule 103
')' Reduce Rule 103
'@(' Reduce Rule 103
'[' Reduce Rule 103
']' Reduce Rule 103
'|' Reduce Rule 103
'}' Reduce Rule 103
AdditionOperatorToken Reduce Rule 103
AnyWordToken Reduce Rule 103
AssignmentOperatorToken Reduce Rule 103
AttributeSpecificationToken Reduce Rule 103
BitwiseOperatorToken Reduce Rule 103
break Reduce Rule 103
CommaToken Reduce Rule 103
CommentToken Reduce Rule 103
ComparisonOperatorToken Reduce Rule 103
continue Reduce Rule 103
do Reduce Rule 103
ExecCall Reduce Rule 103
ExpandableStringToken Reduce Rule 103
finally Reduce Rule 103
foreach Reduce Rule 103
FormatOperatorToken Reduce Rule 103
if Reduce Rule 103
LogicalOperatorToken Reduce Rule 103
LoopLabelToken Reduce Rule 103
MultiplyOperatorToken Reduce Rule 103
NewLine Reduce Rule 103
NumberToken Reduce Rule 103
ParameterToken Reduce Rule 103
PrePostfixOperatorToken Reduce Rule 103
RangeOperatorToken Reduce Rule 103
return Reduce Rule 103
StringToken Reduce Rule 103
trap Reduce Rule 103
UnaryOperatorToken Reduce Rule 103
VariableToken Reduce Rule 103

LALR State 17
Configuration Lookahead
<flowControlStatementRule> ::= return · <pipelineRule> EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<pipelineRule> ::= · <cmdletCall> EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<pipelineRule> ::= · <cmdletCall> '|' <pipelineRule> EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<pipelineRule> ::= · <assignmentStatementRule> EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<pipelineRule> ::= · <assignmentStatementRule> '|' <pipelineRule> EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<assignmentStatementRule> ::= · <lvalueExpression> AssignmentOperatorToken <pipelineRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<lvalueExpression> ::= · <lvalue> AssignmentOperatorToken PrePostfixOperatorToken
<lvalue> ::= · VariableToken AssignmentOperatorToken PrePostfixOperatorToken
<lvalue> ::= · AttributeSpecificationToken VariableToken AssignmentOperatorToken PrePostfixOperatorToken
<lvalue> ::= · VariableToken <propertyOrArrayReferenceOperatorList> AssignmentOperatorToken PrePostfixOperatorToken
<lvalue> ::= · AttributeSpecificationToken VariableToken <propertyOrArrayReferenceOperatorList> AssignmentOperatorToken PrePostfixOperatorToken
<cmdletName> ::= · AnyWordToken EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
<cmdletCall> ::= · ExecCall <cmdletName> <cmletParamsList> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<cmdletCall> ::= · ExecCall <cmdletName> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<cmdletCall> ::= · <cmdletName> <cmletParamsList> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<cmdletCall> ::= · <cmdletName> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<cmdletCall> ::= · <expressionRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<expressionRule> ::= · <logicalExpressionRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<logicalExpressionRule> ::= · <bitwiseExpressionRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<logicalExpressionRule> ::= · <bitwiseExpressionRule> LogicalOperatorToken <logicalExpressionRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<bitwiseExpressionRule> ::= · <comparisonExpressionRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<bitwiseExpressionRule> ::= · <comparisonExpressionRule> BitwiseOperatorToken <bitwiseExpressionRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<comparisonExpressionRule> ::= · <addExpressionRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<comparisonExpressionRule> ::= · <addExpressionRule> ComparisonOperatorToken <comparisonExpressionRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<addExpressionRule> ::= · <multiplyExpressionRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<addExpressionRule> ::= · <multiplyExpressionRule> AdditionOperatorToken <addExpressionRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<multiplyExpressionRule> ::= · <formatExpressionRule> EOF $( ( ) @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<multiplyExpressionRule> ::= · <formatExpressionRule> MultiplyOperatorToken <multiplyExpressionRule> EOF $( ( ) @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<formatExpressionRule> ::= · <rangeExpressionRule> EOF $( ( ) @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<formatExpressionRule> ::= · <rangeExpressionRule> FormatOperatorToken <formatExpressionRule> EOF $( ( ) @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<rangeExpressionRule> ::= · <arrayLiteralRule> EOF $( ( ) @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<rangeExpressionRule> ::= · <arrayLiteralRule> RangeOperatorToken <rangeExpressionRule> EOF $( ( ) @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<arrayLiteralRule> ::= · <postfixOperatorRule> EOF $( ( ) @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<arrayLiteralRule> ::= · <postfixOperatorRule> CommaToken <arrayLiteralRule> EOF $( ( ) @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<postfixOperatorRule> ::= · <lvalueExpression> PrePostfixOperatorToken EOF $( ( ) @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<postfixOperatorRule> ::= · <propertyOrArrayReferenceRule> EOF $( ( ) @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<propertyOrArrayReferenceRule> ::= · <valueRule> EOF $( ( ) @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<propertyOrArrayReferenceRule> ::= · <valueRule> <propertyOrArrayReferenceOperatorList> EOF $( ( ) @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '(' <assignmentStatementRule> ')' EOF $( ( ) @( [ | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '$(' <statementListRule> ')' EOF $( ( ) @( [ | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '@(' <statementListRule> ')' EOF $( ( ) @( [ | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · UnaryOperatorToken <propertyOrArrayReferenceRule> EOF $( ( ) @( [ | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · AttributeSpecificationToken <propertyOrArrayReferenceRule> EOF $( ( ) @( [ | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · AttributeSpecificationToken EOF $( ( ) @( [ | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · NumberToken EOF $( ( ) @( [ | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · StringToken EOF $( ( ) @( [ | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · ExpandableStringToken EOF $( ( ) @( [ | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · VariableToken EOF $( ( ) @( [ | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
Actions
'$(' Shift 1
'(' Shift 2
'@(' Shift 3
AnyWordToken Shift 4
AttributeSpecificationToken Shift 5
ExecCall Shift 10
ExpandableStringToken Shift 11
NumberToken Shift 16
StringToken Shift 18
UnaryOperatorToken Shift 20
VariableToken Shift 21
<addExpressionRule> Goto 22
<arrayLiteralRule> Goto 23
<assignmentStatementRule> Goto 24
<bitwiseExpressionRule> Goto 25
<cmdletCall> Goto 26
<cmdletName> Goto 27
<comparisonExpressionRule> Goto 28
<expressionRule> Goto 30
<formatExpressionRule> Goto 34
<logicalExpressionRule> Goto 36
<lvalue> Goto 37
<lvalueExpression> Goto 38
<multiplyExpressionRule> Goto 39
<pipelineRule> Goto 69
<postfixOperatorRule> Goto 41
<propertyOrArrayReferenceRule> Goto 42
<rangeExpressionRule> Goto 43
<valueRule> Goto 47

LALR State 18
Configuration Lookahead
<valueRule> ::= StringToken · EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
Actions
(EOF) Reduce Rule 104
'$(' Reduce Rule 104
'(' Reduce Rule 104
')' Reduce Rule 104
'@(' Reduce Rule 104
'[' Reduce Rule 104
']' Reduce Rule 104
'|' Reduce Rule 104
'}' Reduce Rule 104
AdditionOperatorToken Reduce Rule 104
AnyWordToken Reduce Rule 104
AssignmentOperatorToken Reduce Rule 104
AttributeSpecificationToken Reduce Rule 104
BitwiseOperatorToken Reduce Rule 104
break Reduce Rule 104
CommaToken Reduce Rule 104
CommentToken Reduce Rule 104
ComparisonOperatorToken Reduce Rule 104
continue Reduce Rule 104
do Reduce Rule 104
ExecCall Reduce Rule 104
ExpandableStringToken Reduce Rule 104
finally Reduce Rule 104
foreach Reduce Rule 104
FormatOperatorToken Reduce Rule 104
if Reduce Rule 104
LogicalOperatorToken Reduce Rule 104
LoopLabelToken Reduce Rule 104
MultiplyOperatorToken Reduce Rule 104
NewLine Reduce Rule 104
NumberToken Reduce Rule 104
ParameterToken Reduce Rule 104
PrePostfixOperatorToken Reduce Rule 104
RangeOperatorToken Reduce Rule 104
return Reduce Rule 104
StringToken Reduce Rule 104
trap Reduce Rule 104
UnaryOperatorToken Reduce Rule 104
VariableToken Reduce Rule 104

LALR State 19
Configuration Lookahead
<trapStatementRule> ::= trap · <statementBlockRule> EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<trapStatementRule> ::= trap · AttributeSpecificationToken <statementBlockRule> EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<statementBlockRule> ::= · '{' <statementListRule> '}' EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
Actions
'{' Shift 61
AttributeSpecificationToken Shift 70
<statementBlockRule> Goto 71

LALR State 20
Configuration Lookahead
<valueRule> ::= UnaryOperatorToken · <propertyOrArrayReferenceRule> EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<propertyOrArrayReferenceRule> ::= · <valueRule> EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<propertyOrArrayReferenceRule> ::= · <valueRule> <propertyOrArrayReferenceOperatorList> EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '(' <assignmentStatementRule> ')' EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '$(' <statementListRule> ')' EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '@(' <statementListRule> ')' EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · UnaryOperatorToken <propertyOrArrayReferenceRule> EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · AttributeSpecificationToken <propertyOrArrayReferenceRule> EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · AttributeSpecificationToken EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · NumberToken EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · StringToken EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · ExpandableStringToken EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · VariableToken EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
Actions
'$(' Shift 1
'(' Shift 2
'@(' Shift 3
AttributeSpecificationToken Shift 54
ExpandableStringToken Shift 11
NumberToken Shift 16
StringToken Shift 18
UnaryOperatorToken Shift 20
VariableToken Shift 57
<propertyOrArrayReferenceRule> Goto 72
<valueRule> Goto 47

LALR State 21
Notes
WARNING: A SHIFT-REDUCE CONFLICT WAS FIXED: '['
Configuration Lookahead
<lvalue> ::= VariableToken · AssignmentOperatorToken PrePostfixOperatorToken
<lvalue> ::= VariableToken · <propertyOrArrayReferenceOperatorList> AssignmentOperatorToken PrePostfixOperatorToken
<valueRule> ::= VariableToken · EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<propertyOrArrayReferenceOperatorList> ::= · <propertyOrArrayReferenceOperator> [ AssignmentOperatorToken PrePostfixOperatorToken
<propertyOrArrayReferenceOperatorList> ::= · <propertyOrArrayReferenceOperatorList> <propertyOrArrayReferenceOperator> [ AssignmentOperatorToken PrePostfixOperatorToken
<propertyOrArrayReferenceOperator> ::= · '[' <expressionRule> ']' ReferenceOperatorToken AnyWordToken [ AssignmentOperatorToken PrePostfixOperatorToken
<propertyOrArrayReferenceOperator> ::= · '[' <expressionRule> ']' ReferenceOperatorToken AnyWordToken <parseCallRule> [ AssignmentOperatorToken PrePostfixOperatorToken
<propertyOrArrayReferenceOperator> ::= · '[' <expressionRule> ']' <valueRule> [ AssignmentOperatorToken PrePostfixOperatorToken
Actions
'[' Shift 73
<propertyOrArrayReferenceOperator> Goto 74
<propertyOrArrayReferenceOperatorList> Goto 75
AssignmentOperatorToken Reduce Rule 21
PrePostfixOperatorToken Reduce Rule 21
(EOF) Reduce Rule 106
'$(' Reduce Rule 106
'(' Reduce Rule 106
')' Reduce Rule 106
'@(' Reduce Rule 106
']' Reduce Rule 106
'|' Reduce Rule 106
'}' Reduce Rule 106
AdditionOperatorToken Reduce Rule 106
AnyWordToken Reduce Rule 106
AttributeSpecificationToken Reduce Rule 106
BitwiseOperatorToken Reduce Rule 106
break Reduce Rule 106
CommaToken Reduce Rule 106
CommentToken Reduce Rule 106
ComparisonOperatorToken Reduce Rule 106
continue Reduce Rule 106
do Reduce Rule 106
ExecCall Reduce Rule 106
ExpandableStringToken Reduce Rule 106
finally Reduce Rule 106
foreach Reduce Rule 106
FormatOperatorToken Reduce Rule 106
if Reduce Rule 106
LogicalOperatorToken Reduce Rule 106
LoopLabelToken Reduce Rule 106
MultiplyOperatorToken Reduce Rule 106
NewLine Reduce Rule 106
NumberToken Reduce Rule 106
RangeOperatorToken Reduce Rule 106
return Reduce Rule 106
StringToken Reduce Rule 106
trap Reduce Rule 106
UnaryOperatorToken Reduce Rule 106
VariableToken Reduce Rule 106

LALR State 22
Configuration Lookahead
<comparisonExpressionRule> ::= <addExpressionRule> · EOF $( ( ) @( ] | } AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<comparisonExpressionRule> ::= <addExpressionRule> · ComparisonOperatorToken <comparisonExpressionRule> EOF $( ( ) @( ] | } AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
Actions
ComparisonOperatorToken Shift 76
(EOF) Reduce Rule 77
'$(' Reduce Rule 77
'(' Reduce Rule 77
')' Reduce Rule 77
'@(' Reduce Rule 77
']' Reduce Rule 77
'|' Reduce Rule 77
'}' Reduce Rule 77
AnyWordToken Reduce Rule 77
AttributeSpecificationToken Reduce Rule 77
BitwiseOperatorToken Reduce Rule 77
break Reduce Rule 77
CommentToken Reduce Rule 77
continue Reduce Rule 77
do Reduce Rule 77
ExecCall Reduce Rule 77
ExpandableStringToken Reduce Rule 77
finally Reduce Rule 77
foreach Reduce Rule 77
if Reduce Rule 77
LogicalOperatorToken Reduce Rule 77
LoopLabelToken Reduce Rule 77
NewLine Reduce Rule 77
NumberToken Reduce Rule 77
return Reduce Rule 77
StringToken Reduce Rule 77
trap Reduce Rule 77
UnaryOperatorToken Reduce Rule 77
VariableToken Reduce Rule 77

LALR State 23
Configuration Lookahead
<rangeExpressionRule> ::= <arrayLiteralRule> · EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<rangeExpressionRule> ::= <arrayLiteralRule> · RangeOperatorToken <rangeExpressionRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
Actions
RangeOperatorToken Shift 77
(EOF) Reduce Rule 85
'$(' Reduce Rule 85
'(' Reduce Rule 85
')' Reduce Rule 85
'@(' Reduce Rule 85
']' Reduce Rule 85
'|' Reduce Rule 85
'}' Reduce Rule 85
AdditionOperatorToken Reduce Rule 85
AnyWordToken Reduce Rule 85
AttributeSpecificationToken Reduce Rule 85
BitwiseOperatorToken Reduce Rule 85
break Reduce Rule 85
CommentToken Reduce Rule 85
ComparisonOperatorToken Reduce Rule 85
continue Reduce Rule 85
do Reduce Rule 85
ExecCall Reduce Rule 85
ExpandableStringToken Reduce Rule 85
finally Reduce Rule 85
foreach Reduce Rule 85
FormatOperatorToken Reduce Rule 85
if Reduce Rule 85
LogicalOperatorToken Reduce Rule 85
LoopLabelToken Reduce Rule 85
MultiplyOperatorToken Reduce Rule 85
NewLine Reduce Rule 85
NumberToken Reduce Rule 85
return Reduce Rule 85
StringToken Reduce Rule 85
trap Reduce Rule 85
UnaryOperatorToken Reduce Rule 85
VariableToken Reduce Rule 85

LALR State 24
Notes
WARNING: A SHIFT-REDUCE CONFLICT WAS FIXED: '|'
Configuration Lookahead
<pipelineRule> ::= <assignmentStatementRule> · EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<pipelineRule> ::= <assignmentStatementRule> · '|' <pipelineRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
Actions
'|' Shift 78
(EOF) Reduce Rule 15
'$(' Reduce Rule 15
'(' Reduce Rule 15
')' Reduce Rule 15
'@(' Reduce Rule 15
'}' Reduce Rule 15
AnyWordToken Reduce Rule 15
AttributeSpecificationToken Reduce Rule 15
break Reduce Rule 15
CommentToken Reduce Rule 15
continue Reduce Rule 15
do Reduce Rule 15
ExecCall Reduce Rule 15
ExpandableStringToken Reduce Rule 15
finally Reduce Rule 15
foreach Reduce Rule 15
if Reduce Rule 15
LoopLabelToken Reduce Rule 15
NewLine Reduce Rule 15
NumberToken Reduce Rule 15
return Reduce Rule 15
StringToken Reduce Rule 15
trap Reduce Rule 15
UnaryOperatorToken Reduce Rule 15
VariableToken Reduce Rule 15

LALR State 25
Configuration Lookahead
<logicalExpressionRule> ::= <bitwiseExpressionRule> · EOF $( ( ) @( ] | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<logicalExpressionRule> ::= <bitwiseExpressionRule> · LogicalOperatorToken <logicalExpressionRule> EOF $( ( ) @( ] | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
Actions
LogicalOperatorToken Shift 79
(EOF) Reduce Rule 73
'$(' Reduce Rule 73
'(' Reduce Rule 73
')' Reduce Rule 73
'@(' Reduce Rule 73
']' Reduce Rule 73
'|' Reduce Rule 73
'}' Reduce Rule 73
AnyWordToken Reduce Rule 73
AttributeSpecificationToken Reduce Rule 73
break Reduce Rule 73
CommentToken Reduce Rule 73
continue Reduce Rule 73
do Reduce Rule 73
ExecCall Reduce Rule 73
ExpandableStringToken Reduce Rule 73
finally Reduce Rule 73
foreach Reduce Rule 73
if Reduce Rule 73
LoopLabelToken Reduce Rule 73
NewLine Reduce Rule 73
NumberToken Reduce Rule 73
return Reduce Rule 73
StringToken Reduce Rule 73
trap Reduce Rule 73
UnaryOperatorToken Reduce Rule 73
VariableToken Reduce Rule 73

LALR State 26
Notes
WARNING: A SHIFT-REDUCE CONFLICT WAS FIXED: '|'
Configuration Lookahead
<pipelineRule> ::= <cmdletCall> · EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<pipelineRule> ::= <cmdletCall> · '|' <pipelineRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
Actions
'|' Shift 80
(EOF) Reduce Rule 13
'$(' Reduce Rule 13
'(' Reduce Rule 13
')' Reduce Rule 13
'@(' Reduce Rule 13
'}' Reduce Rule 13
AnyWordToken Reduce Rule 13
AttributeSpecificationToken Reduce Rule 13
break Reduce Rule 13
CommentToken Reduce Rule 13
continue Reduce Rule 13
do Reduce Rule 13
ExecCall Reduce Rule 13
ExpandableStringToken Reduce Rule 13
finally Reduce Rule 13
foreach Reduce Rule 13
if Reduce Rule 13
LoopLabelToken Reduce Rule 13
NewLine Reduce Rule 13
NumberToken Reduce Rule 13
return Reduce Rule 13
StringToken Reduce Rule 13
trap Reduce Rule 13
UnaryOperatorToken Reduce Rule 13
VariableToken Reduce Rule 13

LALR State 27
Notes
WARNING: A SHIFT-REDUCE CONFLICT WAS FIXED: '$(', '(', '@(', AnyWordToken, AttributeSpecificationToken, ExpandableStringToken, NumberToken, StringToken, UnaryOperatorToken, VariableToken
Configuration Lookahead
<cmdletCall> ::= <cmdletName> · <cmletParamsList> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<cmdletCall> ::= <cmdletName> · EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<ParameterArgumentToken> ::= · <valueRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
<ParameterArgumentToken> ::= · AnyWordToken EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
<ParameterArgumentToken> ::= · ParameterToken EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
<cmletParamsList> ::= · <ParameterArgumentToken> <cmletParamsList> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<cmletParamsList> ::= · <ParameterArgumentToken> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '(' <assignmentStatementRule> ')' EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '$(' <statementListRule> ')' EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '@(' <statementListRule> ')' EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · UnaryOperatorToken <propertyOrArrayReferenceRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · AttributeSpecificationToken <propertyOrArrayReferenceRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · AttributeSpecificationToken EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · NumberToken EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · StringToken EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · ExpandableStringToken EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · VariableToken EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
Actions
'$(' Shift 1
'(' Shift 2
'@(' Shift 3
AnyWordToken Shift 81
AttributeSpecificationToken Shift 54
ExpandableStringToken Shift 11
NumberToken Shift 16
ParameterToken Shift 82
StringToken Shift 18
UnaryOperatorToken Shift 20
VariableToken Shift 57
<cmletParamsList> Goto 83
<ParameterArgumentToken> Goto 84
<valueRule> Goto 85
(EOF) Reduce Rule 34
')' Reduce Rule 34
'|' Reduce Rule 34
'}' Reduce Rule 34
break Reduce Rule 34
CommentToken Reduce Rule 34
continue Reduce Rule 34
do Reduce Rule 34
ExecCall Reduce Rule 34
finally Reduce Rule 34
foreach Reduce Rule 34
if Reduce Rule 34
LoopLabelToken Reduce Rule 34
NewLine Reduce Rule 34
return Reduce Rule 34
trap Reduce Rule 34

LALR State 28
Configuration Lookahead
<bitwiseExpressionRule> ::= <comparisonExpressionRule> · EOF $( ( ) @( ] | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<bitwiseExpressionRule> ::= <comparisonExpressionRule> · BitwiseOperatorToken <bitwiseExpressionRule> EOF $( ( ) @( ] | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
Actions
BitwiseOperatorToken Shift 86
(EOF) Reduce Rule 75
'$(' Reduce Rule 75
'(' Reduce Rule 75
')' Reduce Rule 75
'@(' Reduce Rule 75
']' Reduce Rule 75
'|' Reduce Rule 75
'}' Reduce Rule 75
AnyWordToken Reduce Rule 75
AttributeSpecificationToken Reduce Rule 75
break Reduce Rule 75
CommentToken Reduce Rule 75
continue Reduce Rule 75
do Reduce Rule 75
ExecCall Reduce Rule 75
ExpandableStringToken Reduce Rule 75
finally Reduce Rule 75
foreach Reduce Rule 75
if Reduce Rule 75
LogicalOperatorToken Reduce Rule 75
LoopLabelToken Reduce Rule 75
NewLine Reduce Rule 75
NumberToken Reduce Rule 75
return Reduce Rule 75
StringToken Reduce Rule 75
trap Reduce Rule 75
UnaryOperatorToken Reduce Rule 75
VariableToken Reduce Rule 75

LALR State 29
Configuration Lookahead
<statementRule> ::= <doWhileStatementRule> · EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
Actions
(EOF) Reduce Rule 9
'$(' Reduce Rule 9
'(' Reduce Rule 9
')' Reduce Rule 9
'@(' Reduce Rule 9
'}' Reduce Rule 9
AnyWordToken Reduce Rule 9
AttributeSpecificationToken Reduce Rule 9
break Reduce Rule 9
CommentToken Reduce Rule 9
continue Reduce Rule 9
do Reduce Rule 9
ExecCall Reduce Rule 9
ExpandableStringToken Reduce Rule 9
finally Reduce Rule 9
foreach Reduce Rule 9
if Reduce Rule 9
LoopLabelToken Reduce Rule 9
NewLine Reduce Rule 9
NumberToken Reduce Rule 9
return Reduce Rule 9
StringToken Reduce Rule 9
trap Reduce Rule 9
UnaryOperatorToken Reduce Rule 9
VariableToken Reduce Rule 9

LALR State 30
Configuration Lookahead
<cmdletCall> ::= <expressionRule> · EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
Actions
(EOF) Reduce Rule 35
'$(' Reduce Rule 35
'(' Reduce Rule 35
')' Reduce Rule 35
'@(' Reduce Rule 35
'|' Reduce Rule 35
'}' Reduce Rule 35
AnyWordToken Reduce Rule 35
AttributeSpecificationToken Reduce Rule 35
break Reduce Rule 35
CommentToken Reduce Rule 35
continue Reduce Rule 35
do Reduce Rule 35
ExecCall Reduce Rule 35
ExpandableStringToken Reduce Rule 35
finally Reduce Rule 35
foreach Reduce Rule 35
if Reduce Rule 35
LoopLabelToken Reduce Rule 35
NewLine Reduce Rule 35
NumberToken Reduce Rule 35
return Reduce Rule 35
StringToken Reduce Rule 35
trap Reduce Rule 35
UnaryOperatorToken Reduce Rule 35
VariableToken Reduce Rule 35

LALR State 31
Configuration Lookahead
<statementRule> ::= <finallyStatementRule> · EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
Actions
(EOF) Reduce Rule 12
'$(' Reduce Rule 12
'(' Reduce Rule 12
')' Reduce Rule 12
'@(' Reduce Rule 12
'}' Reduce Rule 12
AnyWordToken Reduce Rule 12
AttributeSpecificationToken Reduce Rule 12
break Reduce Rule 12
CommentToken Reduce Rule 12
continue Reduce Rule 12
do Reduce Rule 12
ExecCall Reduce Rule 12
ExpandableStringToken Reduce Rule 12
finally Reduce Rule 12
foreach Reduce Rule 12
if Reduce Rule 12
LoopLabelToken Reduce Rule 12
NewLine Reduce Rule 12
NumberToken Reduce Rule 12
return Reduce Rule 12
StringToken Reduce Rule 12
trap Reduce Rule 12
UnaryOperatorToken Reduce Rule 12
VariableToken Reduce Rule 12

LALR State 32
Configuration Lookahead
<statementRule> ::= <flowControlStatementRule> · EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
Actions
(EOF) Reduce Rule 10
'$(' Reduce Rule 10
'(' Reduce Rule 10
')' Reduce Rule 10
'@(' Reduce Rule 10
'}' Reduce Rule 10
AnyWordToken Reduce Rule 10
AttributeSpecificationToken Reduce Rule 10
break Reduce Rule 10
CommentToken Reduce Rule 10
continue Reduce Rule 10
do Reduce Rule 10
ExecCall Reduce Rule 10
ExpandableStringToken Reduce Rule 10
finally Reduce Rule 10
foreach Reduce Rule 10
if Reduce Rule 10
LoopLabelToken Reduce Rule 10
NewLine Reduce Rule 10
NumberToken Reduce Rule 10
return Reduce Rule 10
StringToken Reduce Rule 10
trap Reduce Rule 10
UnaryOperatorToken Reduce Rule 10
VariableToken Reduce Rule 10

LALR State 33
Configuration Lookahead
<statementRule> ::= <foreachStatementRule> · EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
Actions
(EOF) Reduce Rule 8
'$(' Reduce Rule 8
'(' Reduce Rule 8
')' Reduce Rule 8
'@(' Reduce Rule 8
'}' Reduce Rule 8
AnyWordToken Reduce Rule 8
AttributeSpecificationToken Reduce Rule 8
break Reduce Rule 8
CommentToken Reduce Rule 8
continue Reduce Rule 8
do Reduce Rule 8
ExecCall Reduce Rule 8
ExpandableStringToken Reduce Rule 8
finally Reduce Rule 8
foreach Reduce Rule 8
if Reduce Rule 8
LoopLabelToken Reduce Rule 8
NewLine Reduce Rule 8
NumberToken Reduce Rule 8
return Reduce Rule 8
StringToken Reduce Rule 8
trap Reduce Rule 8
UnaryOperatorToken Reduce Rule 8
VariableToken Reduce Rule 8

LALR State 34
Configuration Lookahead
<multiplyExpressionRule> ::= <formatExpressionRule> · EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<multiplyExpressionRule> ::= <formatExpressionRule> · MultiplyOperatorToken <multiplyExpressionRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
Actions
MultiplyOperatorToken Shift 87
(EOF) Reduce Rule 81
'$(' Reduce Rule 81
'(' Reduce Rule 81
')' Reduce Rule 81
'@(' Reduce Rule 81
']' Reduce Rule 81
'|' Reduce Rule 81
'}' Reduce Rule 81
AdditionOperatorToken Reduce Rule 81
AnyWordToken Reduce Rule 81
AttributeSpecificationToken Reduce Rule 81
BitwiseOperatorToken Reduce Rule 81
break Reduce Rule 81
CommentToken Reduce Rule 81
ComparisonOperatorToken Reduce Rule 81
continue Reduce Rule 81
do Reduce Rule 81
ExecCall Reduce Rule 81
ExpandableStringToken Reduce Rule 81
finally Reduce Rule 81
foreach Reduce Rule 81
if Reduce Rule 81
LogicalOperatorToken Reduce Rule 81
LoopLabelToken Reduce Rule 81
NewLine Reduce Rule 81
NumberToken Reduce Rule 81
return Reduce Rule 81
StringToken Reduce Rule 81
trap Reduce Rule 81
UnaryOperatorToken Reduce Rule 81
VariableToken Reduce Rule 81

LALR State 35
Configuration Lookahead
<statementRule> ::= <ifStatementRule> · EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
Actions
(EOF) Reduce Rule 7
'$(' Reduce Rule 7
'(' Reduce Rule 7
')' Reduce Rule 7
'@(' Reduce Rule 7
'}' Reduce Rule 7
AnyWordToken Reduce Rule 7
AttributeSpecificationToken Reduce Rule 7
break Reduce Rule 7
CommentToken Reduce Rule 7
continue Reduce Rule 7
do Reduce Rule 7
ExecCall Reduce Rule 7
ExpandableStringToken Reduce Rule 7
finally Reduce Rule 7
foreach Reduce Rule 7
if Reduce Rule 7
LoopLabelToken Reduce Rule 7
NewLine Reduce Rule 7
NumberToken Reduce Rule 7
return Reduce Rule 7
StringToken Reduce Rule 7
trap Reduce Rule 7
UnaryOperatorToken Reduce Rule 7
VariableToken Reduce Rule 7

LALR State 36
Configuration Lookahead
<expressionRule> ::= <logicalExpressionRule> · EOF $( ( ) @( ] | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
Actions
(EOF) Reduce Rule 72
'$(' Reduce Rule 72
'(' Reduce Rule 72
')' Reduce Rule 72
'@(' Reduce Rule 72
']' Reduce Rule 72
'|' Reduce Rule 72
'}' Reduce Rule 72
AnyWordToken Reduce Rule 72
AttributeSpecificationToken Reduce Rule 72
break Reduce Rule 72
CommentToken Reduce Rule 72
continue Reduce Rule 72
do Reduce Rule 72
ExecCall Reduce Rule 72
ExpandableStringToken Reduce Rule 72
finally Reduce Rule 72
foreach Reduce Rule 72
if Reduce Rule 72
LoopLabelToken Reduce Rule 72
NewLine Reduce Rule 72
NumberToken Reduce Rule 72
return Reduce Rule 72
StringToken Reduce Rule 72
trap Reduce Rule 72
UnaryOperatorToken Reduce Rule 72
VariableToken Reduce Rule 72

LALR State 37
Configuration Lookahead
<lvalueExpression> ::= <lvalue> · AssignmentOperatorToken PrePostfixOperatorToken
Actions
AssignmentOperatorToken Reduce Rule 18
PrePostfixOperatorToken Reduce Rule 18

LALR State 38
Configuration Lookahead
<assignmentStatementRule> ::= <lvalueExpression> · AssignmentOperatorToken <pipelineRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<postfixOperatorRule> ::= <lvalueExpression> · PrePostfixOperatorToken EOF $( ( ) @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
Actions
AssignmentOperatorToken Shift 88
PrePostfixOperatorToken Shift 89

LALR State 39
Configuration Lookahead
<addExpressionRule> ::= <multiplyExpressionRule> · EOF $( ( ) @( ] | } AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<addExpressionRule> ::= <multiplyExpressionRule> · AdditionOperatorToken <addExpressionRule> EOF $( ( ) @( ] | } AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
Actions
AdditionOperatorToken Shift 90
(EOF) Reduce Rule 79
'$(' Reduce Rule 79
'(' Reduce Rule 79
')' Reduce Rule 79
'@(' Reduce Rule 79
']' Reduce Rule 79
'|' Reduce Rule 79
'}' Reduce Rule 79
AnyWordToken Reduce Rule 79
AttributeSpecificationToken Reduce Rule 79
BitwiseOperatorToken Reduce Rule 79
break Reduce Rule 79
CommentToken Reduce Rule 79
ComparisonOperatorToken Reduce Rule 79
continue Reduce Rule 79
do Reduce Rule 79
ExecCall Reduce Rule 79
ExpandableStringToken Reduce Rule 79
finally Reduce Rule 79
foreach Reduce Rule 79
if Reduce Rule 79
LogicalOperatorToken Reduce Rule 79
LoopLabelToken Reduce Rule 79
NewLine Reduce Rule 79
NumberToken Reduce Rule 79
return Reduce Rule 79
StringToken Reduce Rule 79
trap Reduce Rule 79
UnaryOperatorToken Reduce Rule 79
VariableToken Reduce Rule 79

LALR State 40
Configuration Lookahead
<statementRule> ::= <pipelineRule> · EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
Actions
(EOF) Reduce Rule 5
'$(' Reduce Rule 5
'(' Reduce Rule 5
')' Reduce Rule 5
'@(' Reduce Rule 5
'}' Reduce Rule 5
AnyWordToken Reduce Rule 5
AttributeSpecificationToken Reduce Rule 5
break Reduce Rule 5
CommentToken Reduce Rule 5
continue Reduce Rule 5
do Reduce Rule 5
ExecCall Reduce Rule 5
ExpandableStringToken Reduce Rule 5
finally Reduce Rule 5
foreach Reduce Rule 5
if Reduce Rule 5
LoopLabelToken Reduce Rule 5
NewLine Reduce Rule 5
NumberToken Reduce Rule 5
return Reduce Rule 5
StringToken Reduce Rule 5
trap Reduce Rule 5
UnaryOperatorToken Reduce Rule 5
VariableToken Reduce Rule 5

LALR State 41
Configuration Lookahead
<arrayLiteralRule> ::= <postfixOperatorRule> · EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<arrayLiteralRule> ::= <postfixOperatorRule> · CommaToken <arrayLiteralRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
Actions
CommaToken Shift 91
(EOF) Reduce Rule 87
'$(' Reduce Rule 87
'(' Reduce Rule 87
')' Reduce Rule 87
'@(' Reduce Rule 87
']' Reduce Rule 87
'|' Reduce Rule 87
'}' Reduce Rule 87
AdditionOperatorToken Reduce Rule 87
AnyWordToken Reduce Rule 87
AttributeSpecificationToken Reduce Rule 87
BitwiseOperatorToken Reduce Rule 87
break Reduce Rule 87
CommentToken Reduce Rule 87
ComparisonOperatorToken Reduce Rule 87
continue Reduce Rule 87
do Reduce Rule 87
ExecCall Reduce Rule 87
ExpandableStringToken Reduce Rule 87
finally Reduce Rule 87
foreach Reduce Rule 87
FormatOperatorToken Reduce Rule 87
if Reduce Rule 87
LogicalOperatorToken Reduce Rule 87
LoopLabelToken Reduce Rule 87
MultiplyOperatorToken Reduce Rule 87
NewLine Reduce Rule 87
NumberToken Reduce Rule 87
RangeOperatorToken Reduce Rule 87
return Reduce Rule 87
StringToken Reduce Rule 87
trap Reduce Rule 87
UnaryOperatorToken Reduce Rule 87
VariableToken Reduce Rule 87

LALR State 42
Configuration Lookahead
<postfixOperatorRule> ::= <propertyOrArrayReferenceRule> · EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
Actions
(EOF) Reduce Rule 90
'$(' Reduce Rule 90
'(' Reduce Rule 90
')' Reduce Rule 90
'@(' Reduce Rule 90
']' Reduce Rule 90
'|' Reduce Rule 90
'}' Reduce Rule 90
AdditionOperatorToken Reduce Rule 90
AnyWordToken Reduce Rule 90
AttributeSpecificationToken Reduce Rule 90
BitwiseOperatorToken Reduce Rule 90
break Reduce Rule 90
CommaToken Reduce Rule 90
CommentToken Reduce Rule 90
ComparisonOperatorToken Reduce Rule 90
continue Reduce Rule 90
do Reduce Rule 90
ExecCall Reduce Rule 90
ExpandableStringToken Reduce Rule 90
finally Reduce Rule 90
foreach Reduce Rule 90
FormatOperatorToken Reduce Rule 90
if Reduce Rule 90
LogicalOperatorToken Reduce Rule 90
LoopLabelToken Reduce Rule 90
MultiplyOperatorToken Reduce Rule 90
NewLine Reduce Rule 90
NumberToken Reduce Rule 90
RangeOperatorToken Reduce Rule 90
return Reduce Rule 90
StringToken Reduce Rule 90
trap Reduce Rule 90
UnaryOperatorToken Reduce Rule 90
VariableToken Reduce Rule 90

LALR State 43
Configuration Lookahead
<formatExpressionRule> ::= <rangeExpressionRule> · EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<formatExpressionRule> ::= <rangeExpressionRule> · FormatOperatorToken <formatExpressionRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
Actions
FormatOperatorToken Shift 92
(EOF) Reduce Rule 83
'$(' Reduce Rule 83
'(' Reduce Rule 83
')' Reduce Rule 83
'@(' Reduce Rule 83
']' Reduce Rule 83
'|' Reduce Rule 83
'}' Reduce Rule 83
AdditionOperatorToken Reduce Rule 83
AnyWordToken Reduce Rule 83
AttributeSpecificationToken Reduce Rule 83
BitwiseOperatorToken Reduce Rule 83
break Reduce Rule 83
CommentToken Reduce Rule 83
ComparisonOperatorToken Reduce Rule 83
continue Reduce Rule 83
do Reduce Rule 83
ExecCall Reduce Rule 83
ExpandableStringToken Reduce Rule 83
finally Reduce Rule 83
foreach Reduce Rule 83
if Reduce Rule 83
LogicalOperatorToken Reduce Rule 83
LoopLabelToken Reduce Rule 83
MultiplyOperatorToken Reduce Rule 83
NewLine Reduce Rule 83
NumberToken Reduce Rule 83
return Reduce Rule 83
StringToken Reduce Rule 83
trap Reduce Rule 83
UnaryOperatorToken Reduce Rule 83
VariableToken Reduce Rule 83

LALR State 44
Configuration Lookahead
<S'> ::= <statementListRule> · (EOF)  
Actions
(EOF) Accept

LALR State 45
Configuration Lookahead
<statementListRule> ::= <statementRule> · EOF ) }
<statementListRule> ::= <statementRule> · <statementSeparatorToken> <statementListRule> EOF ) }
<statementSeparatorToken> ::= · NewLine <statementSeparatorToken> $( ( @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NumberToken return StringToken trap UnaryOperatorToken VariableToken
<statementSeparatorToken> ::= · $( ( @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NumberToken return StringToken trap UnaryOperatorToken VariableToken
Actions
NewLine Shift 93
<statementSeparatorToken> Goto 94
(EOF) Reduce Rule 2
')' Reduce Rule 2
'}' Reduce Rule 2
'$(' Reduce Rule 1
'(' Reduce Rule 1
'@(' Reduce Rule 1
AnyWordToken Reduce Rule 1
AttributeSpecificationToken Reduce Rule 1
break Reduce Rule 1
CommentToken Reduce Rule 1
continue Reduce Rule 1
do Reduce Rule 1
ExecCall Reduce Rule 1
ExpandableStringToken Reduce Rule 1
finally Reduce Rule 1
foreach Reduce Rule 1
if Reduce Rule 1
LoopLabelToken Reduce Rule 1
NumberToken Reduce Rule 1
return Reduce Rule 1
StringToken Reduce Rule 1
trap Reduce Rule 1
UnaryOperatorToken Reduce Rule 1
VariableToken Reduce Rule 1

LALR State 46
Configuration Lookahead
<statementRule> ::= <trapStatementRule> · EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
Actions
(EOF) Reduce Rule 11
'$(' Reduce Rule 11
'(' Reduce Rule 11
')' Reduce Rule 11
'@(' Reduce Rule 11
'}' Reduce Rule 11
AnyWordToken Reduce Rule 11
AttributeSpecificationToken Reduce Rule 11
break Reduce Rule 11
CommentToken Reduce Rule 11
continue Reduce Rule 11
do Reduce Rule 11
ExecCall Reduce Rule 11
ExpandableStringToken Reduce Rule 11
finally Reduce Rule 11
foreach Reduce Rule 11
if Reduce Rule 11
LoopLabelToken Reduce Rule 11
NewLine Reduce Rule 11
NumberToken Reduce Rule 11
return Reduce Rule 11
StringToken Reduce Rule 11
trap Reduce Rule 11
UnaryOperatorToken Reduce Rule 11
VariableToken Reduce Rule 11

LALR State 47
Notes
WARNING: A SHIFT-REDUCE CONFLICT WAS FIXED: '['
Configuration Lookahead
<propertyOrArrayReferenceRule> ::= <valueRule> · EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<propertyOrArrayReferenceRule> ::= <valueRule> · <propertyOrArrayReferenceOperatorList> EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<propertyOrArrayReferenceOperatorList> ::= · <propertyOrArrayReferenceOperator> EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<propertyOrArrayReferenceOperatorList> ::= · <propertyOrArrayReferenceOperatorList> <propertyOrArrayReferenceOperator> EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<propertyOrArrayReferenceOperator> ::= · '[' <expressionRule> ']' ReferenceOperatorToken AnyWordToken EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<propertyOrArrayReferenceOperator> ::= · '[' <expressionRule> ']' ReferenceOperatorToken AnyWordToken <parseCallRule> EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<propertyOrArrayReferenceOperator> ::= · '[' <expressionRule> ']' <valueRule> EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
Actions
'[' Shift 73
<propertyOrArrayReferenceOperator> Goto 74
<propertyOrArrayReferenceOperatorList> Goto 95
(EOF) Reduce Rule 91
'$(' Reduce Rule 91
'(' Reduce Rule 91
')' Reduce Rule 91
'@(' Reduce Rule 91
']' Reduce Rule 91
'|' Reduce Rule 91
'}' Reduce Rule 91
AdditionOperatorToken Reduce Rule 91
AnyWordToken Reduce Rule 91
AssignmentOperatorToken Reduce Rule 91
AttributeSpecificationToken Reduce Rule 91
BitwiseOperatorToken Reduce Rule 91
break Reduce Rule 91
CommaToken Reduce Rule 91
CommentToken Reduce Rule 91
ComparisonOperatorToken Reduce Rule 91
continue Reduce Rule 91
do Reduce Rule 91
ExecCall Reduce Rule 91
ExpandableStringToken Reduce Rule 91
finally Reduce Rule 91
foreach Reduce Rule 91
FormatOperatorToken Reduce Rule 91
if Reduce Rule 91
LogicalOperatorToken Reduce Rule 91
LoopLabelToken Reduce Rule 91
MultiplyOperatorToken Reduce Rule 91
NewLine Reduce Rule 91
NumberToken Reduce Rule 91
ParameterToken Reduce Rule 91
PrePostfixOperatorToken Reduce Rule 91
RangeOperatorToken Reduce Rule 91
return Reduce Rule 91
StringToken Reduce Rule 91
trap Reduce Rule 91
UnaryOperatorToken Reduce Rule 91
VariableToken Reduce Rule 91

LALR State 48
Configuration Lookahead
<valueRule> ::= '$(' <statementListRule> · ')' EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
Actions
')' Shift 96

LALR State 49
Configuration Lookahead
<lvalue> ::= AttributeSpecificationToken · VariableToken AssignmentOperatorToken
<lvalue> ::= AttributeSpecificationToken · VariableToken <propertyOrArrayReferenceOperatorList> AssignmentOperatorToken
Actions
VariableToken Shift 97

LALR State 50
Configuration Lookahead
<lvalue> ::= VariableToken · AssignmentOperatorToken
<lvalue> ::= VariableToken · <propertyOrArrayReferenceOperatorList> AssignmentOperatorToken
<propertyOrArrayReferenceOperatorList> ::= · <propertyOrArrayReferenceOperator> [ AssignmentOperatorToken
<propertyOrArrayReferenceOperatorList> ::= · <propertyOrArrayReferenceOperatorList> <propertyOrArrayReferenceOperator> [ AssignmentOperatorToken
<propertyOrArrayReferenceOperator> ::= · '[' <expressionRule> ']' ReferenceOperatorToken AnyWordToken [ AssignmentOperatorToken
<propertyOrArrayReferenceOperator> ::= · '[' <expressionRule> ']' ReferenceOperatorToken AnyWordToken <parseCallRule> [ AssignmentOperatorToken
<propertyOrArrayReferenceOperator> ::= · '[' <expressionRule> ']' <valueRule> [ AssignmentOperatorToken
Actions
'[' Shift 73
<propertyOrArrayReferenceOperator> Goto 74
<propertyOrArrayReferenceOperatorList> Goto 75
AssignmentOperatorToken Reduce Rule 21

LALR State 51
Configuration Lookahead
<valueRule> ::= '(' <assignmentStatementRule> · ')' EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
Actions
')' Shift 98

LALR State 52
Configuration Lookahead
<assignmentStatementRule> ::= <lvalueExpression> · AssignmentOperatorToken <pipelineRule> )
Actions
AssignmentOperatorToken Shift 88

LALR State 53
Configuration Lookahead
<valueRule> ::= '@(' <statementListRule> · ')' EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
Actions
')' Shift 99

LALR State 54
Notes
WARNING: A SHIFT-REDUCE CONFLICT WAS FIXED: '$(', '(', '@(', AttributeSpecificationToken, ExpandableStringToken, NumberToken, StringToken, UnaryOperatorToken, VariableToken
Configuration Lookahead
<valueRule> ::= AttributeSpecificationToken · <propertyOrArrayReferenceRule> EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= AttributeSpecificationToken · EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<propertyOrArrayReferenceRule> ::= · <valueRule> EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<propertyOrArrayReferenceRule> ::= · <valueRule> <propertyOrArrayReferenceOperatorList> EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '(' <assignmentStatementRule> ')' EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '$(' <statementListRule> ')' EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '@(' <statementListRule> ')' EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · UnaryOperatorToken <propertyOrArrayReferenceRule> EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · AttributeSpecificationToken <propertyOrArrayReferenceRule> EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · AttributeSpecificationToken EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · NumberToken EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · StringToken EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · ExpandableStringToken EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · VariableToken EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
Actions
'$(' Shift 1
'(' Shift 2
'@(' Shift 3
AttributeSpecificationToken Shift 54
ExpandableStringToken Shift 11
NumberToken Shift 16
StringToken Shift 18
UnaryOperatorToken Shift 20
VariableToken Shift 57
<propertyOrArrayReferenceRule> Goto 56
<valueRule> Goto 47
(EOF) Reduce Rule 102
')' Reduce Rule 102
'[' Reduce Rule 102
']' Reduce Rule 102
'|' Reduce Rule 102
'}' Reduce Rule 102
AdditionOperatorToken Reduce Rule 102
AnyWordToken Reduce Rule 102
AssignmentOperatorToken Reduce Rule 102
BitwiseOperatorToken Reduce Rule 102
break Reduce Rule 102
CommaToken Reduce Rule 102
CommentToken Reduce Rule 102
ComparisonOperatorToken Reduce Rule 102
continue Reduce Rule 102
do Reduce Rule 102
ExecCall Reduce Rule 102
finally Reduce Rule 102
foreach Reduce Rule 102
FormatOperatorToken Reduce Rule 102
if Reduce Rule 102
LogicalOperatorToken Reduce Rule 102
LoopLabelToken Reduce Rule 102
MultiplyOperatorToken Reduce Rule 102
NewLine Reduce Rule 102
ParameterToken Reduce Rule 102
PrePostfixOperatorToken Reduce Rule 102
RangeOperatorToken Reduce Rule 102
return Reduce Rule 102
trap Reduce Rule 102

LALR State 55
Notes
WARNING: A SHIFT-REDUCE CONFLICT WAS FIXED: '['
Configuration Lookahead
<lvalue> ::= AttributeSpecificationToken VariableToken · AssignmentOperatorToken PrePostfixOperatorToken
<lvalue> ::= AttributeSpecificationToken VariableToken · <propertyOrArrayReferenceOperatorList> AssignmentOperatorToken PrePostfixOperatorToken
<valueRule> ::= VariableToken · EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<propertyOrArrayReferenceOperatorList> ::= · <propertyOrArrayReferenceOperator> [ AssignmentOperatorToken PrePostfixOperatorToken
<propertyOrArrayReferenceOperatorList> ::= · <propertyOrArrayReferenceOperatorList> <propertyOrArrayReferenceOperator> [ AssignmentOperatorToken PrePostfixOperatorToken
<propertyOrArrayReferenceOperator> ::= · '[' <expressionRule> ']' ReferenceOperatorToken AnyWordToken [ AssignmentOperatorToken PrePostfixOperatorToken
<propertyOrArrayReferenceOperator> ::= · '[' <expressionRule> ']' ReferenceOperatorToken AnyWordToken <parseCallRule> [ AssignmentOperatorToken PrePostfixOperatorToken
<propertyOrArrayReferenceOperator> ::= · '[' <expressionRule> ']' <valueRule> [ AssignmentOperatorToken PrePostfixOperatorToken
Actions
'[' Shift 73
<propertyOrArrayReferenceOperator> Goto 74
<propertyOrArrayReferenceOperatorList> Goto 100
AssignmentOperatorToken Reduce Rule 22
PrePostfixOperatorToken Reduce Rule 22
(EOF) Reduce Rule 106
'$(' Reduce Rule 106
'(' Reduce Rule 106
')' Reduce Rule 106
'@(' Reduce Rule 106
']' Reduce Rule 106
'|' Reduce Rule 106
'}' Reduce Rule 106
AdditionOperatorToken Reduce Rule 106
AnyWordToken Reduce Rule 106
AttributeSpecificationToken Reduce Rule 106
BitwiseOperatorToken Reduce Rule 106
break Reduce Rule 106
CommaToken Reduce Rule 106
CommentToken Reduce Rule 106
ComparisonOperatorToken Reduce Rule 106
continue Reduce Rule 106
do Reduce Rule 106
ExecCall Reduce Rule 106
ExpandableStringToken Reduce Rule 106
finally Reduce Rule 106
foreach Reduce Rule 106
FormatOperatorToken Reduce Rule 106
if Reduce Rule 106
LogicalOperatorToken Reduce Rule 106
LoopLabelToken Reduce Rule 106
MultiplyOperatorToken Reduce Rule 106
NewLine Reduce Rule 106
NumberToken Reduce Rule 106
RangeOperatorToken Reduce Rule 106
return Reduce Rule 106
StringToken Reduce Rule 106
trap Reduce Rule 106
UnaryOperatorToken Reduce Rule 106
VariableToken Reduce Rule 106

LALR State 56
Configuration Lookahead
<valueRule> ::= AttributeSpecificationToken <propertyOrArrayReferenceRule> · EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
Actions
(EOF) Reduce Rule 101
'$(' Reduce Rule 101
'(' Reduce Rule 101
')' Reduce Rule 101
'@(' Reduce Rule 101
'[' Reduce Rule 101
']' Reduce Rule 101
'|' Reduce Rule 101
'}' Reduce Rule 101
AdditionOperatorToken Reduce Rule 101
AnyWordToken Reduce Rule 101
AssignmentOperatorToken Reduce Rule 101
AttributeSpecificationToken Reduce Rule 101
BitwiseOperatorToken Reduce Rule 101
break Reduce Rule 101
CommaToken Reduce Rule 101
CommentToken Reduce Rule 101
ComparisonOperatorToken Reduce Rule 101
continue Reduce Rule 101
do Reduce Rule 101
ExecCall Reduce Rule 101
ExpandableStringToken Reduce Rule 101
finally Reduce Rule 101
foreach Reduce Rule 101
FormatOperatorToken Reduce Rule 101
if Reduce Rule 101
LogicalOperatorToken Reduce Rule 101
LoopLabelToken Reduce Rule 101
MultiplyOperatorToken Reduce Rule 101
NewLine Reduce Rule 101
NumberToken Reduce Rule 101
ParameterToken Reduce Rule 101
PrePostfixOperatorToken Reduce Rule 101
RangeOperatorToken Reduce Rule 101
return Reduce Rule 101
StringToken Reduce Rule 101
trap Reduce Rule 101
UnaryOperatorToken Reduce Rule 101
VariableToken Reduce Rule 101

LALR State 57
Configuration Lookahead
<valueRule> ::= VariableToken · EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
Actions
(EOF) Reduce Rule 106
'$(' Reduce Rule 106
'(' Reduce Rule 106
')' Reduce Rule 106
'@(' Reduce Rule 106
'[' Reduce Rule 106
']' Reduce Rule 106
'|' Reduce Rule 106
'}' Reduce Rule 106
AdditionOperatorToken Reduce Rule 106
AnyWordToken Reduce Rule 106
AssignmentOperatorToken Reduce Rule 106
AttributeSpecificationToken Reduce Rule 106
BitwiseOperatorToken Reduce Rule 106
break Reduce Rule 106
CommaToken Reduce Rule 106
CommentToken Reduce Rule 106
ComparisonOperatorToken Reduce Rule 106
continue Reduce Rule 106
do Reduce Rule 106
ExecCall Reduce Rule 106
ExpandableStringToken Reduce Rule 106
finally Reduce Rule 106
foreach Reduce Rule 106
FormatOperatorToken Reduce Rule 106
if Reduce Rule 106
LogicalOperatorToken Reduce Rule 106
LoopLabelToken Reduce Rule 106
MultiplyOperatorToken Reduce Rule 106
NewLine Reduce Rule 106
NumberToken Reduce Rule 106
ParameterToken Reduce Rule 106
PrePostfixOperatorToken Reduce Rule 106
RangeOperatorToken Reduce Rule 106
return Reduce Rule 106
StringToken Reduce Rule 106
trap Reduce Rule 106
UnaryOperatorToken Reduce Rule 106
VariableToken Reduce Rule 106

LALR State 58
Configuration Lookahead
<flowControlStatementRule> ::= break <flowControlPropertyBody> · EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
Actions
(EOF) Reduce Rule 69
'$(' Reduce Rule 69
'(' Reduce Rule 69
')' Reduce Rule 69
'@(' Reduce Rule 69
'}' Reduce Rule 69
AnyWordToken Reduce Rule 69
AttributeSpecificationToken Reduce Rule 69
break Reduce Rule 69
CommentToken Reduce Rule 69
continue Reduce Rule 69
do Reduce Rule 69
ExecCall Reduce Rule 69
ExpandableStringToken Reduce Rule 69
finally Reduce Rule 69
foreach Reduce Rule 69
if Reduce Rule 69
LoopLabelToken Reduce Rule 69
NewLine Reduce Rule 69
NumberToken Reduce Rule 69
return Reduce Rule 69
StringToken Reduce Rule 69
trap Reduce Rule 69
UnaryOperatorToken Reduce Rule 69
VariableToken Reduce Rule 69

LALR State 59
Configuration Lookahead
<flowControlPropertyBody> ::= <propertyOrArrayReferenceRule> · EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
Actions
(EOF) Reduce Rule 66
'$(' Reduce Rule 66
'(' Reduce Rule 66
')' Reduce Rule 66
'@(' Reduce Rule 66
'}' Reduce Rule 66
AnyWordToken Reduce Rule 66
AttributeSpecificationToken Reduce Rule 66
break Reduce Rule 66
CommentToken Reduce Rule 66
continue Reduce Rule 66
do Reduce Rule 66
ExecCall Reduce Rule 66
ExpandableStringToken Reduce Rule 66
finally Reduce Rule 66
foreach Reduce Rule 66
if Reduce Rule 66
LoopLabelToken Reduce Rule 66
NewLine Reduce Rule 66
NumberToken Reduce Rule 66
return Reduce Rule 66
StringToken Reduce Rule 66
trap Reduce Rule 66
UnaryOperatorToken Reduce Rule 66
VariableToken Reduce Rule 66

LALR State 60
Configuration Lookahead
<flowControlStatementRule> ::= continue <flowControlPropertyBody> · EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
Actions
(EOF) Reduce Rule 70
'$(' Reduce Rule 70
'(' Reduce Rule 70
')' Reduce Rule 70
'@(' Reduce Rule 70
'}' Reduce Rule 70
AnyWordToken Reduce Rule 70
AttributeSpecificationToken Reduce Rule 70
break Reduce Rule 70
CommentToken Reduce Rule 70
continue Reduce Rule 70
do Reduce Rule 70
ExecCall Reduce Rule 70
ExpandableStringToken Reduce Rule 70
finally Reduce Rule 70
foreach Reduce Rule 70
if Reduce Rule 70
LoopLabelToken Reduce Rule 70
NewLine Reduce Rule 70
NumberToken Reduce Rule 70
return Reduce Rule 70
StringToken Reduce Rule 70
trap Reduce Rule 70
UnaryOperatorToken Reduce Rule 70
VariableToken Reduce Rule 70

LALR State 61
Configuration Lookahead
<statementBlockRule> ::= '{' · <statementListRule> '}' EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do else elseif ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken until VariableToken while
<statementListRule> ::= · <statementRule> }
<statementListRule> ::= · <statementRule> <statementSeparatorToken> <statementListRule> }
<statementRule> ::= · <pipelineRule> $( ( @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<statementRule> ::= · CommentToken $( ( @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<statementRule> ::= · <ifStatementRule> $( ( @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<statementRule> ::= · <foreachStatementRule> $( ( @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<statementRule> ::= · <doWhileStatementRule> $( ( @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<statementRule> ::= · <flowControlStatementRule> $( ( @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<statementRule> ::= · <trapStatementRule> $( ( @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<statementRule> ::= · <finallyStatementRule> $( ( @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<pipelineRule> ::= · <cmdletCall> $( ( @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<pipelineRule> ::= · <cmdletCall> '|' <pipelineRule> $( ( @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<pipelineRule> ::= · <assignmentStatementRule> $( ( @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<pipelineRule> ::= · <assignmentStatementRule> '|' <pipelineRule> $( ( @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<assignmentStatementRule> ::= · <lvalueExpression> AssignmentOperatorToken <pipelineRule> $( ( @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<lvalueExpression> ::= · <lvalue> AssignmentOperatorToken PrePostfixOperatorToken
<lvalue> ::= · VariableToken AssignmentOperatorToken PrePostfixOperatorToken
<lvalue> ::= · AttributeSpecificationToken VariableToken AssignmentOperatorToken PrePostfixOperatorToken
<lvalue> ::= · VariableToken <propertyOrArrayReferenceOperatorList> AssignmentOperatorToken PrePostfixOperatorToken
<lvalue> ::= · AttributeSpecificationToken VariableToken <propertyOrArrayReferenceOperatorList> AssignmentOperatorToken PrePostfixOperatorToken
<cmdletName> ::= · AnyWordToken $( ( @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
<cmdletCall> ::= · ExecCall <cmdletName> <cmletParamsList> $( ( @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<cmdletCall> ::= · ExecCall <cmdletName> $( ( @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<cmdletCall> ::= · <cmdletName> <cmletParamsList> $( ( @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<cmdletCall> ::= · <cmdletName> $( ( @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<cmdletCall> ::= · <expressionRule> $( ( @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<ifStatementRule> ::= · if '(' <pipelineRule> ')' <statementBlockRule> $( ( @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<ifStatementRule> ::= · if '(' <pipelineRule> ')' <statementBlockRule> <elseIfBlockRule> $( ( @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<ifStatementRule> ::= · if '(' <pipelineRule> ')' <statementBlockRule> else <statementBlockRule> $( ( @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<ifStatementRule> ::= · if '(' <pipelineRule> ')' <statementBlockRule> <elseIfBlockRule> else <statementBlockRule> $( ( @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<foreachStatementRule> ::= · foreach '(' VariableToken in <pipelineRule> ')' <statementBlockRule> $( ( @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<foreachStatementRule> ::= · LoopLabelToken foreach '(' VariableToken in <pipelineRule> ')' <statementBlockRule> $( ( @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<doWhileStatementRule> ::= · do <statementBlockRule> while '(' <pipelineRule> ')' $( ( @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<doWhileStatementRule> ::= · do <statementBlockRule> until '(' <pipelineRule> ')' $( ( @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<doWhileStatementRule> ::= · LoopLabelToken do <statementBlockRule> while '(' <pipelineRule> ')' $( ( @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<doWhileStatementRule> ::= · LoopLabelToken do <statementBlockRule> until '(' <pipelineRule> ')' $( ( @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<trapStatementRule> ::= · trap <statementBlockRule> $( ( @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<trapStatementRule> ::= · trap AttributeSpecificationToken <statementBlockRule> $( ( @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<finallyStatementRule> ::= · finally <statementBlockRule> $( ( @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<flowControlStatementRule> ::= · break $( ( @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<flowControlStatementRule> ::= · continue $( ( @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<flowControlStatementRule> ::= · break <flowControlPropertyBody> $( ( @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<flowControlStatementRule> ::= · continue <flowControlPropertyBody> $( ( @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<flowControlStatementRule> ::= · return <pipelineRule> $( ( @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<expressionRule> ::= · <logicalExpressionRule> $( ( @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<logicalExpressionRule> ::= · <bitwiseExpressionRule> $( ( @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<logicalExpressionRule> ::= · <bitwiseExpressionRule> LogicalOperatorToken <logicalExpressionRule> $( ( @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<bitwiseExpressionRule> ::= · <comparisonExpressionRule> $( ( @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<bitwiseExpressionRule> ::= · <comparisonExpressionRule> BitwiseOperatorToken <bitwiseExpressionRule> $( ( @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<comparisonExpressionRule> ::= · <addExpressionRule> $( ( @( | } AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<comparisonExpressionRule> ::= · <addExpressionRule> ComparisonOperatorToken <comparisonExpressionRule> $( ( @( | } AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<addExpressionRule> ::= · <multiplyExpressionRule> $( ( @( | } AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<addExpressionRule> ::= · <multiplyExpressionRule> AdditionOperatorToken <addExpressionRule> $( ( @( | } AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<multiplyExpressionRule> ::= · <formatExpressionRule> $( ( @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<multiplyExpressionRule> ::= · <formatExpressionRule> MultiplyOperatorToken <multiplyExpressionRule> $( ( @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<formatExpressionRule> ::= · <rangeExpressionRule> $( ( @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<formatExpressionRule> ::= · <rangeExpressionRule> FormatOperatorToken <formatExpressionRule> $( ( @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<rangeExpressionRule> ::= · <arrayLiteralRule> $( ( @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<rangeExpressionRule> ::= · <arrayLiteralRule> RangeOperatorToken <rangeExpressionRule> $( ( @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<arrayLiteralRule> ::= · <postfixOperatorRule> $( ( @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<arrayLiteralRule> ::= · <postfixOperatorRule> CommaToken <arrayLiteralRule> $( ( @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<postfixOperatorRule> ::= · <lvalueExpression> PrePostfixOperatorToken $( ( @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<postfixOperatorRule> ::= · <propertyOrArrayReferenceRule> $( ( @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<propertyOrArrayReferenceRule> ::= · <valueRule> $( ( @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<propertyOrArrayReferenceRule> ::= · <valueRule> <propertyOrArrayReferenceOperatorList> $( ( @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '(' <assignmentStatementRule> ')' $( ( @( [ | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '$(' <statementListRule> ')' $( ( @( [ | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '@(' <statementListRule> ')' $( ( @( [ | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · UnaryOperatorToken <propertyOrArrayReferenceRule> $( ( @( [ | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · AttributeSpecificationToken <propertyOrArrayReferenceRule> $( ( @( [ | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · AttributeSpecificationToken $( ( @( [ | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · NumberToken $( ( @( [ | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · StringToken $( ( @( [ | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · ExpandableStringToken $( ( @( [ | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · VariableToken $( ( @( [ | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
Actions
'$(' Shift 1
'(' Shift 2
'@(' Shift 3
AnyWordToken Shift 4
AttributeSpecificationToken Shift 5
break Shift 6
CommentToken Shift 7
continue Shift 8
do Shift 9
ExecCall Shift 10
ExpandableStringToken Shift 11
finally Shift 12
foreach Shift 13
if Shift 14
LoopLabelToken Shift 15
NumberToken Shift 16
return Shift 17
StringToken Shift 18
trap Shift 19
UnaryOperatorToken Shift 20
VariableToken Shift 21
<addExpressionRule> Goto 22
<arrayLiteralRule> Goto 23
<assignmentStatementRule> Goto 24
<bitwiseExpressionRule> Goto 25
<cmdletCall> Goto 26
<cmdletName> Goto 27
<comparisonExpressionRule> Goto 28
<doWhileStatementRule> Goto 29
<expressionRule> Goto 30
<finallyStatementRule> Goto 31
<flowControlStatementRule> Goto 32
<foreachStatementRule> Goto 33
<formatExpressionRule> Goto 34
<ifStatementRule> Goto 35
<logicalExpressionRule> Goto 36
<lvalue> Goto 37
<lvalueExpression> Goto 38
<multiplyExpressionRule> Goto 39
<pipelineRule> Goto 40
<postfixOperatorRule> Goto 41
<propertyOrArrayReferenceRule> Goto 42
<rangeExpressionRule> Goto 43
<statementListRule> Goto 101
<statementRule> Goto 45
<trapStatementRule> Goto 46
<valueRule> Goto 47

LALR State 62
Configuration Lookahead
<doWhileStatementRule> ::= do <statementBlockRule> · while '(' <pipelineRule> ')' EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<doWhileStatementRule> ::= do <statementBlockRule> · until '(' <pipelineRule> ')' EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
Actions
until Shift 102
while Shift 103

LALR State 63
Notes
WARNING: A SHIFT-REDUCE CONFLICT WAS FIXED: '$(', '(', '@(', AnyWordToken, AttributeSpecificationToken, ExpandableStringToken, NumberToken, StringToken, UnaryOperatorToken, VariableToken
Configuration Lookahead
<cmdletCall> ::= ExecCall <cmdletName> · <cmletParamsList> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<cmdletCall> ::= ExecCall <cmdletName> · EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<ParameterArgumentToken> ::= · <valueRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
<ParameterArgumentToken> ::= · AnyWordToken EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
<ParameterArgumentToken> ::= · ParameterToken EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
<cmletParamsList> ::= · <ParameterArgumentToken> <cmletParamsList> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<cmletParamsList> ::= · <ParameterArgumentToken> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '(' <assignmentStatementRule> ')' EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '$(' <statementListRule> ')' EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '@(' <statementListRule> ')' EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · UnaryOperatorToken <propertyOrArrayReferenceRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · AttributeSpecificationToken <propertyOrArrayReferenceRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · AttributeSpecificationToken EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · NumberToken EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · StringToken EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · ExpandableStringToken EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · VariableToken EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
Actions
'$(' Shift 1
'(' Shift 2
'@(' Shift 3
AnyWordToken Shift 81
AttributeSpecificationToken Shift 54
ExpandableStringToken Shift 11
NumberToken Shift 16
ParameterToken Shift 82
StringToken Shift 18
UnaryOperatorToken Shift 20
VariableToken Shift 57
<cmletParamsList> Goto 104
<ParameterArgumentToken> Goto 84
<valueRule> Goto 85
(EOF) Reduce Rule 32
')' Reduce Rule 32
'|' Reduce Rule 32
'}' Reduce Rule 32
break Reduce Rule 32
CommentToken Reduce Rule 32
continue Reduce Rule 32
do Reduce Rule 32
ExecCall Reduce Rule 32
finally Reduce Rule 32
foreach Reduce Rule 32
if Reduce Rule 32
LoopLabelToken Reduce Rule 32
NewLine Reduce Rule 32
return Reduce Rule 32
trap Reduce Rule 32

LALR State 64
Configuration Lookahead
<finallyStatementRule> ::= finally <statementBlockRule> · EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
Actions
(EOF) Reduce Rule 65
'$(' Reduce Rule 65
'(' Reduce Rule 65
')' Reduce Rule 65
'@(' Reduce Rule 65
'}' Reduce Rule 65
AnyWordToken Reduce Rule 65
AttributeSpecificationToken Reduce Rule 65
break Reduce Rule 65
CommentToken Reduce Rule 65
continue Reduce Rule 65
do Reduce Rule 65
ExecCall Reduce Rule 65
ExpandableStringToken Reduce Rule 65
finally Reduce Rule 65
foreach Reduce Rule 65
if Reduce Rule 65
LoopLabelToken Reduce Rule 65
NewLine Reduce Rule 65
NumberToken Reduce Rule 65
return Reduce Rule 65
StringToken Reduce Rule 65
trap Reduce Rule 65
UnaryOperatorToken Reduce Rule 65
VariableToken Reduce Rule 65

LALR State 65
Configuration Lookahead
<foreachStatementRule> ::= foreach '(' · VariableToken in <pipelineRule> ')' <statementBlockRule> EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
Actions
VariableToken Shift 105

LALR State 66
Configuration Lookahead
<ifStatementRule> ::= if '(' · <pipelineRule> ')' <statementBlockRule> EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<ifStatementRule> ::= if '(' · <pipelineRule> ')' <statementBlockRule> <elseIfBlockRule> EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<ifStatementRule> ::= if '(' · <pipelineRule> ')' <statementBlockRule> else <statementBlockRule> EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<ifStatementRule> ::= if '(' · <pipelineRule> ')' <statementBlockRule> <elseIfBlockRule> else <statementBlockRule> EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<pipelineRule> ::= · <cmdletCall> )
<pipelineRule> ::= · <cmdletCall> '|' <pipelineRule> )
<pipelineRule> ::= · <assignmentStatementRule> )
<pipelineRule> ::= · <assignmentStatementRule> '|' <pipelineRule> )
<assignmentStatementRule> ::= · <lvalueExpression> AssignmentOperatorToken <pipelineRule> ) |
<lvalueExpression> ::= · <lvalue> AssignmentOperatorToken PrePostfixOperatorToken
<lvalue> ::= · VariableToken AssignmentOperatorToken PrePostfixOperatorToken
<lvalue> ::= · AttributeSpecificationToken VariableToken AssignmentOperatorToken PrePostfixOperatorToken
<lvalue> ::= · VariableToken <propertyOrArrayReferenceOperatorList> AssignmentOperatorToken PrePostfixOperatorToken
<lvalue> ::= · AttributeSpecificationToken VariableToken <propertyOrArrayReferenceOperatorList> AssignmentOperatorToken PrePostfixOperatorToken
<cmdletName> ::= · AnyWordToken $( ( ) @( | AnyWordToken AttributeSpecificationToken ExpandableStringToken NumberToken ParameterToken StringToken UnaryOperatorToken VariableToken
<cmdletCall> ::= · ExecCall <cmdletName> <cmletParamsList> ) |
<cmdletCall> ::= · ExecCall <cmdletName> ) |
<cmdletCall> ::= · <cmdletName> <cmletParamsList> ) |
<cmdletCall> ::= · <cmdletName> ) |
<cmdletCall> ::= · <expressionRule> ) |
<expressionRule> ::= · <logicalExpressionRule> ) |
<logicalExpressionRule> ::= · <bitwiseExpressionRule> ) |
<logicalExpressionRule> ::= · <bitwiseExpressionRule> LogicalOperatorToken <logicalExpressionRule> ) |
<bitwiseExpressionRule> ::= · <comparisonExpressionRule> ) | LogicalOperatorToken
<bitwiseExpressionRule> ::= · <comparisonExpressionRule> BitwiseOperatorToken <bitwiseExpressionRule> ) | LogicalOperatorToken
<comparisonExpressionRule> ::= · <addExpressionRule> ) | BitwiseOperatorToken LogicalOperatorToken
<comparisonExpressionRule> ::= · <addExpressionRule> ComparisonOperatorToken <comparisonExpressionRule> ) | BitwiseOperatorToken LogicalOperatorToken
<addExpressionRule> ::= · <multiplyExpressionRule> ) | BitwiseOperatorToken ComparisonOperatorToken LogicalOperatorToken
<addExpressionRule> ::= · <multiplyExpressionRule> AdditionOperatorToken <addExpressionRule> ) | BitwiseOperatorToken ComparisonOperatorToken LogicalOperatorToken
<multiplyExpressionRule> ::= · <formatExpressionRule> ) | AdditionOperatorToken BitwiseOperatorToken ComparisonOperatorToken LogicalOperatorToken
<multiplyExpressionRule> ::= · <formatExpressionRule> MultiplyOperatorToken <multiplyExpressionRule> ) | AdditionOperatorToken BitwiseOperatorToken ComparisonOperatorToken LogicalOperatorToken
<formatExpressionRule> ::= · <rangeExpressionRule> ) | AdditionOperatorToken BitwiseOperatorToken ComparisonOperatorToken LogicalOperatorToken MultiplyOperatorToken
<formatExpressionRule> ::= · <rangeExpressionRule> FormatOperatorToken <formatExpressionRule> ) | AdditionOperatorToken BitwiseOperatorToken ComparisonOperatorToken LogicalOperatorToken MultiplyOperatorToken
<rangeExpressionRule> ::= · <arrayLiteralRule> ) | AdditionOperatorToken BitwiseOperatorToken ComparisonOperatorToken FormatOperatorToken LogicalOperatorToken MultiplyOperatorToken
<rangeExpressionRule> ::= · <arrayLiteralRule> RangeOperatorToken <rangeExpressionRule> ) | AdditionOperatorToken BitwiseOperatorToken ComparisonOperatorToken FormatOperatorToken LogicalOperatorToken MultiplyOperatorToken
<arrayLiteralRule> ::= · <postfixOperatorRule> ) | AdditionOperatorToken BitwiseOperatorToken ComparisonOperatorToken FormatOperatorToken LogicalOperatorToken MultiplyOperatorToken RangeOperatorToken
<arrayLiteralRule> ::= · <postfixOperatorRule> CommaToken <arrayLiteralRule> ) | AdditionOperatorToken BitwiseOperatorToken ComparisonOperatorToken FormatOperatorToken LogicalOperatorToken MultiplyOperatorToken RangeOperatorToken
<postfixOperatorRule> ::= · <lvalueExpression> PrePostfixOperatorToken ) | AdditionOperatorToken BitwiseOperatorToken CommaToken ComparisonOperatorToken FormatOperatorToken LogicalOperatorToken MultiplyOperatorToken RangeOperatorToken
<postfixOperatorRule> ::= · <propertyOrArrayReferenceRule> ) | AdditionOperatorToken BitwiseOperatorToken CommaToken ComparisonOperatorToken FormatOperatorToken LogicalOperatorToken MultiplyOperatorToken RangeOperatorToken
<propertyOrArrayReferenceRule> ::= · <valueRule> ) | AdditionOperatorToken BitwiseOperatorToken CommaToken ComparisonOperatorToken FormatOperatorToken LogicalOperatorToken MultiplyOperatorToken RangeOperatorToken
<propertyOrArrayReferenceRule> ::= · <valueRule> <propertyOrArrayReferenceOperatorList> ) | AdditionOperatorToken BitwiseOperatorToken CommaToken ComparisonOperatorToken FormatOperatorToken LogicalOperatorToken MultiplyOperatorToken RangeOperatorToken
<valueRule> ::= · '(' <assignmentStatementRule> ')' ) [ | AdditionOperatorToken BitwiseOperatorToken CommaToken ComparisonOperatorToken FormatOperatorToken LogicalOperatorToken MultiplyOperatorToken RangeOperatorToken
<valueRule> ::= · '$(' <statementListRule> ')' ) [ | AdditionOperatorToken BitwiseOperatorToken CommaToken ComparisonOperatorToken FormatOperatorToken LogicalOperatorToken MultiplyOperatorToken RangeOperatorToken
<valueRule> ::= · '@(' <statementListRule> ')' ) [ | AdditionOperatorToken BitwiseOperatorToken CommaToken ComparisonOperatorToken FormatOperatorToken LogicalOperatorToken MultiplyOperatorToken RangeOperatorToken
<valueRule> ::= · UnaryOperatorToken <propertyOrArrayReferenceRule> ) [ | AdditionOperatorToken BitwiseOperatorToken CommaToken ComparisonOperatorToken FormatOperatorToken LogicalOperatorToken MultiplyOperatorToken RangeOperatorToken
<valueRule> ::= · AttributeSpecificationToken <propertyOrArrayReferenceRule> ) [ | AdditionOperatorToken BitwiseOperatorToken CommaToken ComparisonOperatorToken FormatOperatorToken LogicalOperatorToken MultiplyOperatorToken RangeOperatorToken
<valueRule> ::= · AttributeSpecificationToken ) [ | AdditionOperatorToken BitwiseOperatorToken CommaToken ComparisonOperatorToken FormatOperatorToken LogicalOperatorToken MultiplyOperatorToken RangeOperatorToken
<valueRule> ::= · NumberToken ) [ | AdditionOperatorToken BitwiseOperatorToken CommaToken ComparisonOperatorToken FormatOperatorToken LogicalOperatorToken MultiplyOperatorToken RangeOperatorToken
<valueRule> ::= · StringToken ) [ | AdditionOperatorToken BitwiseOperatorToken CommaToken ComparisonOperatorToken FormatOperatorToken LogicalOperatorToken MultiplyOperatorToken RangeOperatorToken
<valueRule> ::= · ExpandableStringToken ) [ | AdditionOperatorToken BitwiseOperatorToken CommaToken ComparisonOperatorToken FormatOperatorToken LogicalOperatorToken MultiplyOperatorToken RangeOperatorToken
<valueRule> ::= · VariableToken ) [ | AdditionOperatorToken BitwiseOperatorToken CommaToken ComparisonOperatorToken FormatOperatorToken LogicalOperatorToken MultiplyOperatorToken RangeOperatorToken
Actions
'$(' Shift 1
'(' Shift 2
'@(' Shift 3
AnyWordToken Shift 4
AttributeSpecificationToken Shift 5
ExecCall Shift 10
ExpandableStringToken Shift 11
NumberToken Shift 16
StringToken Shift 18
UnaryOperatorToken Shift 20
VariableToken Shift 21
<addExpressionRule> Goto 22
<arrayLiteralRule> Goto 23
<assignmentStatementRule> Goto 24
<bitwiseExpressionRule> Goto 25
<cmdletCall> Goto 26
<cmdletName> Goto 27
<comparisonExpressionRule> Goto 28
<expressionRule> Goto 30
<formatExpressionRule> Goto 34
<logicalExpressionRule> Goto 36
<lvalue> Goto 37
<lvalueExpression> Goto 38
<multiplyExpressionRule> Goto 39
<pipelineRule> Goto 106
<postfixOperatorRule> Goto 41
<propertyOrArrayReferenceRule> Goto 42
<rangeExpressionRule> Goto 43
<valueRule> Goto 47

LALR State 67
Configuration Lookahead
<doWhileStatementRule> ::= LoopLabelToken do · <statementBlockRule> while '(' <pipelineRule> ')' EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<doWhileStatementRule> ::= LoopLabelToken do · <statementBlockRule> until '(' <pipelineRule> ')' EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<statementBlockRule> ::= · '{' <statementListRule> '}' until while
Actions
'{' Shift 61
<statementBlockRule> Goto 107

LALR State 68
Configuration Lookahead
<foreachStatementRule> ::= LoopLabelToken foreach · '(' VariableToken in <pipelineRule> ')' <statementBlockRule> EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
Actions
'(' Shift 108

LALR State 69
Configuration Lookahead
<flowControlStatementRule> ::= return <pipelineRule> · EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
Actions
(EOF) Reduce Rule 71
'$(' Reduce Rule 71
'(' Reduce Rule 71
')' Reduce Rule 71
'@(' Reduce Rule 71
'}' Reduce Rule 71
AnyWordToken Reduce Rule 71
AttributeSpecificationToken Reduce Rule 71
break Reduce Rule 71
CommentToken Reduce Rule 71
continue Reduce Rule 71
do Reduce Rule 71
ExecCall Reduce Rule 71
ExpandableStringToken Reduce Rule 71
finally Reduce Rule 71
foreach Reduce Rule 71
if Reduce Rule 71
LoopLabelToken Reduce Rule 71
NewLine Reduce Rule 71
NumberToken Reduce Rule 71
return Reduce Rule 71
StringToken Reduce Rule 71
trap Reduce Rule 71
UnaryOperatorToken Reduce Rule 71
VariableToken Reduce Rule 71

LALR State 70
Configuration Lookahead
<trapStatementRule> ::= trap AttributeSpecificationToken · <statementBlockRule> EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<statementBlockRule> ::= · '{' <statementListRule> '}' EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
Actions
'{' Shift 61
<statementBlockRule> Goto 109

LALR State 71
Configuration Lookahead
<trapStatementRule> ::= trap <statementBlockRule> · EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
Actions
(EOF) Reduce Rule 63
'$(' Reduce Rule 63
'(' Reduce Rule 63
')' Reduce Rule 63
'@(' Reduce Rule 63
'}' Reduce Rule 63
AnyWordToken Reduce Rule 63
AttributeSpecificationToken Reduce Rule 63
break Reduce Rule 63
CommentToken Reduce Rule 63
continue Reduce Rule 63
do Reduce Rule 63
ExecCall Reduce Rule 63
ExpandableStringToken Reduce Rule 63
finally Reduce Rule 63
foreach Reduce Rule 63
if Reduce Rule 63
LoopLabelToken Reduce Rule 63
NewLine Reduce Rule 63
NumberToken Reduce Rule 63
return Reduce Rule 63
StringToken Reduce Rule 63
trap Reduce Rule 63
UnaryOperatorToken Reduce Rule 63
VariableToken Reduce Rule 63

LALR State 72
Configuration Lookahead
<valueRule> ::= UnaryOperatorToken <propertyOrArrayReferenceRule> · EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
Actions
(EOF) Reduce Rule 100
'$(' Reduce Rule 100
'(' Reduce Rule 100
')' Reduce Rule 100
'@(' Reduce Rule 100
'[' Reduce Rule 100
']' Reduce Rule 100
'|' Reduce Rule 100
'}' Reduce Rule 100
AdditionOperatorToken Reduce Rule 100
AnyWordToken Reduce Rule 100
AssignmentOperatorToken Reduce Rule 100
AttributeSpecificationToken Reduce Rule 100
BitwiseOperatorToken Reduce Rule 100
break Reduce Rule 100
CommaToken Reduce Rule 100
CommentToken Reduce Rule 100
ComparisonOperatorToken Reduce Rule 100
continue Reduce Rule 100
do Reduce Rule 100
ExecCall Reduce Rule 100
ExpandableStringToken Reduce Rule 100
finally Reduce Rule 100
foreach Reduce Rule 100
FormatOperatorToken Reduce Rule 100
if Reduce Rule 100
LogicalOperatorToken Reduce Rule 100
LoopLabelToken Reduce Rule 100
MultiplyOperatorToken Reduce Rule 100
NewLine Reduce Rule 100
NumberToken Reduce Rule 100
ParameterToken Reduce Rule 100
PrePostfixOperatorToken Reduce Rule 100
RangeOperatorToken Reduce Rule 100
return Reduce Rule 100
StringToken Reduce Rule 100
trap Reduce Rule 100
UnaryOperatorToken Reduce Rule 100
VariableToken Reduce Rule 100

LALR State 73
Configuration Lookahead
<propertyOrArrayReferenceOperator> ::= '[' · <expressionRule> ']' ReferenceOperatorToken AnyWordToken EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<propertyOrArrayReferenceOperator> ::= '[' · <expressionRule> ']' ReferenceOperatorToken AnyWordToken <parseCallRule> EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<propertyOrArrayReferenceOperator> ::= '[' · <expressionRule> ']' <valueRule> EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<lvalueExpression> ::= · <lvalue> PrePostfixOperatorToken
<lvalue> ::= · VariableToken PrePostfixOperatorToken
<lvalue> ::= · AttributeSpecificationToken VariableToken PrePostfixOperatorToken
<lvalue> ::= · VariableToken <propertyOrArrayReferenceOperatorList> PrePostfixOperatorToken
<lvalue> ::= · AttributeSpecificationToken VariableToken <propertyOrArrayReferenceOperatorList> PrePostfixOperatorToken
<expressionRule> ::= · <logicalExpressionRule> ]
<logicalExpressionRule> ::= · <bitwiseExpressionRule> ]
<logicalExpressionRule> ::= · <bitwiseExpressionRule> LogicalOperatorToken <logicalExpressionRule> ]
<bitwiseExpressionRule> ::= · <comparisonExpressionRule> ] LogicalOperatorToken
<bitwiseExpressionRule> ::= · <comparisonExpressionRule> BitwiseOperatorToken <bitwiseExpressionRule> ] LogicalOperatorToken
<comparisonExpressionRule> ::= · <addExpressionRule> ] BitwiseOperatorToken LogicalOperatorToken
<comparisonExpressionRule> ::= · <addExpressionRule> ComparisonOperatorToken <comparisonExpressionRule> ] BitwiseOperatorToken LogicalOperatorToken
<addExpressionRule> ::= · <multiplyExpressionRule> ] BitwiseOperatorToken ComparisonOperatorToken LogicalOperatorToken
<addExpressionRule> ::= · <multiplyExpressionRule> AdditionOperatorToken <addExpressionRule> ] BitwiseOperatorToken ComparisonOperatorToken LogicalOperatorToken
<multiplyExpressionRule> ::= · <formatExpressionRule> ] AdditionOperatorToken BitwiseOperatorToken ComparisonOperatorToken LogicalOperatorToken
<multiplyExpressionRule> ::= · <formatExpressionRule> MultiplyOperatorToken <multiplyExpressionRule> ] AdditionOperatorToken BitwiseOperatorToken ComparisonOperatorToken LogicalOperatorToken
<formatExpressionRule> ::= · <rangeExpressionRule> ] AdditionOperatorToken BitwiseOperatorToken ComparisonOperatorToken LogicalOperatorToken MultiplyOperatorToken
<formatExpressionRule> ::= · <rangeExpressionRule> FormatOperatorToken <formatExpressionRule> ] AdditionOperatorToken BitwiseOperatorToken ComparisonOperatorToken LogicalOperatorToken MultiplyOperatorToken
<rangeExpressionRule> ::= · <arrayLiteralRule> ] AdditionOperatorToken BitwiseOperatorToken ComparisonOperatorToken FormatOperatorToken LogicalOperatorToken MultiplyOperatorToken
<rangeExpressionRule> ::= · <arrayLiteralRule> RangeOperatorToken <rangeExpressionRule> ] AdditionOperatorToken BitwiseOperatorToken ComparisonOperatorToken FormatOperatorToken LogicalOperatorToken MultiplyOperatorToken
<arrayLiteralRule> ::= · <postfixOperatorRule> ] AdditionOperatorToken BitwiseOperatorToken ComparisonOperatorToken FormatOperatorToken LogicalOperatorToken MultiplyOperatorToken RangeOperatorToken
<arrayLiteralRule> ::= · <postfixOperatorRule> CommaToken <arrayLiteralRule> ] AdditionOperatorToken BitwiseOperatorToken ComparisonOperatorToken FormatOperatorToken LogicalOperatorToken MultiplyOperatorToken RangeOperatorToken
<postfixOperatorRule> ::= · <lvalueExpression> PrePostfixOperatorToken ] AdditionOperatorToken BitwiseOperatorToken CommaToken ComparisonOperatorToken FormatOperatorToken LogicalOperatorToken MultiplyOperatorToken RangeOperatorToken
<postfixOperatorRule> ::= · <propertyOrArrayReferenceRule> ] AdditionOperatorToken BitwiseOperatorToken CommaToken ComparisonOperatorToken FormatOperatorToken LogicalOperatorToken MultiplyOperatorToken RangeOperatorToken
<propertyOrArrayReferenceRule> ::= · <valueRule> ] AdditionOperatorToken BitwiseOperatorToken CommaToken ComparisonOperatorToken FormatOperatorToken LogicalOperatorToken MultiplyOperatorToken RangeOperatorToken
<propertyOrArrayReferenceRule> ::= · <valueRule> <propertyOrArrayReferenceOperatorList> ] AdditionOperatorToken BitwiseOperatorToken CommaToken ComparisonOperatorToken FormatOperatorToken LogicalOperatorToken MultiplyOperatorToken RangeOperatorToken
<valueRule> ::= · '(' <assignmentStatementRule> ')' [ ] AdditionOperatorToken BitwiseOperatorToken CommaToken ComparisonOperatorToken FormatOperatorToken LogicalOperatorToken MultiplyOperatorToken RangeOperatorToken
<valueRule> ::= · '$(' <statementListRule> ')' [ ] AdditionOperatorToken BitwiseOperatorToken CommaToken ComparisonOperatorToken FormatOperatorToken LogicalOperatorToken MultiplyOperatorToken RangeOperatorToken
<valueRule> ::= · '@(' <statementListRule> ')' [ ] AdditionOperatorToken BitwiseOperatorToken CommaToken ComparisonOperatorToken FormatOperatorToken LogicalOperatorToken MultiplyOperatorToken RangeOperatorToken
<valueRule> ::= · UnaryOperatorToken <propertyOrArrayReferenceRule> [ ] AdditionOperatorToken BitwiseOperatorToken CommaToken ComparisonOperatorToken FormatOperatorToken LogicalOperatorToken MultiplyOperatorToken RangeOperatorToken
<valueRule> ::= · AttributeSpecificationToken <propertyOrArrayReferenceRule> [ ] AdditionOperatorToken BitwiseOperatorToken CommaToken ComparisonOperatorToken FormatOperatorToken LogicalOperatorToken MultiplyOperatorToken RangeOperatorToken
<valueRule> ::= · AttributeSpecificationToken [ ] AdditionOperatorToken BitwiseOperatorToken CommaToken ComparisonOperatorToken FormatOperatorToken LogicalOperatorToken MultiplyOperatorToken RangeOperatorToken
<valueRule> ::= · NumberToken [ ] AdditionOperatorToken BitwiseOperatorToken CommaToken ComparisonOperatorToken FormatOperatorToken LogicalOperatorToken MultiplyOperatorToken RangeOperatorToken
<valueRule> ::= · StringToken [ ] AdditionOperatorToken BitwiseOperatorToken CommaToken ComparisonOperatorToken FormatOperatorToken LogicalOperatorToken MultiplyOperatorToken RangeOperatorToken
<valueRule> ::= · ExpandableStringToken [ ] AdditionOperatorToken BitwiseOperatorToken CommaToken ComparisonOperatorToken FormatOperatorToken LogicalOperatorToken MultiplyOperatorToken RangeOperatorToken
<valueRule> ::= · VariableToken [ ] AdditionOperatorToken BitwiseOperatorToken CommaToken ComparisonOperatorToken FormatOperatorToken LogicalOperatorToken MultiplyOperatorToken RangeOperatorToken
Actions
'$(' Shift 1
'(' Shift 2
'@(' Shift 3
AttributeSpecificationToken Shift 5
ExpandableStringToken Shift 11
NumberToken Shift 16
StringToken Shift 18
UnaryOperatorToken Shift 20
VariableToken Shift 21
<addExpressionRule> Goto 22
<arrayLiteralRule> Goto 23
<bitwiseExpressionRule> Goto 25
<comparisonExpressionRule> Goto 28
<expressionRule> Goto 110
<formatExpressionRule> Goto 34
<logicalExpressionRule> Goto 36
<lvalue> Goto 37
<lvalueExpression> Goto 111
<multiplyExpressionRule> Goto 39
<postfixOperatorRule> Goto 41
<propertyOrArrayReferenceRule> Goto 42
<rangeExpressionRule> Goto 43
<valueRule> Goto 47

LALR State 74
Configuration Lookahead
<propertyOrArrayReferenceOperatorList> ::= <propertyOrArrayReferenceOperator> · EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AssignmentOperatorToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken ParameterToken PrePostfixOperatorToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
Actions
(EOF) Reduce Rule 19
'$(' Reduce Rule 19
'(' Reduce Rule 19
')' Reduce Rule 19
'@(' Reduce Rule 19
'[' Reduce Rule 19
']' Reduce Rule 19
'|' Reduce Rule 19
'}' Reduce Rule 19
AdditionOperatorToken Reduce Rule 19
AnyWordToken Reduce Rule 19
AssignmentOperatorToken Reduce Rule 19
AttributeSpecificationToken Reduce Rule 19
BitwiseOperatorToken Reduce Rule 19
break Reduce Rule 19
CommaToken Reduce Rule 19
CommentToken Reduce Rule 19
ComparisonOperatorToken Reduce Rule 19
continue Reduce Rule 19
do Reduce Rule 19
ExecCall Reduce Rule 19
ExpandableStringToken Reduce Rule 19
finally Reduce Rule 19
foreach Reduce Rule 19
FormatOperatorToken Reduce Rule 19
if Reduce Rule 19
LogicalOperatorToken Reduce Rule 19
LoopLabelToken Reduce Rule 19
MultiplyOperatorToken Reduce Rule 19
NewLine Reduce Rule 19
NumberToken Reduce Rule 19
ParameterToken Reduce Rule 19
PrePostfixOperatorToken Reduce Rule 19
RangeOperatorToken Reduce Rule 19
return Reduce Rule 19
StringToken Reduce Rule 19
trap Reduce Rule 19
UnaryOperatorToken Reduce Rule 19
VariableToken Reduce Rule 19

LALR State 75
Configuration Lookahead
<lvalue> ::= VariableToken <propertyOrArrayReferenceOperatorList> · AssignmentOperatorToken PrePostfixOperatorToken
<propertyOrArrayReferenceOperatorList> ::= <propertyOrArrayReferenceOperatorList> · <propertyOrArrayReferenceOperator> [ AssignmentOperatorToken PrePostfixOperatorToken
<propertyOrArrayReferenceOperator> ::= · '[' <expressionRule> ']' ReferenceOperatorToken AnyWordToken [ AssignmentOperatorToken PrePostfixOperatorToken
<propertyOrArrayReferenceOperator> ::= · '[' <expressionRule> ']' ReferenceOperatorToken AnyWordToken <parseCallRule> [ AssignmentOperatorToken PrePostfixOperatorToken
<propertyOrArrayReferenceOperator> ::= · '[' <expressionRule> ']' <valueRule> [ AssignmentOperatorToken PrePostfixOperatorToken
Actions
'[' Shift 73
<propertyOrArrayReferenceOperator> Goto 112
AssignmentOperatorToken Reduce Rule 23
PrePostfixOperatorToken Reduce Rule 23

LALR State 76
Configuration Lookahead
<comparisonExpressionRule> ::= <addExpressionRule> ComparisonOperatorToken · <comparisonExpressionRule> EOF $( ( ) @( ] | } AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<lvalueExpression> ::= · <lvalue> PrePostfixOperatorToken
<lvalue> ::= · VariableToken PrePostfixOperatorToken
<lvalue> ::= · AttributeSpecificationToken VariableToken PrePostfixOperatorToken
<lvalue> ::= · VariableToken <propertyOrArrayReferenceOperatorList> PrePostfixOperatorToken
<lvalue> ::= · AttributeSpecificationToken VariableToken <propertyOrArrayReferenceOperatorList> PrePostfixOperatorToken
<comparisonExpressionRule> ::= · <addExpressionRule> EOF $( ( ) @( ] | } AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<comparisonExpressionRule> ::= · <addExpressionRule> ComparisonOperatorToken <comparisonExpressionRule> EOF $( ( ) @( ] | } AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<addExpressionRule> ::= · <multiplyExpressionRule> EOF $( ( ) @( ] | } AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<addExpressionRule> ::= · <multiplyExpressionRule> AdditionOperatorToken <addExpressionRule> EOF $( ( ) @( ] | } AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<multiplyExpressionRule> ::= · <formatExpressionRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<multiplyExpressionRule> ::= · <formatExpressionRule> MultiplyOperatorToken <multiplyExpressionRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<formatExpressionRule> ::= · <rangeExpressionRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<formatExpressionRule> ::= · <rangeExpressionRule> FormatOperatorToken <formatExpressionRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<rangeExpressionRule> ::= · <arrayLiteralRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<rangeExpressionRule> ::= · <arrayLiteralRule> RangeOperatorToken <rangeExpressionRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<arrayLiteralRule> ::= · <postfixOperatorRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<arrayLiteralRule> ::= · <postfixOperatorRule> CommaToken <arrayLiteralRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<postfixOperatorRule> ::= · <lvalueExpression> PrePostfixOperatorToken EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<postfixOperatorRule> ::= · <propertyOrArrayReferenceRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<propertyOrArrayReferenceRule> ::= · <valueRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<propertyOrArrayReferenceRule> ::= · <valueRule> <propertyOrArrayReferenceOperatorList> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '(' <assignmentStatementRule> ')' EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '$(' <statementListRule> ')' EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '@(' <statementListRule> ')' EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · UnaryOperatorToken <propertyOrArrayReferenceRule> EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · AttributeSpecificationToken <propertyOrArrayReferenceRule> EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · AttributeSpecificationToken EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · NumberToken EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · StringToken EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · ExpandableStringToken EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · VariableToken EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
Actions
'$(' Shift 1
'(' Shift 2
'@(' Shift 3
AttributeSpecificationToken Shift 5
ExpandableStringToken Shift 11
NumberToken Shift 16
StringToken Shift 18
UnaryOperatorToken Shift 20
VariableToken Shift 21
<addExpressionRule> Goto 22
<arrayLiteralRule> Goto 23
<comparisonExpressionRule> Goto 113
<formatExpressionRule> Goto 34
<lvalue> Goto 37
<lvalueExpression> Goto 111
<multiplyExpressionRule> Goto 39
<postfixOperatorRule> Goto 41
<propertyOrArrayReferenceRule> Goto 42
<rangeExpressionRule> Goto 43
<valueRule> Goto 47

LALR State 77
Configuration Lookahead
<rangeExpressionRule> ::= <arrayLiteralRule> RangeOperatorToken · <rangeExpressionRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<lvalueExpression> ::= · <lvalue> PrePostfixOperatorToken
<lvalue> ::= · VariableToken PrePostfixOperatorToken
<lvalue> ::= · AttributeSpecificationToken VariableToken PrePostfixOperatorToken
<lvalue> ::= · VariableToken <propertyOrArrayReferenceOperatorList> PrePostfixOperatorToken
<lvalue> ::= · AttributeSpecificationToken VariableToken <propertyOrArrayReferenceOperatorList> PrePostfixOperatorToken
<rangeExpressionRule> ::= · <arrayLiteralRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<rangeExpressionRule> ::= · <arrayLiteralRule> RangeOperatorToken <rangeExpressionRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<arrayLiteralRule> ::= · <postfixOperatorRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<arrayLiteralRule> ::= · <postfixOperatorRule> CommaToken <arrayLiteralRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<postfixOperatorRule> ::= · <lvalueExpression> PrePostfixOperatorToken EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<postfixOperatorRule> ::= · <propertyOrArrayReferenceRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<propertyOrArrayReferenceRule> ::= · <valueRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<propertyOrArrayReferenceRule> ::= · <valueRule> <propertyOrArrayReferenceOperatorList> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '(' <assignmentStatementRule> ')' EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '$(' <statementListRule> ')' EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '@(' <statementListRule> ')' EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · UnaryOperatorToken <propertyOrArrayReferenceRule> EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · AttributeSpecificationToken <propertyOrArrayReferenceRule> EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · AttributeSpecificationToken EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · NumberToken EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · StringToken EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · ExpandableStringToken EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · VariableToken EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
Actions
'$(' Shift 1
'(' Shift 2
'@(' Shift 3
AttributeSpecificationToken Shift 5
ExpandableStringToken Shift 11
NumberToken Shift 16
StringToken Shift 18
UnaryOperatorToken Shift 20
VariableToken Shift 21
<arrayLiteralRule> Goto 23
<lvalue> Goto 37
<lvalueExpression> Goto 111
<postfixOperatorRule> Goto 41
<propertyOrArrayReferenceRule> Goto 42
<rangeExpressionRule> Goto 114
<valueRule> Goto 47

LALR State 78
Configuration Lookahead
<pipelineRule> ::= <assignmentStatementRule> '|' · <pipelineRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<pipelineRule> ::= · <cmdletCall> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<pipelineRule> ::= · <cmdletCall> '|' <pipelineRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<pipelineRule> ::= · <assignmentStatementRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<pipelineRule> ::= · <assignmentStatementRule> '|' <pipelineRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<assignmentStatementRule> ::= · <lvalueExpression> AssignmentOperatorToken <pipelineRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<lvalueExpression> ::= · <lvalue> AssignmentOperatorToken PrePostfixOperatorToken
<lvalue> ::= · VariableToken AssignmentOperatorToken PrePostfixOperatorToken
<lvalue> ::= · AttributeSpecificationToken VariableToken AssignmentOperatorToken PrePostfixOperatorToken
<lvalue> ::= · VariableToken <propertyOrArrayReferenceOperatorList> AssignmentOperatorToken PrePostfixOperatorToken
<lvalue> ::= · AttributeSpecificationToken VariableToken <propertyOrArrayReferenceOperatorList> AssignmentOperatorToken PrePostfixOperatorToken
<cmdletName> ::= · AnyWordToken EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
<cmdletCall> ::= · ExecCall <cmdletName> <cmletParamsList> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<cmdletCall> ::= · ExecCall <cmdletName> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<cmdletCall> ::= · <cmdletName> <cmletParamsList> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<cmdletCall> ::= · <cmdletName> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<cmdletCall> ::= · <expressionRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<expressionRule> ::= · <logicalExpressionRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<logicalExpressionRule> ::= · <bitwiseExpressionRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<logicalExpressionRule> ::= · <bitwiseExpressionRule> LogicalOperatorToken <logicalExpressionRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<bitwiseExpressionRule> ::= · <comparisonExpressionRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<bitwiseExpressionRule> ::= · <comparisonExpressionRule> BitwiseOperatorToken <bitwiseExpressionRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<comparisonExpressionRule> ::= · <addExpressionRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<comparisonExpressionRule> ::= · <addExpressionRule> ComparisonOperatorToken <comparisonExpressionRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<addExpressionRule> ::= · <multiplyExpressionRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<addExpressionRule> ::= · <multiplyExpressionRule> AdditionOperatorToken <addExpressionRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<multiplyExpressionRule> ::= · <formatExpressionRule> EOF $( ( ) @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<multiplyExpressionRule> ::= · <formatExpressionRule> MultiplyOperatorToken <multiplyExpressionRule> EOF $( ( ) @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<formatExpressionRule> ::= · <rangeExpressionRule> EOF $( ( ) @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<formatExpressionRule> ::= · <rangeExpressionRule> FormatOperatorToken <formatExpressionRule> EOF $( ( ) @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<rangeExpressionRule> ::= · <arrayLiteralRule> EOF $( ( ) @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<rangeExpressionRule> ::= · <arrayLiteralRule> RangeOperatorToken <rangeExpressionRule> EOF $( ( ) @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<arrayLiteralRule> ::= · <postfixOperatorRule> EOF $( ( ) @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<arrayLiteralRule> ::= · <postfixOperatorRule> CommaToken <arrayLiteralRule> EOF $( ( ) @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<postfixOperatorRule> ::= · <lvalueExpression> PrePostfixOperatorToken EOF $( ( ) @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<postfixOperatorRule> ::= · <propertyOrArrayReferenceRule> EOF $( ( ) @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<propertyOrArrayReferenceRule> ::= · <valueRule> EOF $( ( ) @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<propertyOrArrayReferenceRule> ::= · <valueRule> <propertyOrArrayReferenceOperatorList> EOF $( ( ) @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '(' <assignmentStatementRule> ')' EOF $( ( ) @( [ | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '$(' <statementListRule> ')' EOF $( ( ) @( [ | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '@(' <statementListRule> ')' EOF $( ( ) @( [ | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · UnaryOperatorToken <propertyOrArrayReferenceRule> EOF $( ( ) @( [ | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · AttributeSpecificationToken <propertyOrArrayReferenceRule> EOF $( ( ) @( [ | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · AttributeSpecificationToken EOF $( ( ) @( [ | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · NumberToken EOF $( ( ) @( [ | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · StringToken EOF $( ( ) @( [ | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · ExpandableStringToken EOF $( ( ) @( [ | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · VariableToken EOF $( ( ) @( [ | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
Actions
'$(' Shift 1
'(' Shift 2
'@(' Shift 3
AnyWordToken Shift 4
AttributeSpecificationToken Shift 5
ExecCall Shift 10
ExpandableStringToken Shift 11
NumberToken Shift 16
StringToken Shift 18
UnaryOperatorToken Shift 20
VariableToken Shift 21
<addExpressionRule> Goto 22
<arrayLiteralRule> Goto 23
<assignmentStatementRule> Goto 24
<bitwiseExpressionRule> Goto 25
<cmdletCall> Goto 26
<cmdletName> Goto 27
<comparisonExpressionRule> Goto 28
<expressionRule> Goto 30
<formatExpressionRule> Goto 34
<logicalExpressionRule> Goto 36
<lvalue> Goto 37
<lvalueExpression> Goto 38
<multiplyExpressionRule> Goto 39
<pipelineRule> Goto 115
<postfixOperatorRule> Goto 41
<propertyOrArrayReferenceRule> Goto 42
<rangeExpressionRule> Goto 43
<valueRule> Goto 47

LALR State 79
Configuration Lookahead
<logicalExpressionRule> ::= <bitwiseExpressionRule> LogicalOperatorToken · <logicalExpressionRule> EOF $( ( ) @( ] | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<lvalueExpression> ::= · <lvalue> PrePostfixOperatorToken
<lvalue> ::= · VariableToken PrePostfixOperatorToken
<lvalue> ::= · AttributeSpecificationToken VariableToken PrePostfixOperatorToken
<lvalue> ::= · VariableToken <propertyOrArrayReferenceOperatorList> PrePostfixOperatorToken
<lvalue> ::= · AttributeSpecificationToken VariableToken <propertyOrArrayReferenceOperatorList> PrePostfixOperatorToken
<logicalExpressionRule> ::= · <bitwiseExpressionRule> EOF $( ( ) @( ] | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<logicalExpressionRule> ::= · <bitwiseExpressionRule> LogicalOperatorToken <logicalExpressionRule> EOF $( ( ) @( ] | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<bitwiseExpressionRule> ::= · <comparisonExpressionRule> EOF $( ( ) @( ] | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<bitwiseExpressionRule> ::= · <comparisonExpressionRule> BitwiseOperatorToken <bitwiseExpressionRule> EOF $( ( ) @( ] | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<comparisonExpressionRule> ::= · <addExpressionRule> EOF $( ( ) @( ] | } AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<comparisonExpressionRule> ::= · <addExpressionRule> ComparisonOperatorToken <comparisonExpressionRule> EOF $( ( ) @( ] | } AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<addExpressionRule> ::= · <multiplyExpressionRule> EOF $( ( ) @( ] | } AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<addExpressionRule> ::= · <multiplyExpressionRule> AdditionOperatorToken <addExpressionRule> EOF $( ( ) @( ] | } AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<multiplyExpressionRule> ::= · <formatExpressionRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<multiplyExpressionRule> ::= · <formatExpressionRule> MultiplyOperatorToken <multiplyExpressionRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<formatExpressionRule> ::= · <rangeExpressionRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<formatExpressionRule> ::= · <rangeExpressionRule> FormatOperatorToken <formatExpressionRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<rangeExpressionRule> ::= · <arrayLiteralRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<rangeExpressionRule> ::= · <arrayLiteralRule> RangeOperatorToken <rangeExpressionRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<arrayLiteralRule> ::= · <postfixOperatorRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<arrayLiteralRule> ::= · <postfixOperatorRule> CommaToken <arrayLiteralRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<postfixOperatorRule> ::= · <lvalueExpression> PrePostfixOperatorToken EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<postfixOperatorRule> ::= · <propertyOrArrayReferenceRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<propertyOrArrayReferenceRule> ::= · <valueRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<propertyOrArrayReferenceRule> ::= · <valueRule> <propertyOrArrayReferenceOperatorList> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '(' <assignmentStatementRule> ')' EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '$(' <statementListRule> ')' EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '@(' <statementListRule> ')' EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · UnaryOperatorToken <propertyOrArrayReferenceRule> EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · AttributeSpecificationToken <propertyOrArrayReferenceRule> EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · AttributeSpecificationToken EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · NumberToken EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · StringToken EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · ExpandableStringToken EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · VariableToken EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
Actions
'$(' Shift 1
'(' Shift 2
'@(' Shift 3
AttributeSpecificationToken Shift 5
ExpandableStringToken Shift 11
NumberToken Shift 16
StringToken Shift 18
UnaryOperatorToken Shift 20
VariableToken Shift 21
<addExpressionRule> Goto 22
<arrayLiteralRule> Goto 23
<bitwiseExpressionRule> Goto 25
<comparisonExpressionRule> Goto 28
<formatExpressionRule> Goto 34
<logicalExpressionRule> Goto 116
<lvalue> Goto 37
<lvalueExpression> Goto 111
<multiplyExpressionRule> Goto 39
<postfixOperatorRule> Goto 41
<propertyOrArrayReferenceRule> Goto 42
<rangeExpressionRule> Goto 43
<valueRule> Goto 47

LALR State 80
Configuration Lookahead
<pipelineRule> ::= <cmdletCall> '|' · <pipelineRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<pipelineRule> ::= · <cmdletCall> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<pipelineRule> ::= · <cmdletCall> '|' <pipelineRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<pipelineRule> ::= · <assignmentStatementRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<pipelineRule> ::= · <assignmentStatementRule> '|' <pipelineRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<assignmentStatementRule> ::= · <lvalueExpression> AssignmentOperatorToken <pipelineRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<lvalueExpression> ::= · <lvalue> AssignmentOperatorToken PrePostfixOperatorToken
<lvalue> ::= · VariableToken AssignmentOperatorToken PrePostfixOperatorToken
<lvalue> ::= · AttributeSpecificationToken VariableToken AssignmentOperatorToken PrePostfixOperatorToken
<lvalue> ::= · VariableToken <propertyOrArrayReferenceOperatorList> AssignmentOperatorToken PrePostfixOperatorToken
<lvalue> ::= · AttributeSpecificationToken VariableToken <propertyOrArrayReferenceOperatorList> AssignmentOperatorToken PrePostfixOperatorToken
<cmdletName> ::= · AnyWordToken EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
<cmdletCall> ::= · ExecCall <cmdletName> <cmletParamsList> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<cmdletCall> ::= · ExecCall <cmdletName> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<cmdletCall> ::= · <cmdletName> <cmletParamsList> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<cmdletCall> ::= · <cmdletName> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<cmdletCall> ::= · <expressionRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<expressionRule> ::= · <logicalExpressionRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<logicalExpressionRule> ::= · <bitwiseExpressionRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<logicalExpressionRule> ::= · <bitwiseExpressionRule> LogicalOperatorToken <logicalExpressionRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<bitwiseExpressionRule> ::= · <comparisonExpressionRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<bitwiseExpressionRule> ::= · <comparisonExpressionRule> BitwiseOperatorToken <bitwiseExpressionRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<comparisonExpressionRule> ::= · <addExpressionRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<comparisonExpressionRule> ::= · <addExpressionRule> ComparisonOperatorToken <comparisonExpressionRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<addExpressionRule> ::= · <multiplyExpressionRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<addExpressionRule> ::= · <multiplyExpressionRule> AdditionOperatorToken <addExpressionRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<multiplyExpressionRule> ::= · <formatExpressionRule> EOF $( ( ) @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<multiplyExpressionRule> ::= · <formatExpressionRule> MultiplyOperatorToken <multiplyExpressionRule> EOF $( ( ) @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<formatExpressionRule> ::= · <rangeExpressionRule> EOF $( ( ) @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<formatExpressionRule> ::= · <rangeExpressionRule> FormatOperatorToken <formatExpressionRule> EOF $( ( ) @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<rangeExpressionRule> ::= · <arrayLiteralRule> EOF $( ( ) @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<rangeExpressionRule> ::= · <arrayLiteralRule> RangeOperatorToken <rangeExpressionRule> EOF $( ( ) @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<arrayLiteralRule> ::= · <postfixOperatorRule> EOF $( ( ) @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<arrayLiteralRule> ::= · <postfixOperatorRule> CommaToken <arrayLiteralRule> EOF $( ( ) @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<postfixOperatorRule> ::= · <lvalueExpression> PrePostfixOperatorToken EOF $( ( ) @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<postfixOperatorRule> ::= · <propertyOrArrayReferenceRule> EOF $( ( ) @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<propertyOrArrayReferenceRule> ::= · <valueRule> EOF $( ( ) @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<propertyOrArrayReferenceRule> ::= · <valueRule> <propertyOrArrayReferenceOperatorList> EOF $( ( ) @( | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '(' <assignmentStatementRule> ')' EOF $( ( ) @( [ | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '$(' <statementListRule> ')' EOF $( ( ) @( [ | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '@(' <statementListRule> ')' EOF $( ( ) @( [ | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · UnaryOperatorToken <propertyOrArrayReferenceRule> EOF $( ( ) @( [ | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · AttributeSpecificationToken <propertyOrArrayReferenceRule> EOF $( ( ) @( [ | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · AttributeSpecificationToken EOF $( ( ) @( [ | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · NumberToken EOF $( ( ) @( [ | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · StringToken EOF $( ( ) @( [ | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · ExpandableStringToken EOF $( ( ) @( [ | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · VariableToken EOF $( ( ) @( [ | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
Actions
'$(' Shift 1
'(' Shift 2
'@(' Shift 3
AnyWordToken Shift 4
AttributeSpecificationToken Shift 5
ExecCall Shift 10
ExpandableStringToken Shift 11
NumberToken Shift 16
StringToken Shift 18
UnaryOperatorToken Shift 20
VariableToken Shift 21
<addExpressionRule> Goto 22
<arrayLiteralRule> Goto 23
<assignmentStatementRule> Goto 24
<bitwiseExpressionRule> Goto 25
<cmdletCall> Goto 26
<cmdletName> Goto 27
<comparisonExpressionRule> Goto 28
<expressionRule> Goto 30
<formatExpressionRule> Goto 34
<logicalExpressionRule> Goto 36
<lvalue> Goto 37
<lvalueExpression> Goto 38
<multiplyExpressionRule> Goto 39
<pipelineRule> Goto 117
<postfixOperatorRule> Goto 41
<propertyOrArrayReferenceRule> Goto 42
<rangeExpressionRule> Goto 43
<valueRule> Goto 47

LALR State 81
Configuration Lookahead
<ParameterArgumentToken> ::= AnyWordToken · EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
Actions
(EOF) Reduce Rule 26
'$(' Reduce Rule 26
'(' Reduce Rule 26
')' Reduce Rule 26
'@(' Reduce Rule 26
'|' Reduce Rule 26
'}' Reduce Rule 26
AnyWordToken Reduce Rule 26
AttributeSpecificationToken Reduce Rule 26
break Reduce Rule 26
CommentToken Reduce Rule 26
continue Reduce Rule 26
do Reduce Rule 26
ExecCall Reduce Rule 26
ExpandableStringToken Reduce Rule 26
finally Reduce Rule 26
foreach Reduce Rule 26
if Reduce Rule 26
LoopLabelToken Reduce Rule 26
NewLine Reduce Rule 26
NumberToken Reduce Rule 26
ParameterToken Reduce Rule 26
return Reduce Rule 26
StringToken Reduce Rule 26
trap Reduce Rule 26
UnaryOperatorToken Reduce Rule 26
VariableToken Reduce Rule 26

LALR State 82
Configuration Lookahead
<ParameterArgumentToken> ::= ParameterToken · EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
Actions
(EOF) Reduce Rule 27
'$(' Reduce Rule 27
'(' Reduce Rule 27
')' Reduce Rule 27
'@(' Reduce Rule 27
'|' Reduce Rule 27
'}' Reduce Rule 27
AnyWordToken Reduce Rule 27
AttributeSpecificationToken Reduce Rule 27
break Reduce Rule 27
CommentToken Reduce Rule 27
continue Reduce Rule 27
do Reduce Rule 27
ExecCall Reduce Rule 27
ExpandableStringToken Reduce Rule 27
finally Reduce Rule 27
foreach Reduce Rule 27
if Reduce Rule 27
LoopLabelToken Reduce Rule 27
NewLine Reduce Rule 27
NumberToken Reduce Rule 27
ParameterToken Reduce Rule 27
return Reduce Rule 27
StringToken Reduce Rule 27
trap Reduce Rule 27
UnaryOperatorToken Reduce Rule 27
VariableToken Reduce Rule 27

LALR State 83
Configuration Lookahead
<cmdletCall> ::= <cmdletName> <cmletParamsList> · EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
Actions
(EOF) Reduce Rule 33
'$(' Reduce Rule 33
'(' Reduce Rule 33
')' Reduce Rule 33
'@(' Reduce Rule 33
'|' Reduce Rule 33
'}' Reduce Rule 33
AnyWordToken Reduce Rule 33
AttributeSpecificationToken Reduce Rule 33
break Reduce Rule 33
CommentToken Reduce Rule 33
continue Reduce Rule 33
do Reduce Rule 33
ExecCall Reduce Rule 33
ExpandableStringToken Reduce Rule 33
finally Reduce Rule 33
foreach Reduce Rule 33
if Reduce Rule 33
LoopLabelToken Reduce Rule 33
NewLine Reduce Rule 33
NumberToken Reduce Rule 33
return Reduce Rule 33
StringToken Reduce Rule 33
trap Reduce Rule 33
UnaryOperatorToken Reduce Rule 33
VariableToken Reduce Rule 33

LALR State 84
Notes
WARNING: A SHIFT-REDUCE CONFLICT WAS FIXED: '$(', '(', '@(', AnyWordToken, AttributeSpecificationToken, ExpandableStringToken, NumberToken, StringToken, UnaryOperatorToken, VariableToken
Configuration Lookahead
<cmletParamsList> ::= <ParameterArgumentToken> · <cmletParamsList> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<cmletParamsList> ::= <ParameterArgumentToken> · EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<ParameterArgumentToken> ::= · <valueRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
<ParameterArgumentToken> ::= · AnyWordToken EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
<ParameterArgumentToken> ::= · ParameterToken EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
<cmletParamsList> ::= · <ParameterArgumentToken> <cmletParamsList> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<cmletParamsList> ::= · <ParameterArgumentToken> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '(' <assignmentStatementRule> ')' EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '$(' <statementListRule> ')' EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '@(' <statementListRule> ')' EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · UnaryOperatorToken <propertyOrArrayReferenceRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · AttributeSpecificationToken <propertyOrArrayReferenceRule> EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · AttributeSpecificationToken EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · NumberToken EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · StringToken EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · ExpandableStringToken EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · VariableToken EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
Actions
'$(' Shift 1
'(' Shift 2
'@(' Shift 3
AnyWordToken Shift 81
AttributeSpecificationToken Shift 54
ExpandableStringToken Shift 11
NumberToken Shift 16
ParameterToken Shift 82
StringToken Shift 18
UnaryOperatorToken Shift 20
VariableToken Shift 57
<cmletParamsList> Goto 118
<ParameterArgumentToken> Goto 84
<valueRule> Goto 85
(EOF) Reduce Rule 29
')' Reduce Rule 29
'|' Reduce Rule 29
'}' Reduce Rule 29
break Reduce Rule 29
CommentToken Reduce Rule 29
continue Reduce Rule 29
do Reduce Rule 29
ExecCall Reduce Rule 29
finally Reduce Rule 29
foreach Reduce Rule 29
if Reduce Rule 29
LoopLabelToken Reduce Rule 29
NewLine Reduce Rule 29
return Reduce Rule 29
trap Reduce Rule 29

LALR State 85
Configuration Lookahead
<ParameterArgumentToken> ::= <valueRule> · EOF $( ( ) @( | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken ParameterToken return StringToken trap UnaryOperatorToken VariableToken
Actions
(EOF) Reduce Rule 25
'$(' Reduce Rule 25
'(' Reduce Rule 25
')' Reduce Rule 25
'@(' Reduce Rule 25
'|' Reduce Rule 25
'}' Reduce Rule 25
AnyWordToken Reduce Rule 25
AttributeSpecificationToken Reduce Rule 25
break Reduce Rule 25
CommentToken Reduce Rule 25
continue Reduce Rule 25
do Reduce Rule 25
ExecCall Reduce Rule 25
ExpandableStringToken Reduce Rule 25
finally Reduce Rule 25
foreach Reduce Rule 25
if Reduce Rule 25
LoopLabelToken Reduce Rule 25
NewLine Reduce Rule 25
NumberToken Reduce Rule 25
ParameterToken Reduce Rule 25
return Reduce Rule 25
StringToken Reduce Rule 25
trap Reduce Rule 25
UnaryOperatorToken Reduce Rule 25
VariableToken Reduce Rule 25

LALR State 86
Configuration Lookahead
<bitwiseExpressionRule> ::= <comparisonExpressionRule> BitwiseOperatorToken · <bitwiseExpressionRule> EOF $( ( ) @( ] | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<lvalueExpression> ::= · <lvalue> PrePostfixOperatorToken
<lvalue> ::= · VariableToken PrePostfixOperatorToken
<lvalue> ::= · AttributeSpecificationToken VariableToken PrePostfixOperatorToken
<lvalue> ::= · VariableToken <propertyOrArrayReferenceOperatorList> PrePostfixOperatorToken
<lvalue> ::= · AttributeSpecificationToken VariableToken <propertyOrArrayReferenceOperatorList> PrePostfixOperatorToken
<bitwiseExpressionRule> ::= · <comparisonExpressionRule> EOF $( ( ) @( ] | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<bitwiseExpressionRule> ::= · <comparisonExpressionRule> BitwiseOperatorToken <bitwiseExpressionRule> EOF $( ( ) @( ] | } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<comparisonExpressionRule> ::= · <addExpressionRule> EOF $( ( ) @( ] | } AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<comparisonExpressionRule> ::= · <addExpressionRule> ComparisonOperatorToken <comparisonExpressionRule> EOF $( ( ) @( ] | } AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<addExpressionRule> ::= · <multiplyExpressionRule> EOF $( ( ) @( ] | } AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<addExpressionRule> ::= · <multiplyExpressionRule> AdditionOperatorToken <addExpressionRule> EOF $( ( ) @( ] | } AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<multiplyExpressionRule> ::= · <formatExpressionRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<multiplyExpressionRule> ::= · <formatExpressionRule> MultiplyOperatorToken <multiplyExpressionRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<formatExpressionRule> ::= · <rangeExpressionRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<formatExpressionRule> ::= · <rangeExpressionRule> FormatOperatorToken <formatExpressionRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<rangeExpressionRule> ::= · <arrayLiteralRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<rangeExpressionRule> ::= · <arrayLiteralRule> RangeOperatorToken <rangeExpressionRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<arrayLiteralRule> ::= · <postfixOperatorRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<arrayLiteralRule> ::= · <postfixOperatorRule> CommaToken <arrayLiteralRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<postfixOperatorRule> ::= · <lvalueExpression> PrePostfixOperatorToken EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<postfixOperatorRule> ::= · <propertyOrArrayReferenceRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<propertyOrArrayReferenceRule> ::= · <valueRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<propertyOrArrayReferenceRule> ::= · <valueRule> <propertyOrArrayReferenceOperatorList> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '(' <assignmentStatementRule> ')' EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '$(' <statementListRule> ')' EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '@(' <statementListRule> ')' EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · UnaryOperatorToken <propertyOrArrayReferenceRule> EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · AttributeSpecificationToken <propertyOrArrayReferenceRule> EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · AttributeSpecificationToken EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · NumberToken EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · StringToken EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · ExpandableStringToken EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · VariableToken EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
Actions
'$(' Shift 1
'(' Shift 2
'@(' Shift 3
AttributeSpecificationToken Shift 5
ExpandableStringToken Shift 11
NumberToken Shift 16
StringToken Shift 18
UnaryOperatorToken Shift 20
VariableToken Shift 21
<addExpressionRule> Goto 22
<arrayLiteralRule> Goto 23
<bitwiseExpressionRule> Goto 119
<comparisonExpressionRule> Goto 28
<formatExpressionRule> Goto 34
<lvalue> Goto 37
<lvalueExpression> Goto 111
<multiplyExpressionRule> Goto 39
<postfixOperatorRule> Goto 41
<propertyOrArrayReferenceRule> Goto 42
<rangeExpressionRule> Goto 43
<valueRule> Goto 47

LALR State 87
Configuration Lookahead
<multiplyExpressionRule> ::= <formatExpressionRule> MultiplyOperatorToken · <multiplyExpressionRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<lvalueExpression> ::= · <lvalue> PrePostfixOperatorToken
<lvalue> ::= · VariableToken PrePostfixOperatorToken
<lvalue> ::= · AttributeSpecificationToken VariableToken PrePostfixOperatorToken
<lvalue> ::= · VariableToken <propertyOrArrayReferenceOperatorList> PrePostfixOperatorToken
<lvalue> ::= · AttributeSpecificationToken VariableToken <propertyOrArrayReferenceOperatorList> PrePostfixOperatorToken
<multiplyExpressionRule> ::= · <formatExpressionRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<multiplyExpressionRule> ::= · <formatExpressionRule> MultiplyOperatorToken <multiplyExpressionRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<formatExpressionRule> ::= · <rangeExpressionRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<formatExpressionRule> ::= · <rangeExpressionRule> FormatOperatorToken <formatExpressionRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<rangeExpressionRule> ::= · <arrayLiteralRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<rangeExpressionRule> ::= · <arrayLiteralRule> RangeOperatorToken <rangeExpressionRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<arrayLiteralRule> ::= · <postfixOperatorRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<arrayLiteralRule> ::= · <postfixOperatorRule> CommaToken <arrayLiteralRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<postfixOperatorRule> ::= · <lvalueExpression> PrePostfixOperatorToken EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<postfixOperatorRule> ::= · <propertyOrArrayReferenceRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<propertyOrArrayReferenceRule> ::= · <valueRule> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<propertyOrArrayReferenceRule> ::= · <valueRule> <propertyOrArrayReferenceOperatorList> EOF $( ( ) @( ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '(' <assignmentStatementRule> ')' EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '$(' <statementListRule> ')' EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · '@(' <statementListRule> ')' EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · UnaryOperatorToken <propertyOrArrayReferenceRule> EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · AttributeSpecificationToken <propertyOrArrayReferenceRule> EOF $( ( ) @( [ ] | } AdditionOperatorToken AnyWordToken AttributeSpecificationToken BitwiseOperatorToken break CommaToken CommentToken ComparisonOperatorToken continue do ExecCall ExpandableStringToken finally foreach FormatOperatorToken if LogicalOperatorToken LoopLabelToken MultiplyOperatorToken NewLine NumberToken RangeOperatorToken return StringToken trap UnaryOperatorToken VariableToken
<valueRule> ::= · AttributeSpecificationToken