Pash (PowerShell-like) Grammar


Syntax


<statementSeparatorToken>
    ::= NewLine <statementSeparatorToken>
    |  

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

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

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

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

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

<lvalueExpression>
    ::= <lvalue>

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

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

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

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

<cmdletName>
    ::= AnyWordToken

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

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

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

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

<switchCasesensitiveParameterRule>
    ::= -casesensitive
    |  

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

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

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

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

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

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

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

<finallyStatementRule>
    ::= finally <statementBlockRule>

<flowControlPropertyBody>
    ::= <propertyOrArrayReferenceRule>

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

<expressionRule>
    ::= <logicalExpressionRule>

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

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

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

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

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

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

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

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

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

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

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

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

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


Grammar


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

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

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

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

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

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

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

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

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

{HexNumber} = {Number} + [abcdefABCDEF]

{SimpleAlphaNumeric} = {AlphaNumeric}

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

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

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

LogicalOperatorToken = '-and' | '-or'

BitwiseOperatorToken = '-band' | '-bor'

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

FunctionDeclarationToken = 'function' | 'filter'

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

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

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

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

! <CallArguementSeparatorToken> = ' |'

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

!MinusMinusToken = '--'

RangeOperatorToken = '..'

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

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

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

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

FormatOperatorToken = '-f'

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

! ParameterToken = 'param'

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

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

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

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

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

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

AnyWordToken = {SimpleTextCharSetNoDashAndNumber}{SimpleTextCharSet}+

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

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

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

<statementSeparatorToken> ::= NewLine <statementSeparatorToken>
                            | 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

! <redirectionRule> = <redirectionOperatorToken> <propertyOrArrayReferenceRule>

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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


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

<expressionRule> ::= <logicalExpressionRule>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


Data Tables


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


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


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


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


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


DFA States


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

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

DFA State 2
Action Characters
Accept '('  

DFA State 3
Action Characters
Accept ')'  

DFA State 4
Action Characters
Accept ']'  

DFA State 5
Action Characters
Accept '|'  

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

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

DFA State 8
Action Characters
Accept AssignmentOperatorToken  

DFA State 9
Action Characters
Accept CommaToken  

DFA State 10
Action Characters
Accept NewLine  

DFA State 11
Action Characters
Goto 12 :

DFA State 12
Action Characters
Accept ReferenceOperatorToken  

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

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

DFA State 15
Action Characters
Accept StringToken  

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

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

DFA State 18
Action Characters
Accept StringToken  

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

DFA State 20
Action Characters
Accept NewLine  

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

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

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

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

DFA State 25
Action Characters
Accept '$('  

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

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

DFA State 28
Action Characters
Accept AssignmentOperatorToken  

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

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

DFA State 31
Action Characters
Accept AssignmentOperatorToken  

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

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

DFA State 34
Action Characters
Accept AssignmentOperatorToken  

DFA State 35
Action Characters
Accept PrePostfixOperatorToken  

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

DFA State 37
Action Characters
Accept AssignmentOperatorToken