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 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
<formatExpressionRule> Goto 34
<lvalue> Goto 37
<lvalueExpression> Goto 111
<multiplyExpressionRule> Goto 120
<postfixOperatorRule> Goto 41
<propertyOrArrayReferenceRule> Goto 42
<rangeExpressionRule> Goto 43
<valueRule> Goto 47

LALR State 88
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
<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 121
<postfixOperatorRule> Goto 41
<propertyOrArrayReferenceRule> Goto 42
<rangeExpressionRule> Goto 43
<valueRule> Goto 47

LALR State 89
Configuration Lookahead
<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
(EOF) Reduce Rule 89
'$(' Reduce Rule 89
'(' Reduce Rule 89
')' Reduce Rule 89
'@(' Reduce Rule 89
']' Reduce Rule 89
'|' Reduce Rule 89
'}' Reduce Rule 89
AdditionOperatorToken Reduce Rule 89
AnyWordToken Reduce Rule 89
AttributeSpecificationToken Reduce Rule 89
BitwiseOperatorToken Reduce Rule 89
break Reduce Rule 89
CommaToken Reduce Rule 89
CommentToken Reduce Rule 89
ComparisonOperatorToken Reduce Rule 89
continue Reduce Rule 89
do Reduce Rule 89
ExecCall Reduce Rule 89
ExpandableStringToken Reduce Rule 89
finally Reduce Rule 89
foreach Reduce Rule 89
FormatOperatorToken Reduce Rule 89
if Reduce Rule 89
LogicalOperatorToken Reduce Rule 89
LoopLabelToken Reduce Rule 89
MultiplyOperatorToken Reduce Rule 89
NewLine Reduce Rule 89
NumberToken Reduce Rule 89
RangeOperatorToken Reduce Rule 89
return Reduce Rule 89
StringToken Reduce Rule 89
trap Reduce Rule 89
UnaryOperatorToken Reduce Rule 89
VariableToken Reduce Rule 89

LALR State 90
Configuration Lookahead
<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
<lvalueExpression> ::= · <lvalue> PrePostfixOperatorToken
<lvalue> ::= · VariableToken PrePostfixOperatorToken
<lvalue> ::= · AttributeSpecificationToken VariableToken PrePostfixOperatorToken
<lvalue> ::= · VariableToken <propertyOrArrayReferenceOperatorList> PrePostfixOperatorToken
<lvalue> ::= · AttributeSpecificationToken VariableToken <propertyOrArrayReferenceOperatorList> PrePostfixOperatorToken
<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 122
<arrayLiteralRule> Goto 23
<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 91
Configuration Lookahead
<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
<lvalueExpression> ::= · <lvalue> PrePostfixOperatorToken
<lvalue> ::= · VariableToken PrePostfixOperatorToken
<lvalue> ::= · AttributeSpecificationToken VariableToken PrePostfixOperatorToken
<lvalue> ::= · VariableToken <propertyOrArrayReferenceOperatorList> PrePostfixOperatorToken
<lvalue> ::= · AttributeSpecificationToken VariableToken <propertyOrArrayReferenceOperatorList> PrePostfixOperatorToken
<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 123
<lvalue> Goto 37
<lvalueExpression> Goto 111
<postfixOperatorRule> Goto 41
<propertyOrArrayReferenceRule> Goto 42
<valueRule> Goto 47

LALR State 92
Configuration Lookahead
<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
<lvalueExpression> ::= · <lvalue> PrePostfixOperatorToken
<lvalue> ::= · VariableToken PrePostfixOperatorToken
<lvalue> ::= · AttributeSpecificationToken VariableToken PrePostfixOperatorToken
<lvalue> ::= · VariableToken <propertyOrArrayReferenceOperatorList> PrePostfixOperatorToken
<lvalue> ::= · AttributeSpecificationToken VariableToken <propertyOrArrayReferenceOperatorList> PrePostfixOperatorToken
<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
<arrayLiteralRule> Goto 23
<formatExpressionRule> Goto 124
<lvalue> Goto 37
<lvalueExpression> Goto 111
<postfixOperatorRule> Goto 41
<propertyOrArrayReferenceRule> Goto 42
<rangeExpressionRule> Goto 43
<valueRule> Goto 47

