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

"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