LALR State 93
Configuration Lookahead
<statementSeparatorToken> ::= NewLine · <statementSeparatorToken> $( ( @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NumberToken return StringToken trap UnaryOperatorToken VariableToken
<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 125
'$(' 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 94
Configuration Lookahead
<statementListRule> ::= <statementRule> <statementSeparatorToken> · <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 126
<statementRule> Goto 45
<trapStatementRule> Goto 46
<valueRule> Goto 47

LALR State 95
Notes
WARNING: A SHIFT-REDUCE CONFLICT WAS FIXED: '['
Configuration Lookahead
<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> ::= <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 112
(EOF) Reduce Rule 92
'$(' Reduce Rule 92
'(' Reduce Rule 92
')' Reduce Rule 92
'@(' Reduce Rule 92
']' Reduce Rule 92
'|' Reduce Rule 92
'}' Reduce Rule 92
AdditionOperatorToken Reduce Rule 92
AnyWordToken Reduce Rule 92
AssignmentOperatorToken Reduce Rule 92
AttributeSpecificationToken Reduce Rule 92
BitwiseOperatorToken Reduce Rule 92
break Reduce Rule 92
CommaToken Reduce Rule 92
CommentToken Reduce Rule 92
ComparisonOperatorToken Reduce Rule 92
continue Reduce Rule 92
do Reduce Rule 92
ExecCall Reduce Rule 92
ExpandableStringToken Reduce Rule 92
finally Reduce Rule 92
foreach Reduce Rule 92
FormatOperatorToken Reduce Rule 92
if Reduce Rule 92
LogicalOperatorToken Reduce Rule 92
LoopLabelToken Reduce Rule 92
MultiplyOperatorToken Reduce Rule 92
NewLine Reduce Rule 92
NumberToken Reduce Rule 92
ParameterToken Reduce Rule 92
PrePostfixOperatorToken Reduce Rule 92
RangeOperatorToken Reduce Rule 92
return Reduce Rule 92
StringToken Reduce Rule 92
trap Reduce Rule 92
UnaryOperatorToken Reduce Rule 92
VariableToken Reduce Rule 92

LALR State 96
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
(EOF) Reduce Rule 98
'$(' Reduce Rule 98
'(' Reduce Rule 98
')' Reduce Rule 98
'@(' Reduce Rule 98
'[' Reduce Rule 98
']' Reduce Rule 98
'|' Reduce Rule 98
'}' Reduce Rule 98
AdditionOperatorToken Reduce Rule 98
AnyWordToken Reduce Rule 98
AssignmentOperatorToken Reduce Rule 98
AttributeSpecificationToken Reduce Rule 98
BitwiseOperatorToken Reduce Rule 98
break Reduce Rule 98
CommaToken Reduce Rule 98
CommentToken Reduce Rule 98
ComparisonOperatorToken Reduce Rule 98
continue Reduce Rule 98
do Reduce Rule 98
ExecCall Reduce Rule 98
ExpandableStringToken Reduce Rule 98
finally Reduce Rule 98
foreach Reduce Rule 98
FormatOperatorToken Reduce Rule 98
if Reduce Rule 98
LogicalOperatorToken Reduce Rule 98
LoopLabelToken Reduce Rule 98
MultiplyOperatorToken Reduce Rule 98
NewLine Reduce Rule 98
NumberToken Reduce Rule 98
ParameterToken Reduce Rule 98
PrePostfixOperatorToken Reduce Rule 98
RangeOperatorToken Reduce Rule 98
return Reduce Rule 98
StringToken Reduce Rule 98
trap Reduce Rule 98
UnaryOperatorToken Reduce Rule 98
VariableToken Reduce Rule 98

LALR State 97
Configuration Lookahead
<lvalue> ::= AttributeSpecificationToken VariableToken · AssignmentOperatorToken
<lvalue> ::= AttributeSpecificationToken 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 100
AssignmentOperatorToken Reduce Rule 22

LALR State 98
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
(EOF) Reduce Rule 97
'$(' Reduce Rule 97
'(' Reduce Rule 97
')' Reduce Rule 97
'@(' Reduce Rule 97
'[' Reduce Rule 97
']' Reduce Rule 97
'|' Reduce Rule 97
'}' Reduce Rule 97
AdditionOperatorToken Reduce Rule 97
AnyWordToken Reduce Rule 97
AssignmentOperatorToken Reduce Rule 97
AttributeSpecificationToken Reduce Rule 97
BitwiseOperatorToken Reduce Rule 97
break Reduce Rule 97
CommaToken Reduce Rule 97
CommentToken Reduce Rule 97
ComparisonOperatorToken Reduce Rule 97
continue Reduce Rule 97
do Reduce Rule 97
ExecCall Reduce Rule 97
ExpandableStringToken Reduce Rule 97
finally Reduce Rule 97
foreach Reduce Rule 97
FormatOperatorToken Reduce Rule 97
if Reduce Rule 97
LogicalOperatorToken Reduce Rule 97
LoopLabelToken Reduce Rule 97
MultiplyOperatorToken Reduce Rule 97
NewLine Reduce Rule 97
NumberToken Reduce Rule 97
ParameterToken Reduce Rule 97
PrePostfixOperatorToken Reduce Rule 97
RangeOperatorToken Reduce Rule 97
return Reduce Rule 97
StringToken Reduce Rule 97
trap Reduce Rule 97
UnaryOperatorToken Reduce Rule 97
VariableToken Reduce Rule 97

LALR State 99
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
(EOF) Reduce Rule 99
'$(' Reduce Rule 99
'(' Reduce Rule 99
')' Reduce Rule 99
'@(' Reduce Rule 99
'[' Reduce Rule 99
']' Reduce Rule 99
'|' Reduce Rule 99
'}' Reduce Rule 99
AdditionOperatorToken Reduce Rule 99
AnyWordToken Reduce Rule 99
AssignmentOperatorToken Reduce Rule 99
AttributeSpecificationToken Reduce Rule 99
BitwiseOperatorToken Reduce Rule 99
break Reduce Rule 99
CommaToken Reduce Rule 99
CommentToken Reduce Rule 99
ComparisonOperatorToken Reduce Rule 99
continue Reduce Rule 99
do Reduce Rule 99
ExecCall Reduce Rule 99
ExpandableStringToken Reduce Rule 99
finally Reduce Rule 99
foreach Reduce Rule 99
FormatOperatorToken Reduce Rule 99
if Reduce Rule 99
LogicalOperatorToken Reduce Rule 99
LoopLabelToken Reduce Rule 99
MultiplyOperatorToken Reduce Rule 99
NewLine Reduce Rule 99
NumberToken Reduce Rule 99
ParameterToken Reduce Rule 99
PrePostfixOperatorToken Reduce Rule 99
RangeOperatorToken Reduce Rule 99
return Reduce Rule 99
StringToken Reduce Rule 99
trap Reduce Rule 99
UnaryOperatorToken Reduce Rule 99
VariableToken Reduce Rule 99

LALR State 100
Configuration Lookahead
<lvalue> ::= AttributeSpecificationToken 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 24
PrePostfixOperatorToken Reduce Rule 24

LALR State 101
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
Actions
'}' Shift 127

LALR State 102
Configuration Lookahead
<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
'(' Shift 128

LALR State 103
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
Actions
'(' Shift 129

LALR State 104
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
Actions
(EOF) Reduce Rule 31
'$(' Reduce Rule 31
'(' Reduce Rule 31
')' Reduce Rule 31
'@(' Reduce Rule 31
'|' Reduce Rule 31
'}' Reduce Rule 31
AnyWordToken Reduce Rule 31
AttributeSpecificationToken Reduce Rule 31
break Reduce Rule 31
CommentToken Reduce Rule 31
continue Reduce Rule 31
do Reduce Rule 31
ExecCall Reduce Rule 31
ExpandableStringToken Reduce Rule 31
finally Reduce Rule 31
foreach Reduce Rule 31
if Reduce Rule 31
LoopLabelToken Reduce Rule 31
NewLine Reduce Rule 31
NumberToken Reduce Rule 31
return Reduce Rule 31
StringToken Reduce Rule 31
trap Reduce Rule 31
UnaryOperatorToken Reduce Rule 31
VariableToken Reduce Rule 31

LALR State 105
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
in Shift 130

LALR State 106
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 131

LALR State 107
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
Actions
until Shift 132
while Shift 133

LALR State 108
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
VariableToken Shift 134

LALR State 109
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
Actions
(EOF) Reduce Rule 64
'$(' Reduce Rule 64
'(' Reduce Rule 64
')' Reduce Rule 64
'@(' Reduce Rule 64
'}' Reduce Rule 64
AnyWordToken Reduce Rule 64
AttributeSpecificationToken Reduce Rule 64
break Reduce Rule 64
CommentToken Reduce Rule 64
continue Reduce Rule 64
do Reduce Rule 64
ExecCall Reduce Rule 64
ExpandableStringToken Reduce Rule 64
finally Reduce Rule 64
foreach Reduce Rule 64
if Reduce Rule 64
LoopLabelToken Reduce Rule 64
NewLine Reduce Rule 64
NumberToken Reduce Rule 64
return Reduce Rule 64
StringToken Reduce Rule 64
trap Reduce Rule 64
UnaryOperatorToken Reduce Rule 64
VariableToken Reduce Rule 64

LALR State 110
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
Actions
']' Shift 135

LALR State 111
Configuration Lookahead
<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
PrePostfixOperatorToken Shift 89

LALR State 112
Configuration Lookahead
<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
Actions
(EOF) Reduce Rule 20
'$(' Reduce Rule 20
'(' Reduce Rule 20
')' Reduce Rule 20
'@(' Reduce Rule 20
'[' Reduce Rule 20
']' Reduce Rule 20
'|' Reduce Rule 20
'}' Reduce Rule 20
AdditionOperatorToken Reduce Rule 20
AnyWordToken Reduce Rule 20
AssignmentOperatorToken Reduce Rule 20
AttributeSpecificationToken Reduce Rule 20
BitwiseOperatorToken Reduce Rule 20
break Reduce Rule 20
CommaToken Reduce Rule 20
CommentToken Reduce Rule 20
ComparisonOperatorToken Reduce Rule 20
continue Reduce Rule 20
do Reduce Rule 20
ExecCall Reduce Rule 20
ExpandableStringToken Reduce Rule 20
finally Reduce Rule 20
foreach Reduce Rule 20
FormatOperatorToken Reduce Rule 20
if Reduce Rule 20
LogicalOperatorToken Reduce Rule 20
LoopLabelToken Reduce Rule 20
MultiplyOperatorToken Reduce Rule 20
NewLine Reduce Rule 20
NumberToken Reduce Rule 20
ParameterToken Reduce Rule 20
PrePostfixOperatorToken Reduce Rule 20
RangeOperatorToken Reduce Rule 20
return Reduce Rule 20
StringToken Reduce Rule 20
trap Reduce Rule 20
UnaryOperatorToken Reduce Rule 20
VariableToken Reduce Rule 20

LALR State 113
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
Actions
(EOF) Reduce Rule 78
'$(' Reduce Rule 78
'(' Reduce Rule 78
')' Reduce Rule 78
'@(' Reduce Rule 78
']' Reduce Rule 78
'|' Reduce Rule 78
'}' Reduce Rule 78
AnyWordToken Reduce Rule 78
AttributeSpecificationToken Reduce Rule 78
BitwiseOperatorToken Reduce Rule 78
break Reduce Rule 78
CommentToken Reduce Rule 78
continue Reduce Rule 78
do Reduce Rule 78
ExecCall Reduce Rule 78
ExpandableStringToken Reduce Rule 78
finally Reduce Rule 78
foreach Reduce Rule 78
if Reduce Rule 78
LogicalOperatorToken Reduce Rule 78
LoopLabelToken Reduce Rule 78
NewLine Reduce Rule 78
NumberToken Reduce Rule 78
return Reduce Rule 78
StringToken Reduce Rule 78
trap Reduce Rule 78
UnaryOperatorToken Reduce Rule 78
VariableToken Reduce Rule 78

LALR State 114
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
Actions
(EOF) Reduce Rule 86
'$(' Reduce Rule 86
'(' Reduce Rule 86
')' Reduce Rule 86
'@(' Reduce Rule 86
']' Reduce Rule 86
'|' Reduce Rule 86
'}' Reduce Rule 86
AdditionOperatorToken Reduce Rule 86
AnyWordToken Reduce Rule 86
AttributeSpecificationToken Reduce Rule 86
BitwiseOperatorToken Reduce Rule 86
break Reduce Rule 86
CommentToken Reduce Rule 86
ComparisonOperatorToken Reduce Rule 86
continue Reduce Rule 86
do Reduce Rule 86
ExecCall Reduce Rule 86
ExpandableStringToken Reduce Rule 86
finally Reduce Rule 86
foreach Reduce Rule 86
FormatOperatorToken Reduce Rule 86
if Reduce Rule 86
LogicalOperatorToken Reduce Rule 86
LoopLabelToken Reduce Rule 86
MultiplyOperatorToken Reduce Rule 86
NewLine Reduce Rule 86
NumberToken Reduce Rule 86
return Reduce Rule 86
StringToken Reduce Rule 86
trap Reduce Rule 86
UnaryOperatorToken Reduce Rule 86
VariableToken Reduce Rule 86

LALR State 115
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
Actions
(EOF) Reduce Rule 16
'$(' Reduce Rule 16
'(' Reduce Rule 16
')' Reduce Rule 16
'@(' Reduce Rule 16
'|' Reduce Rule 16
'}' Reduce Rule 16
AnyWordToken Reduce Rule 16
AttributeSpecificationToken Reduce Rule 16
break Reduce Rule 16
CommentToken Reduce Rule 16
continue Reduce Rule 16
do Reduce Rule 16
ExecCall Reduce Rule 16
ExpandableStringToken Reduce Rule 16
finally Reduce Rule 16
foreach Reduce Rule 16
if Reduce Rule 16
LoopLabelToken Reduce Rule 16
NewLine Reduce Rule 16
NumberToken Reduce Rule 16
return Reduce Rule 16
StringToken Reduce Rule 16
trap Reduce Rule 16
UnaryOperatorToken Reduce Rule 16
VariableToken Reduce Rule 16

LALR State 116
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
Actions
(EOF) Reduce Rule 74
'$(' Reduce Rule 74
'(' Reduce Rule 74
')' Reduce Rule 74
'@(' Reduce Rule 74
']' Reduce Rule 74
'|' Reduce Rule 74
'}' Reduce Rule 74
AnyWordToken Reduce Rule 74
AttributeSpecificationToken Reduce Rule 74
break Reduce Rule 74
CommentToken Reduce Rule 74
continue Reduce Rule 74
do Reduce Rule 74
ExecCall Reduce Rule 74
ExpandableStringToken Reduce Rule 74
finally Reduce Rule 74
foreach Reduce Rule 74
if Reduce Rule 74
LoopLabelToken Reduce Rule 74
NewLine Reduce Rule 74
NumberToken Reduce Rule 74
return Reduce Rule 74
StringToken Reduce Rule 74
trap Reduce Rule 74
UnaryOperatorToken Reduce Rule 74
VariableToken Reduce Rule 74

LALR State 117
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
Actions
(EOF) Reduce Rule 14
'$(' Reduce Rule 14
'(' Reduce Rule 14
')' Reduce Rule 14
'@(' Reduce Rule 14
'|' Reduce Rule 14
'}' Reduce Rule 14
AnyWordToken Reduce Rule 14
AttributeSpecificationToken Reduce Rule 14
break Reduce Rule 14
CommentToken Reduce Rule 14
continue Reduce Rule 14
do Reduce Rule 14
ExecCall Reduce Rule 14
ExpandableStringToken Reduce Rule 14
finally Reduce Rule 14
foreach Reduce Rule 14
if Reduce Rule 14
LoopLabelToken Reduce Rule 14
NewLine Reduce Rule 14
NumberToken Reduce Rule 14
return Reduce Rule 14
StringToken Reduce Rule 14
trap Reduce Rule 14
UnaryOperatorToken Reduce Rule 14
VariableToken Reduce Rule 14

LALR State 118
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
Actions
(EOF) Reduce Rule 28
'$(' Reduce Rule 28
'(' Reduce Rule 28
')' Reduce Rule 28
'@(' Reduce Rule 28
'|' Reduce Rule 28
'}' Reduce Rule 28
AnyWordToken Reduce Rule 28
AttributeSpecificationToken Reduce Rule 28
break Reduce Rule 28
CommentToken Reduce Rule 28
continue Reduce Rule 28
do Reduce Rule 28
ExecCall Reduce Rule 28
ExpandableStringToken Reduce Rule 28
finally Reduce Rule 28
foreach Reduce Rule 28
if Reduce Rule 28
LoopLabelToken Reduce Rule 28
NewLine Reduce Rule 28
NumberToken Reduce Rule 28
return Reduce Rule 28
StringToken Reduce Rule 28
trap Reduce Rule 28
UnaryOperatorToken Reduce Rule 28
VariableToken Reduce Rule 28

LALR State 119
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
Actions
(EOF) Reduce Rule 76
'$(' Reduce Rule 76
'(' Reduce Rule 76
')' Reduce Rule 76
'@(' Reduce Rule 76
']' Reduce Rule 76
'|' Reduce Rule 76
'}' Reduce Rule 76
AnyWordToken Reduce Rule 76
AttributeSpecificationToken Reduce Rule 76
break Reduce Rule 76
CommentToken Reduce Rule 76
continue Reduce Rule 76
do Reduce Rule 76
ExecCall Reduce Rule 76
ExpandableStringToken Reduce Rule 76
finally Reduce Rule 76
foreach Reduce Rule 76
if Reduce Rule 76
LogicalOperatorToken Reduce Rule 76
LoopLabelToken Reduce Rule 76
NewLine Reduce Rule 76
NumberToken Reduce Rule 76
return Reduce Rule 76
StringToken Reduce Rule 76
trap Reduce Rule 76
UnaryOperatorToken Reduce Rule 76
VariableToken Reduce Rule 76

LALR State 120
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
Actions
(EOF) Reduce Rule 82
'$(' Reduce Rule 82
'(' Reduce Rule 82
')' Reduce Rule 82
'@(' Reduce Rule 82
']' Reduce Rule 82
'|' Reduce Rule 82
'}' Reduce Rule 82
AdditionOperatorToken Reduce Rule 82
AnyWordToken Reduce Rule 82
AttributeSpecificationToken Reduce Rule 82
BitwiseOperatorToken Reduce Rule 82
break Reduce Rule 82
CommentToken Reduce Rule 82
ComparisonOperatorToken Reduce Rule 82
continue Reduce Rule 82
do Reduce Rule 82
ExecCall Reduce Rule 82
ExpandableStringToken Reduce Rule 82
finally Reduce Rule 82
foreach Reduce Rule 82
if Reduce Rule 82
LogicalOperatorToken Reduce Rule 82
LoopLabelToken Reduce Rule 82
NewLine Reduce Rule 82
NumberToken Reduce Rule 82
return Reduce Rule 82
StringToken Reduce Rule 82
trap Reduce Rule 82
UnaryOperatorToken Reduce Rule 82
VariableToken Reduce Rule 82

LALR State 121
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
Actions
(EOF) Reduce Rule 17
'$(' Reduce Rule 17
'(' Reduce Rule 17
')' Reduce Rule 17
'@(' Reduce Rule 17
'|' Reduce Rule 17
'}' Reduce Rule 17
AnyWordToken Reduce Rule 17
AttributeSpecificationToken Reduce Rule 17
break Reduce Rule 17
CommentToken Reduce Rule 17
continue Reduce Rule 17
do Reduce Rule 17
ExecCall Reduce Rule 17
ExpandableStringToken Reduce Rule 17
finally Reduce Rule 17
foreach Reduce Rule 17
if Reduce Rule 17
LoopLabelToken Reduce Rule 17
NewLine Reduce Rule 17
NumberToken Reduce Rule 17
return Reduce Rule 17
StringToken Reduce Rule 17
trap Reduce Rule 17
UnaryOperatorToken Reduce Rule 17
VariableToken Reduce Rule 17

LALR State 122
Configuration Lookahead
<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
(EOF) Reduce Rule 80
'$(' Reduce Rule 80
'(' Reduce Rule 80
')' Reduce Rule 80
'@(' Reduce Rule 80
']' Reduce Rule 80
'|' Reduce Rule 80
'}' Reduce Rule 80
AnyWordToken Reduce Rule 80
AttributeSpecificationToken Reduce Rule 80
BitwiseOperatorToken Reduce Rule 80
break Reduce Rule 80
CommentToken Reduce Rule 80
ComparisonOperatorToken Reduce Rule 80
continue Reduce Rule 80
do Reduce Rule 80
ExecCall Reduce Rule 80
ExpandableStringToken Reduce Rule 80
finally Reduce Rule 80
foreach Reduce Rule 80
if Reduce Rule 80
LogicalOperatorToken Reduce Rule 80
LoopLabelToken Reduce Rule 80
NewLine Reduce Rule 80
NumberToken Reduce Rule 80
return Reduce Rule 80
StringToken Reduce Rule 80
trap Reduce Rule 80
UnaryOperatorToken Reduce Rule 80
VariableToken Reduce Rule 80

LALR State 123
Configuration Lookahead
<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
(EOF) Reduce Rule 88
'$(' Reduce Rule 88
'(' Reduce Rule 88
')' Reduce Rule 88
'@(' Reduce Rule 88
']' Reduce Rule 88
'|' Reduce Rule 88
'}' Reduce Rule 88
AdditionOperatorToken Reduce Rule 88
AnyWordToken Reduce Rule 88
AttributeSpecificationToken Reduce Rule 88
BitwiseOperatorToken Reduce Rule 88
break Reduce Rule 88
CommentToken Reduce Rule 88
ComparisonOperatorToken Reduce Rule 88
continue Reduce Rule 88
do Reduce Rule 88
ExecCall Reduce Rule 88
ExpandableStringToken Reduce Rule 88
finally Reduce Rule 88
foreach Reduce Rule 88
FormatOperatorToken Reduce Rule 88
if Reduce Rule 88
LogicalOperatorToken Reduce Rule 88
LoopLabelToken Reduce Rule 88
MultiplyOperatorToken Reduce Rule 88
NewLine Reduce Rule 88
NumberToken Reduce Rule 88
RangeOperatorToken Reduce Rule 88
return Reduce Rule 88
StringToken Reduce Rule 88
trap Reduce Rule 88
UnaryOperatorToken Reduce Rule 88
VariableToken Reduce Rule 88

LALR State 124
Configuration Lookahead
<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
(EOF) Reduce Rule 84
'$(' Reduce Rule 84
'(' Reduce Rule 84
')' Reduce Rule 84
'@(' Reduce Rule 84
']' Reduce Rule 84
'|' Reduce Rule 84
'}' Reduce Rule 84
AdditionOperatorToken Reduce Rule 84
AnyWordToken Reduce Rule 84
AttributeSpecificationToken Reduce Rule 84
BitwiseOperatorToken Reduce Rule 84
break Reduce Rule 84
CommentToken Reduce Rule 84
ComparisonOperatorToken Reduce Rule 84
continue Reduce Rule 84
do Reduce Rule 84
ExecCall Reduce Rule 84
ExpandableStringToken Reduce Rule 84
finally Reduce Rule 84
foreach Reduce Rule 84
if Reduce Rule 84
LogicalOperatorToken Reduce Rule 84
LoopLabelToken Reduce Rule 84
MultiplyOperatorToken Reduce Rule 84
NewLine Reduce Rule 84
NumberToken Reduce Rule 84
return Reduce Rule 84
StringToken Reduce Rule 84
trap Reduce Rule 84
UnaryOperatorToken Reduce Rule 84
VariableToken Reduce Rule 84

LALR State 125
Configuration Lookahead
<statementSeparatorToken> ::= NewLine <statementSeparatorToken> · $( ( @( AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NumberToken return StringToken trap UnaryOperatorToken VariableToken
Actions
'$(' Reduce Rule 0
'(' Reduce Rule 0
'@(' Reduce Rule 0
AnyWordToken Reduce Rule 0
AttributeSpecificationToken Reduce Rule 0
break Reduce Rule 0
CommentToken Reduce Rule 0
continue Reduce Rule 0
do Reduce Rule 0
ExecCall Reduce Rule 0
ExpandableStringToken Reduce Rule 0
finally Reduce Rule 0
foreach Reduce Rule 0
if Reduce Rule 0
LoopLabelToken Reduce Rule 0
NumberToken Reduce Rule 0
return Reduce Rule 0
StringToken Reduce Rule 0
trap Reduce Rule 0
UnaryOperatorToken Reduce Rule 0
VariableToken Reduce Rule 0

LALR State 126
Configuration Lookahead
<statementListRule> ::= <statementRule> <statementSeparatorToken> <statementListRule> · EOF ) }
Actions
(EOF) Reduce Rule 3
')' Reduce Rule 3
'}' Reduce Rule 3

LALR State 127
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
Actions
(EOF) Reduce Rule 4
'$(' Reduce Rule 4
'(' Reduce Rule 4
')' Reduce Rule 4
'@(' Reduce Rule 4
'}' Reduce Rule 4
AnyWordToken Reduce Rule 4
AttributeSpecificationToken Reduce Rule 4
break Reduce Rule 4
CommentToken Reduce Rule 4
continue Reduce Rule 4
do Reduce Rule 4
else Reduce Rule 4
elseif Reduce Rule 4
ExecCall Reduce Rule 4
ExpandableStringToken Reduce Rule 4
finally Reduce Rule 4
foreach Reduce Rule 4
if Reduce Rule 4
LoopLabelToken Reduce Rule 4
NewLine Reduce Rule 4
NumberToken Reduce Rule 4
return Reduce Rule 4
StringToken Reduce Rule 4
trap Reduce Rule 4
UnaryOperatorToken Reduce Rule 4
until Reduce Rule 4
VariableToken Reduce Rule 4
while Reduce Rule 4

LALR State 128
Configuration Lookahead
<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
<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 136
<postfixOperatorRule> Goto 41
<propertyOrArrayReferenceRule> Goto 42
<rangeExpressionRule> Goto 43
<valueRule> Goto 47

LALR State 129
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
<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 137
<postfixOperatorRule> Goto 41
<propertyOrArrayReferenceRule> Goto 42
<rangeExpressionRule> Goto 43
<valueRule> Goto 47

LALR State 130
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
<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 138
<postfixOperatorRule> Goto 41
<propertyOrArrayReferenceRule> Goto 42
<rangeExpressionRule> Goto 43
<valueRule> Goto 47

LALR State 131
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
<statementBlockRule> ::= · '{' <statementListRule> '}' EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do else elseif ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
Actions
'{' Shift 61
<statementBlockRule> Goto 139

LALR State 132
Configuration Lookahead
<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
'(' Shift 140

LALR State 133
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
Actions
'(' Shift 141

LALR State 134
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
in Shift 142

LALR State 135
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
<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
ReferenceOperatorToken Shift 143
StringToken Shift 18
UnaryOperatorToken Shift 20
VariableToken Shift 57
<valueRule> Goto 144

LALR State 136
Configuration Lookahead
<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
')' Shift 145

LALR State 137
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
Actions
')' Shift 146

LALR State 138
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 147

LALR State 139
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
<elseIfBlockRule> ::= · elseif '(' <pipelineRule> ')' <statementBlockRule> EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do else ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<elseIfBlockRule> ::= · elseif '(' <pipelineRule> ')' <statementBlockRule> <elseIfBlockRule> EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do else ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
Actions
else Shift 148
elseif Shift 149
<elseIfBlockRule> Goto 150
(EOF) Reduce Rule 38
'$(' Reduce Rule 38
'(' Reduce Rule 38
')' Reduce Rule 38
'@(' Reduce Rule 38
'}' Reduce Rule 38
AnyWordToken Reduce Rule 38
AttributeSpecificationToken Reduce Rule 38
break Reduce Rule 38
CommentToken Reduce Rule 38
continue Reduce Rule 38
do Reduce Rule 38
ExecCall Reduce Rule 38
ExpandableStringToken Reduce Rule 38
finally Reduce Rule 38
foreach Reduce Rule 38
if Reduce Rule 38
LoopLabelToken Reduce Rule 38
NewLine Reduce Rule 38
NumberToken Reduce Rule 38
return Reduce Rule 38
StringToken Reduce Rule 38
trap Reduce Rule 38
UnaryOperatorToken Reduce Rule 38
VariableToken Reduce Rule 38

LALR State 140
Configuration Lookahead
<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
<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 151
<postfixOperatorRule> Goto 41
<propertyOrArrayReferenceRule> Goto 42
<rangeExpressionRule> Goto 43
<valueRule> Goto 47

LALR State 141
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
<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 152
<postfixOperatorRule> Goto 41
<propertyOrArrayReferenceRule> Goto 42
<rangeExpressionRule> Goto 43
<valueRule> Goto 47

LALR State 142
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
<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 153
<postfixOperatorRule> Goto 41
<propertyOrArrayReferenceRule> Goto 42
<rangeExpressionRule> Goto 43
<valueRule> Goto 47

LALR State 143
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
Actions
AnyWordToken Shift 154

LALR State 144
Configuration Lookahead
<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
(EOF) Reduce Rule 95
'$(' Reduce Rule 95
'(' Reduce Rule 95
')' Reduce Rule 95
'@(' Reduce Rule 95
'[' Reduce Rule 95
']' Reduce Rule 95
'|' Reduce Rule 95
'}' Reduce Rule 95
AdditionOperatorToken Reduce Rule 95
AnyWordToken Reduce Rule 95
AssignmentOperatorToken Reduce Rule 95
AttributeSpecificationToken Reduce Rule 95
BitwiseOperatorToken Reduce Rule 95
break Reduce Rule 95
CommaToken Reduce Rule 95
CommentToken Reduce Rule 95
ComparisonOperatorToken Reduce Rule 95
continue Reduce Rule 95
do Reduce Rule 95
ExecCall Reduce Rule 95
ExpandableStringToken Reduce Rule 95
finally Reduce Rule 95
foreach Reduce Rule 95
FormatOperatorToken Reduce Rule 95
if Reduce Rule 95
LogicalOperatorToken Reduce Rule 95
LoopLabelToken Reduce Rule 95
MultiplyOperatorToken Reduce Rule 95
NewLine Reduce Rule 95
NumberToken Reduce Rule 95
ParameterToken Reduce Rule 95
PrePostfixOperatorToken Reduce Rule 95
RangeOperatorToken Reduce Rule 95
return Reduce Rule 95
StringToken Reduce Rule 95
trap Reduce Rule 95
UnaryOperatorToken Reduce Rule 95
VariableToken Reduce Rule 95

LALR State 145
Configuration Lookahead
<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
(EOF) Reduce Rule 60
'$(' Reduce Rule 60
'(' Reduce Rule 60
')' Reduce Rule 60
'@(' Reduce Rule 60
'}' Reduce Rule 60
AnyWordToken Reduce Rule 60
AttributeSpecificationToken Reduce Rule 60
break Reduce Rule 60
CommentToken Reduce Rule 60
continue Reduce Rule 60
do Reduce Rule 60
ExecCall Reduce Rule 60
ExpandableStringToken Reduce Rule 60
finally Reduce Rule 60
foreach Reduce Rule 60
if Reduce Rule 60
LoopLabelToken Reduce Rule 60
NewLine Reduce Rule 60
NumberToken Reduce Rule 60
return Reduce Rule 60
StringToken Reduce Rule 60
trap Reduce Rule 60
UnaryOperatorToken Reduce Rule 60
VariableToken Reduce Rule 60

LALR State 146
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
Actions
(EOF) Reduce Rule 59
'$(' Reduce Rule 59
'(' Reduce Rule 59
')' Reduce Rule 59
'@(' Reduce Rule 59
'}' Reduce Rule 59
AnyWordToken Reduce Rule 59
AttributeSpecificationToken Reduce Rule 59
break Reduce Rule 59
CommentToken Reduce Rule 59
continue Reduce Rule 59
do Reduce Rule 59
ExecCall Reduce Rule 59
ExpandableStringToken Reduce Rule 59
finally Reduce Rule 59
foreach Reduce Rule 59
if Reduce Rule 59
LoopLabelToken Reduce Rule 59
NewLine Reduce Rule 59
NumberToken Reduce Rule 59
return Reduce Rule 59
StringToken Reduce Rule 59
trap Reduce Rule 59
UnaryOperatorToken Reduce Rule 59
VariableToken Reduce Rule 59

LALR State 147
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
<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 155

LALR State 148
Configuration Lookahead
<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
<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 156

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

LALR State 150
Configuration Lookahead
<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> <elseIfBlockRule> · else <statementBlockRule> EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
Actions
else Shift 158
(EOF) Reduce Rule 39
'$(' Reduce Rule 39
'(' Reduce Rule 39
')' Reduce Rule 39
'@(' Reduce Rule 39
'}' Reduce Rule 39
AnyWordToken Reduce Rule 39
AttributeSpecificationToken Reduce Rule 39
break Reduce Rule 39
CommentToken Reduce Rule 39
continue Reduce Rule 39
do Reduce Rule 39
ExecCall Reduce Rule 39
ExpandableStringToken Reduce Rule 39
finally Reduce Rule 39
foreach Reduce Rule 39
if Reduce Rule 39
LoopLabelToken Reduce Rule 39
NewLine Reduce Rule 39
NumberToken Reduce Rule 39
return Reduce Rule 39
StringToken Reduce Rule 39
trap Reduce Rule 39
UnaryOperatorToken Reduce Rule 39
VariableToken Reduce Rule 39

LALR State 151
Configuration Lookahead
<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
')' Shift 159

LALR State 152
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
Actions
')' Shift 160

LALR State 153
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 161

LALR State 154
Notes
WARNING: A SHIFT-REDUCE CONFLICT WAS FIXED: '('
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
<parseCallRule> ::= · '(' <arrayLiteralRule> ')' 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 162
<parseCallRule> Goto 163
(EOF) Reduce Rule 93
'$(' Reduce Rule 93
')' Reduce Rule 93
'@(' Reduce Rule 93
'[' Reduce Rule 93
']' Reduce Rule 93
'|' Reduce Rule 93
'}' Reduce Rule 93
AdditionOperatorToken Reduce Rule 93
AnyWordToken Reduce Rule 93
AssignmentOperatorToken Reduce Rule 93
AttributeSpecificationToken Reduce Rule 93
BitwiseOperatorToken Reduce Rule 93
break Reduce Rule 93
CommaToken Reduce Rule 93
CommentToken Reduce Rule 93
ComparisonOperatorToken Reduce Rule 93
continue Reduce Rule 93
do Reduce Rule 93
ExecCall Reduce Rule 93
ExpandableStringToken Reduce Rule 93
finally Reduce Rule 93
foreach Reduce Rule 93
FormatOperatorToken Reduce Rule 93
if Reduce Rule 93
LogicalOperatorToken Reduce Rule 93
LoopLabelToken Reduce Rule 93
MultiplyOperatorToken Reduce Rule 93
NewLine Reduce Rule 93
NumberToken Reduce Rule 93
ParameterToken Reduce Rule 93
PrePostfixOperatorToken Reduce Rule 93
RangeOperatorToken Reduce Rule 93
return Reduce Rule 93
StringToken Reduce Rule 93
trap Reduce Rule 93
UnaryOperatorToken Reduce Rule 93
VariableToken Reduce Rule 93

LALR State 155
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
(EOF) Reduce Rule 57
'$(' Reduce Rule 57
'(' Reduce Rule 57
')' Reduce Rule 57
'@(' Reduce Rule 57
'}' Reduce Rule 57
AnyWordToken Reduce Rule 57
AttributeSpecificationToken Reduce Rule 57
break Reduce Rule 57
CommentToken Reduce Rule 57
continue Reduce Rule 57
do Reduce Rule 57
ExecCall Reduce Rule 57
ExpandableStringToken Reduce Rule 57
finally Reduce Rule 57
foreach Reduce Rule 57
if Reduce Rule 57
LoopLabelToken Reduce Rule 57
NewLine Reduce Rule 57
NumberToken Reduce Rule 57
return Reduce Rule 57
StringToken Reduce Rule 57
trap Reduce Rule 57
UnaryOperatorToken Reduce Rule 57
VariableToken Reduce Rule 57

LALR State 156
Configuration Lookahead
<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
Actions
(EOF) Reduce Rule 40
'$(' Reduce Rule 40
'(' Reduce Rule 40
')' Reduce Rule 40
'@(' Reduce Rule 40
'}' Reduce Rule 40
AnyWordToken Reduce Rule 40
AttributeSpecificationToken Reduce Rule 40
break Reduce Rule 40
CommentToken Reduce Rule 40
continue Reduce Rule 40
do Reduce Rule 40
ExecCall Reduce Rule 40
ExpandableStringToken Reduce Rule 40
finally Reduce Rule 40
foreach Reduce Rule 40
if Reduce Rule 40
LoopLabelToken Reduce Rule 40
NewLine Reduce Rule 40
NumberToken Reduce Rule 40
return Reduce Rule 40
StringToken Reduce Rule 40
trap Reduce Rule 40
UnaryOperatorToken Reduce Rule 40
VariableToken Reduce Rule 40

LALR State 157
Configuration Lookahead
<elseIfBlockRule> ::= elseif '(' · <pipelineRule> ')' <statementBlockRule> EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do else ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<elseIfBlockRule> ::= elseif '(' · <pipelineRule> ')' <statementBlockRule> <elseIfBlockRule> EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do else 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 164
<postfixOperatorRule> Goto 41
<propertyOrArrayReferenceRule> Goto 42
<rangeExpressionRule> Goto 43
<valueRule> Goto 47

LALR State 158
Configuration Lookahead
<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
<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 165

LALR State 159
Configuration Lookahead
<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
(EOF) Reduce Rule 62
'$(' Reduce Rule 62
'(' Reduce Rule 62
')' Reduce Rule 62
'@(' Reduce Rule 62
'}' Reduce Rule 62
AnyWordToken Reduce Rule 62
AttributeSpecificationToken Reduce Rule 62
break Reduce Rule 62
CommentToken Reduce Rule 62
continue Reduce Rule 62
do Reduce Rule 62
ExecCall Reduce Rule 62
ExpandableStringToken Reduce Rule 62
finally Reduce Rule 62
foreach Reduce Rule 62
if Reduce Rule 62
LoopLabelToken Reduce Rule 62
NewLine Reduce Rule 62
NumberToken Reduce Rule 62
return Reduce Rule 62
StringToken Reduce Rule 62
trap Reduce Rule 62
UnaryOperatorToken Reduce Rule 62
VariableToken Reduce Rule 62

LALR State 160
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
Actions
(EOF) Reduce Rule 61
'$(' Reduce Rule 61
'(' Reduce Rule 61
')' Reduce Rule 61
'@(' Reduce Rule 61
'}' Reduce Rule 61
AnyWordToken Reduce Rule 61
AttributeSpecificationToken Reduce Rule 61
break Reduce Rule 61
CommentToken Reduce Rule 61
continue Reduce Rule 61
do Reduce Rule 61
ExecCall Reduce Rule 61
ExpandableStringToken Reduce Rule 61
finally Reduce Rule 61
foreach Reduce Rule 61
if Reduce Rule 61
LoopLabelToken Reduce Rule 61
NewLine Reduce Rule 61
NumberToken Reduce Rule 61
return Reduce Rule 61
StringToken Reduce Rule 61
trap Reduce Rule 61
UnaryOperatorToken Reduce Rule 61
VariableToken Reduce Rule 61

LALR State 161
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
<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 166

LALR State 162
Configuration Lookahead
<parseCallRule> ::= '(' · <arrayLiteralRule> ')' 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
<arrayLiteralRule> ::= · <postfixOperatorRule> )
<arrayLiteralRule> ::= · <postfixOperatorRule> CommaToken <arrayLiteralRule> )
<postfixOperatorRule> ::= · <lvalueExpression> PrePostfixOperatorToken ) CommaToken
<postfixOperatorRule> ::= · <propertyOrArrayReferenceRule> ) CommaToken
<propertyOrArrayReferenceRule> ::= · <valueRule> ) CommaToken
<propertyOrArrayReferenceRule> ::= · <valueRule> <propertyOrArrayReferenceOperatorList> ) CommaToken
<valueRule> ::= · '(' <assignmentStatementRule> ')' ) [ CommaToken
<valueRule> ::= · '$(' <statementListRule> ')' ) [ CommaToken
<valueRule> ::= · '@(' <statementListRule> ')' ) [ CommaToken
<valueRule> ::= · UnaryOperatorToken <propertyOrArrayReferenceRule> ) [ CommaToken
<valueRule> ::= · AttributeSpecificationToken <propertyOrArrayReferenceRule> ) [ CommaToken
<valueRule> ::= · AttributeSpecificationToken ) [ CommaToken
<valueRule> ::= · NumberToken ) [ CommaToken
<valueRule> ::= · StringToken ) [ CommaToken
<valueRule> ::= · ExpandableStringToken ) [ CommaToken
<valueRule> ::= · VariableToken ) [ CommaToken
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 167
<lvalue> Goto 37
<lvalueExpression> Goto 111
<postfixOperatorRule> Goto 41
<propertyOrArrayReferenceRule> Goto 42
<valueRule> Goto 47

LALR State 163
Configuration Lookahead
<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
Actions
(EOF) Reduce Rule 94
'$(' Reduce Rule 94
'(' Reduce Rule 94
')' Reduce Rule 94
'@(' Reduce Rule 94
'[' Reduce Rule 94
']' Reduce Rule 94
'|' Reduce Rule 94
'}' Reduce Rule 94
AdditionOperatorToken Reduce Rule 94
AnyWordToken Reduce Rule 94
AssignmentOperatorToken Reduce Rule 94
AttributeSpecificationToken Reduce Rule 94
BitwiseOperatorToken Reduce Rule 94
break Reduce Rule 94
CommaToken Reduce Rule 94
CommentToken Reduce Rule 94
ComparisonOperatorToken Reduce Rule 94
continue Reduce Rule 94
do Reduce Rule 94
ExecCall Reduce Rule 94
ExpandableStringToken Reduce Rule 94
finally Reduce Rule 94
foreach Reduce Rule 94
FormatOperatorToken Reduce Rule 94
if Reduce Rule 94
LogicalOperatorToken Reduce Rule 94
LoopLabelToken Reduce Rule 94
MultiplyOperatorToken Reduce Rule 94
NewLine Reduce Rule 94
NumberToken Reduce Rule 94
ParameterToken Reduce Rule 94
PrePostfixOperatorToken Reduce Rule 94
RangeOperatorToken Reduce Rule 94
return Reduce Rule 94
StringToken Reduce Rule 94
trap Reduce Rule 94
UnaryOperatorToken Reduce Rule 94
VariableToken Reduce Rule 94

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

LALR State 165
Configuration Lookahead
<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
(EOF) Reduce Rule 41
'$(' Reduce Rule 41
'(' Reduce Rule 41
')' Reduce Rule 41
'@(' Reduce Rule 41
'}' Reduce Rule 41
AnyWordToken Reduce Rule 41
AttributeSpecificationToken Reduce Rule 41
break Reduce Rule 41
CommentToken Reduce Rule 41
continue Reduce Rule 41
do Reduce Rule 41
ExecCall Reduce Rule 41
ExpandableStringToken Reduce Rule 41
finally Reduce Rule 41
foreach Reduce Rule 41
if Reduce Rule 41
LoopLabelToken Reduce Rule 41
NewLine Reduce Rule 41
NumberToken Reduce Rule 41
return Reduce Rule 41
StringToken Reduce Rule 41
trap Reduce Rule 41
UnaryOperatorToken Reduce Rule 41
VariableToken Reduce Rule 41

LALR State 166
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
(EOF) Reduce Rule 58
'$(' Reduce Rule 58
'(' Reduce Rule 58
')' Reduce Rule 58
'@(' Reduce Rule 58
'}' Reduce Rule 58
AnyWordToken Reduce Rule 58
AttributeSpecificationToken Reduce Rule 58
break Reduce Rule 58
CommentToken Reduce Rule 58
continue Reduce Rule 58
do Reduce Rule 58
ExecCall Reduce Rule 58
ExpandableStringToken Reduce Rule 58
finally Reduce Rule 58
foreach Reduce Rule 58
if Reduce Rule 58
LoopLabelToken Reduce Rule 58
NewLine Reduce Rule 58
NumberToken Reduce Rule 58
return Reduce Rule 58
StringToken Reduce Rule 58
trap Reduce Rule 58
UnaryOperatorToken Reduce Rule 58
VariableToken Reduce Rule 58

LALR State 167
Configuration Lookahead
<parseCallRule> ::= '(' <arrayLiteralRule> · ')' 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 169

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

LALR State 169
Configuration Lookahead
<parseCallRule> ::= '(' <arrayLiteralRule> ')' · 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 96
'$(' Reduce Rule 96
'(' Reduce Rule 96
')' Reduce Rule 96
'@(' Reduce Rule 96
'[' Reduce Rule 96
']' Reduce Rule 96
'|' Reduce Rule 96
'}' Reduce Rule 96
AdditionOperatorToken Reduce Rule 96
AnyWordToken Reduce Rule 96
AssignmentOperatorToken Reduce Rule 96
AttributeSpecificationToken Reduce Rule 96
BitwiseOperatorToken Reduce Rule 96
break Reduce Rule 96
CommaToken Reduce Rule 96
CommentToken Reduce Rule 96
ComparisonOperatorToken Reduce Rule 96
continue Reduce Rule 96
do Reduce Rule 96
ExecCall Reduce Rule 96
ExpandableStringToken Reduce Rule 96
finally Reduce Rule 96
foreach Reduce Rule 96
FormatOperatorToken Reduce Rule 96
if Reduce Rule 96
LogicalOperatorToken Reduce Rule 96
LoopLabelToken Reduce Rule 96
MultiplyOperatorToken Reduce Rule 96
NewLine Reduce Rule 96
NumberToken Reduce Rule 96
ParameterToken Reduce Rule 96
PrePostfixOperatorToken Reduce Rule 96
RangeOperatorToken Reduce Rule 96
return Reduce Rule 96
StringToken Reduce Rule 96
trap Reduce Rule 96
UnaryOperatorToken Reduce Rule 96
VariableToken Reduce Rule 96

LALR State 170
Configuration Lookahead
<elseIfBlockRule> ::= elseif '(' <pipelineRule> ')' <statementBlockRule> · EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do else ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<elseIfBlockRule> ::= elseif '(' <pipelineRule> ')' <statementBlockRule> · <elseIfBlockRule> EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do else ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<elseIfBlockRule> ::= · elseif '(' <pipelineRule> ')' <statementBlockRule> EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do else ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
<elseIfBlockRule> ::= · elseif '(' <pipelineRule> ')' <statementBlockRule> <elseIfBlockRule> EOF $( ( ) @( } AnyWordToken AttributeSpecificationToken break CommentToken continue do else ExecCall ExpandableStringToken finally foreach if LoopLabelToken NewLine NumberToken return StringToken trap UnaryOperatorToken VariableToken
Actions
elseif Shift 149
<elseIfBlockRule> Goto 171
(EOF) Reduce Rule 36
'$(' Reduce Rule 36
'(' Reduce Rule 36
')' Reduce Rule 36
'@(' Reduce Rule 36
'}' Reduce Rule 36
AnyWordToken Reduce Rule 36
AttributeSpecificationToken Reduce Rule 36
break Reduce Rule 36
CommentToken Reduce Rule 36
continue Reduce Rule 36
do Reduce Rule 36
else Reduce Rule 36
ExecCall Reduce Rule 36
ExpandableStringToken Reduce Rule 36
finally Reduce Rule 36
foreach Reduce Rule 36
if Reduce Rule 36
LoopLabelToken Reduce Rule 36
NewLine Reduce Rule 36
NumberToken Reduce Rule 36
return Reduce Rule 36
StringToken Reduce Rule 36
trap Reduce Rule 36
UnaryOperatorToken Reduce Rule 36
VariableToken Reduce Rule 36

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



Log
Section Type Line/State Name
Grammar Details   $( was implicitly defined
Grammar Details   ( was implicitly defined
Grammar Details   ) was implicitly defined
Grammar Details   @( was implicitly defined
Grammar Details   [ was implicitly defined
Grammar Details   ] was implicitly defined
Grammar Details   { was implicitly defined
Grammar Details   | was implicitly defined
Grammar Details   } was implicitly defined
Grammar Details   break was implicitly defined
Grammar Details   -casesensitive was implicitly defined
Grammar Details   continue was implicitly defined
Grammar Details   default was implicitly defined
Grammar Details   do was implicitly defined
Grammar Details   else was implicitly defined
Grammar Details   elseif was implicitly defined
Grammar Details   -exact was implicitly defined
Grammar Details   -file was implicitly defined
Grammar Details   finally was implicitly defined
Grammar Details   foreach was implicitly defined
Grammar Details   if was implicitly defined
Grammar Details   in was implicitly defined
Grammar Details   -regex was implicitly defined
Grammar Details   return was implicitly defined
Grammar Details   switch was implicitly defined
Grammar Details   trap was implicitly defined
Grammar Details   until was implicitly defined
Grammar Details   while was implicitly defined
Grammar Details   -wildcard was implicitly defined
Grammar Details   Whitespace is variable length.
Grammar Details   AnyWordToken is variable length.
Grammar Details   AttributeSpecificationToken is variable length.
Grammar Details   CommentToken is variable length.
Grammar Details   LoopLabelToken is variable length.
Grammar Details   NumberToken is variable length.
Grammar Details   ParameterToken is variable length.
Grammar Details   StringToken is variable length.
Grammar Details   VariableToken is variable length.
Grammar Details   The grammar contains a total of 54 formal terminals.
Grammar Warning   Unreachable rule: <switchBody>
Grammar Warning   Unreachable rule: <switchCasesensitiveParameterRule>
Grammar Warning   Unreachable rule: <switchParameterRule>
Grammar Warning   Unreachable rule: <switchSelectorStatementRule>
Grammar Warning   Unreachable rule: <switchStatementRule>
Grammar Warning   Unreachable rule: <switchTypeStatementRule>
Grammar Warning   Unused terminal: -casesensitive
Grammar Warning   Unused terminal: default
Grammar Warning   Unused terminal: -exact
Grammar Warning   Unused terminal: -file
Grammar Warning   Unused terminal: FunctionDeclarationToken
Grammar Warning   Unused terminal: RedirectionOperatorToken
Grammar Warning   Unused terminal: -regex
Grammar Warning   Unused terminal: switch
Grammar Warning   Unused terminal: -wildcard
Grammar Success   The grammar was successfully analyzed
LALR States Details   The temporary First and Nullable tables were successfully created
LALR States Warning 5 A Shift-Reduce Conflict was fixed
LALR States Warning 6 A Shift-Reduce Conflict was fixed
LALR States Warning 8 A Shift-Reduce Conflict was fixed
LALR States Warning 21 A Shift-Reduce Conflict was fixed
LALR States Warning 24 A Shift-Reduce Conflict was fixed
LALR States Warning 26 A Shift-Reduce Conflict was fixed
LALR States Warning 27 A Shift-Reduce Conflict was fixed
LALR States Warning 47 A Shift-Reduce Conflict was fixed
LALR States Warning 54 A Shift-Reduce Conflict was fixed
LALR States Warning 55 A Shift-Reduce Conflict was fixed
LALR States Warning 63 A Shift-Reduce Conflict was fixed
LALR States Warning 84 A Shift-Reduce Conflict was fixed
LALR States Warning 95 A Shift-Reduce Conflict was fixed
LALR States Warning 154 A Shift-Reduce Conflict was fixed
LALR States Details   LALR computation took: 0 Hours 0 Minutes 2 Seconds
LALR States Success   The LALR Table was succesfully created
LALR States Details   Total actions: 493 Shifts, 2579 Reduces, 497 Gotos, 1 Accepts.
DFA States Details   The initial Nondeterministic Finite Automata has 833 states
DFA States Success   The DFA State Table was successfully created
DFA States Details   DFA computation took: 0 Hours 0 Minutes 5 Seconds