C# Class ComponentFactory.Quicksilver.Binding.Eval

Accept and evaluate simple expressions using a specific .NET language syntax/semantics.

C# is implemented using the following LL(1) BNF. ------------------------------------------------ expression ::= condOr cond2 cond2 ::= '?' expression ':' expression | '??' expression | {empty} condOr ::= condAnd condOr2 condOr2 ::= '||' condAnd condOr2 | {empty} condAnd ::= logicalOr condAnd2 condAnd2 ::= '&&' logicalOr condAnd2 | {empty} logicalOr ::= logicalXor logicalOr2 logicalOr2 ::= '|' logicalXor logicalOr2 | {empty} logicalXor ::= logicalAnd logicalXor2 logicalXor2 ::= '^' logicalAnd logicalXor2 | {empty} logicalAnd ::= equality logicalAnd2 logicalAnd2 ::= '&' equality logicalAnd2 | {empty} equality ::= relational equality2 equality2 ::= '==' relational equality2 | '!=' relational equality2 | {empty} relational ::= shift relational2 relational2 ::= '<' shift relational2 | '>' shift relational2 | '<=' shift relational2 | '>=' shift relational2 | {empty} shift ::= addsub shift2 shift2 ::= '<<' addsub shift2 | '>>' addsub shift2 | {empty} addsub ::= term expression2 expression2 ::= '+' term expression2 | '-' term expression2 | {empty} term ::= factor term2 term2 ::= '*' factor term2 | '/' factor term2 | '%' factor term2 | {empty} factor ::= '+' factor | '-' factor | '!' factor | '~' factor | access access ::= primary access2 access2 ::= '.' identifier methodcall access2 | '[' arglist1 ']' access2 | {empty} methodcall ::= '(' arglist ')' | {empty} primary ::= integer-literal | real-literal | boolean-literal | char-literal | string-literal | identifier | '(' expression ')' arglist ::= expression arglist2 | {empty} arglist1 ::= expression arglist2 | arglist2 ::= ',' expression arglist2 | {empty} VB.NET is implemented using the following LL(1) BNF. ---------------------------------------------------- expression ::= logicalOrVB logicalXor2VB logicalXor2VB ::= 'Xor' logicalOrVB logicalXor2VB | {empty} logicalOrVB ::= logicalAndVB logicalOr2VB logicalOr2VB ::= 'Or' logicalAndVB logicalOr2VB | 'OrElse' logicalAndVB logicalOr2VB | {empty} logicalAndVB ::= logicalNotVB logicalAnd2VB logicalAnd2VB ::= 'And' logicalNotVB logicalAnd2VB | 'AndAlso' logicalNotVB logicalAnd2VB | {empty} logicalNotVB ::= "Not' logicalNotVB | relationalVB relationalVB ::= shiftVB relational2VB relational2VB ::= '<' shiftVB relational2VB | '>' shiftVB relational2VB | '<=' shiftVB relational2VB | '>=' shiftVB relational2VB | '=' shiftVB relational2VB | '<>' shiftVB relational2VB | {empty} shiftVB ::= concatVB shift2VB shift2VB ::= '<<' concatVB shift2VB | '>>' concatVB shift2VB | {empty} concatVB ::= addsubVB concat2VB concat2VB ::= '&' addsubVB concat2VB | {empty} addsubVB ::= modVB addsub2VB addsub2VB ::= '+' modVB addsub2VB | '-' modVB addsub2VB | {empty} modVB ::= intdivVB mod2VB mod2VB ::= 'Mod' intdivVB mod2VB | {empty} intdivVB ::= termVB intdiv2VB intdiv2VB ::= '\' termVB intdiv2VB | {empty} termVB ::= factorVB term2VB term2VB ::= '*' factorVB term2VB | '/' factorVB term2VB | {empty} factorVB ::= '+' factorVB | '-' factorVB | expoVB expoVB ::= accessVB expo2VB expo2VB ::= '^' accessVB expo2VB | {empty} accessVB ::= primary access2VB access2VB ::= '.' identifier methodcall access2VB | '(' arglist1 ')' access2VB | {empty} methodcall ::= '(' arglist ')' | {empty} primary ::= integer-literal | real-literal | boolean-literal | char-literal | string-literal | identifier | '(' expression ')' arglist ::= expression arglist2 | {empty} arglist1 ::= expression arglist2 | arglist2 ::= ',' expression arglist2 | {empty}

Inheritance: Arithmetic

Mostra file Open project: ComponentFactory/Quicksilver Class Usage Examples

Public Methods

Method	Description
Eval ( ) : System	Initialize a new instance of the Eval class.
Eval ( System.Language language ) : System	Initialize a new instance of the Eval class.
Eval ( string input ) : System	Initialize a new instance of the Eval class.
Eval ( string input, System.Language language ) : System	Initialize a new instance of the Eval class.
PerformResolveIdentifier ( string identifier ) : object	Attempt to resolve the provided identifier into a value.

Protected Methods

Method	Description
OnResolveIdentifier ( ResolveIdentifierEventArgs e ) : void	Raises the ResolveIdentifier event.
ParseAccess ( ) : EvalNode	Parse the 'access' rule. access ::= primary access2
ParseAccess2 ( ) : EvalNode	Process the 'term2' rule. access2 ::= '.' identifier methodcall access2 \| '[' arglist1 ']' access2 \| {empty}
ParseAccess2VB ( ) : EvalNode	Process the 'access2VB' rule. access2VB ::= '.' identifier methodcall access2VB \| '(' arglist1 ')' access2VB \| {empty}
ParseAccessVB ( ) : EvalNode	Parse the 'accessVB' rule. accessVB ::= primary access2VB
ParseAddSub ( ) : EvalNode	Parse the 'addsub' rule. addsub ::= term expression2
ParseAddSub2VB ( ) : EvalNode	Process the 'addsub2VB' rule. addsub2VB ::= '+' modVB addsub2VB \| '-' modVB addsub2VB \| {empty}
ParseAddSubVB ( ) : EvalNode	Parse the 'addsubVB' rule. addsubVB ::= modVB addsub2VB
ParseArgList ( ) : EvalNode	Process the 'arglist' rule. arglist ::= expression arglist2 \| {empty}
ParseArgList1 ( ) : EvalNode	Process the 'arglist1' rule. arglist1 ::= expression arglist2 \|
ParseArgList2 ( ) : EvalNodeArgList	Process the 'arglist2' rule. arglist2 ::= ',' expression arglist2 \| {empty}
ParseConcat2VB ( ) : EvalNode	Process the 'concat2VB' rule. concat2VB ::= '&' addsubVB concat2VB \| {empty}
ParseConcatVB ( ) : EvalNode	Parse the 'concatVB' rule. concatVB ::= addsubVB concat2VB
ParseCond2 ( ) : EvalNode	Parse the 'cond2' rule. cond2 ::= '?' expression ':' expression \| '??' expression \| {empty}
ParseCondAnd ( ) : EvalNode	Parse the 'condAnd' rule. condAnd ::= logicalOr condAnd2
ParseCondAnd2 ( ) : EvalNode	Parse the 'condAnd2' rule. condAnd2 ::= '&&' logicalOr condAnd2 \| {empty}
ParseCondOr ( ) : EvalNode	Parse the 'condOr' rule. condOr ::= condAnd condOr2
ParseCondOr2 ( ) : EvalNode	Parse the 'condOr2' rule. condOr2 ::= '\|\|' condAnd condOr2 \| {empty}
ParseEquality ( ) : EvalNode	Parse the 'equality' rule. equality ::= relational equality2
ParseEquality2 ( ) : EvalNode	Parse the 'equality2' rule. equality2 ::= '==' relational equality2 \| '!=' relational equality2 \| {empty}
ParseExpo2VB ( ) : EvalNode	Parse the 'expo2VB' rule. expo2VB ::= '^' accessVB expo2VB \| {empty}
ParseExpoVB ( ) : EvalNode	Parse the 'expoVB' rule. expoVB ::= accessVB expo2VB
ParseExpression ( ) : EvalNode	Parse the 'expression' rule. expression ::= condOr cond2
ParseExpressionCS ( ) : EvalNode	Parse the 'expression' rule. expression ::= condOr cond2
ParseExpressionVB ( ) : EvalNode	Parse the 'expression' rule. expression ::= logicalOrVB logicalXor2VB
ParseFactor ( ) : EvalNode	Parse the 'factor' rule. factor ::= '+' factor \| '-' factor \| '!' factor \| '~' factor \| access
ParseFactorVB ( ) : EvalNode	Parse the 'factorVB' rule. factorVB ::= '+' factorVB \| '-' factorVB \| expoVB
ParseIntDiv2VB ( ) : EvalNode	Process the 'intdiv2VB' rule. intdiv2VB ::= '\' termVB intdiv2VB \| {empty}
ParseIntDivVB ( ) : EvalNode	Parse the 'intdivVB' rule. intdivVB ::= termVB intdiv2VB
ParseLogicalAnd ( ) : EvalNode	Parse the 'logicalAnd' rule. logicalAnd ::= equality logicalAnd2
ParseLogicalAnd2 ( ) : EvalNode	Parse the 'logicalAnd2' rule. logicalAnd2 ::= '&' equality logicalAnd2 \| {empty}
ParseLogicalAnd2VB ( ) : EvalNode	Parse the 'logicalAnd2VB' rule. logicalAnd2VB ::= 'And' logicalNotVB logicalAnd2VB \| 'AndAlso' logicalNotVB logicalAnd2VB \| {empty}
ParseLogicalAndVB ( ) : EvalNode	Parse the 'logicalAndVB' rule. logicalAndVB ::= logicalNotVB logicalAnd2VB
ParseLogicalNotVB ( ) : EvalNode	Parse the 'logicalNotVB' rule. logicalNotVB ::= 'Not' logicalNotVB \| relationalVB
ParseLogicalOr ( ) : EvalNode	Parse the 'logicalOr' rule. logicalOr ::= logicalXor logicalOr2
ParseLogicalOr2 ( ) : EvalNode	Parse the 'logicalOr2' rule. logicalOr2 ::= '\|' logicalXor logicalOr2 \| {empty}
ParseLogicalOr2VB ( ) : EvalNode	Parse the 'logicalOr2VB' rule. logicalOr2VB ::= 'Or' logicalAndVB logicalOr2VB \| 'OrElse' logicalAndVB logicalOr2VB \| {empty}
ParseLogicalOrVB ( ) : EvalNode	Parse the 'logicalOrVB' rule. logicalOrVB ::= logicalAndVB logicalOr2VB
ParseLogicalXor ( ) : EvalNode	Parse the 'logicalXor' rule. logicalXor ::= logicalAnd logicalXor2
ParseLogicalXor2 ( ) : EvalNode	Parse the 'logicalXor2' rule. logicalXor2 ::= '^' logicalAnd logicalXor2 \| {empty}
ParseLogicalXor2VB ( ) : EvalNode	Parse the 'logicalXor2VB' rule. logicalXor2VB ::= 'Xor' logicalOrVB logicalXor2VB \| {empty}
ParseMethodCall ( ) : EvalNode	Process the 'methodcall' rule. methodcall ::= '(' arglist ')' \| {empty}
ParseMod2VB ( ) : EvalNode	Process the 'mod2VB' rule. mod2VB ::= 'Mod' intdivVB mod2VB \| {empty}
ParseModVB ( ) : EvalNode	Parse the 'modVB' rule. modVB ::= intdivVB mod2VB
ParsePrimary ( ) : EvalNode	Parse the 'primary' rule. primary ::= integer-literal \| real-literal \| boolean-literal \| char-literal \| string-literal \| identifier \| '(' expression ')'
ParseRelational ( ) : EvalNode	Parse the 'relational' rule. relational ::= shift relational2
ParseRelational2 ( ) : EvalNode	Parse the 'relational2' rule. relational2 ::= '<' shift relational2 \| '>' shift relational2 \| '<=' shift relational2 \| '>=' shift relational2 \| {empty}
ParseRelational2VB ( ) : EvalNode	Parse the 'relational2VB' rule. relational2VB ::= '<' shiftVB relational2VB \| '>' shiftVB relational2VB \| '<=' shiftVB relational2VB \| '>=' shiftVB relational2VB \| '=' shiftVB relational2VB \| '<>' shiftVB relational2VB \| {empty}
ParseRelationalVB ( ) : EvalNode	Parse the 'relationalVB' rule. relationalVB ::= shiftVB relational2VB
ParseShift ( ) : EvalNode	Parse the 'shift' rule. shift ::= addsub shift2
ParseShift2 ( ) : EvalNode	Parse the 'shift2' rule. shift2 ::= '<<' addsub shift2 \| '>>' addsub shift2 \| {empty}
ParseShift2VB ( ) : EvalNode	Process the 'shift2VB' rule. shift2VB ::= '<<' concatVB shift2VB \| '>>' concatVB shift2VB \| {empty}
ParseShiftVB ( ) : EvalNode	Parse the 'shiftVB' rule. shiftVB ::= concatVB shift2VB
ParseTerm2 ( ) : EvalNode	Process the 'term2' rule. term2 ::= '*' factor term2 \| '/' factor term2 \| '%' factor term2 \| {empty}
ParseTerm2VB ( ) : EvalNode	Process the 'term2VB' rule. term2VB ::= '*' factorVB term2VB \| '/' factorVB term2VB \| {empty}
ParseTermVB ( ) : EvalNode	Parse the 'termVB' rule. termVB ::= factorVB term2VB

Method Details

Eval() public method

Initialize a new instance of the Eval class.

public Eval ( ) : System
return	System

Eval() public method

Initialize a new instance of the Eval class.

public Eval ( System.Language language ) : System
language	System.Language	Language used for parsing.
return	System

Eval() public method

Initialize a new instance of the Eval class.

public Eval ( string input ) : System
input	string	Input string to parse.
return	System

Eval() public method

Initialize a new instance of the Eval class.

public Eval ( string input, System.Language language ) : System
input	string	Input string to parse.
language	System.Language	Language used for parsing.
return	System

OnResolveIdentifier() protected method

Raises the ResolveIdentifier event.

protected OnResolveIdentifier ( ResolveIdentifierEventArgs e ) : void
e	ResolveIdentifierEventArgs	An ResolveIdentifierEventArgs containing the event data.
return	void

ParseAccess() protected method

Parse the 'access' rule.

access ::= primary access2

protected ParseAccess ( ) : EvalNode
return	EvalNode

ParseAccess2() protected method

Process the 'term2' rule.

access2 ::= '.' identifier methodcall access2 | '[' arglist1 ']' access2 | {empty}

protected ParseAccess2 ( ) : EvalNode
return	EvalNode

ParseAccess2VB() protected method

Process the 'access2VB' rule.

access2VB ::= '.' identifier methodcall access2VB | '(' arglist1 ')' access2VB | {empty}

protected ParseAccess2VB ( ) : EvalNode
return	EvalNode

ParseAccessVB() protected method

Parse the 'accessVB' rule.

accessVB ::= primary access2VB

protected ParseAccessVB ( ) : EvalNode
return	EvalNode

ParseAddSub() protected method

Parse the 'addsub' rule.

addsub ::= term expression2

protected ParseAddSub ( ) : EvalNode
return	EvalNode

ParseAddSub2VB() protected method

Process the 'addsub2VB' rule.

addsub2VB ::= '+' modVB addsub2VB | '-' modVB addsub2VB | {empty}

protected ParseAddSub2VB ( ) : EvalNode
return	EvalNode

ParseAddSubVB() protected method

Parse the 'addsubVB' rule.

addsubVB ::= modVB addsub2VB

protected ParseAddSubVB ( ) : EvalNode
return	EvalNode

ParseArgList() protected method

Process the 'arglist' rule.

arglist ::= expression arglist2 | {empty}

protected ParseArgList ( ) : EvalNode
return	EvalNode

ParseArgList1() protected method

Process the 'arglist1' rule.

arglist1 ::= expression arglist2 |

protected ParseArgList1 ( ) : EvalNode
return	EvalNode

ParseArgList2() protected method

Process the 'arglist2' rule.

arglist2 ::= ',' expression arglist2 | {empty}

protected ParseArgList2 ( ) : EvalNodeArgList
return	EvalNodeArgList

ParseConcat2VB() protected method

Process the 'concat2VB' rule.

concat2VB ::= '&' addsubVB concat2VB | {empty}

protected ParseConcat2VB ( ) : EvalNode
return	EvalNode

ParseConcatVB() protected method

Parse the 'concatVB' rule.

concatVB ::= addsubVB concat2VB

protected ParseConcatVB ( ) : EvalNode
return	EvalNode

ParseCond2() protected method

Parse the 'cond2' rule.

cond2 ::= '?' expression ':' expression | '??' expression | {empty}

protected ParseCond2 ( ) : EvalNode
return	EvalNode

ParseCondAnd() protected method

Parse the 'condAnd' rule.

condAnd ::= logicalOr condAnd2

protected ParseCondAnd ( ) : EvalNode
return	EvalNode

ParseCondAnd2() protected method

Parse the 'condAnd2' rule.

condAnd2 ::= '&&' logicalOr condAnd2 | {empty}

protected ParseCondAnd2 ( ) : EvalNode
return	EvalNode

ParseCondOr() protected method

Parse the 'condOr' rule.

condOr ::= condAnd condOr2

protected ParseCondOr ( ) : EvalNode
return	EvalNode

ParseCondOr2() protected method

Parse the 'condOr2' rule.

condOr2 ::= '||' condAnd condOr2 | {empty}

protected ParseCondOr2 ( ) : EvalNode
return	EvalNode

ParseEquality() protected method

Parse the 'equality' rule.

equality ::= relational equality2

protected ParseEquality ( ) : EvalNode
return	EvalNode

ParseEquality2() protected method

Parse the 'equality2' rule.

equality2 ::= '==' relational equality2 | '!=' relational equality2 | {empty}

protected ParseEquality2 ( ) : EvalNode
return	EvalNode

ParseExpo2VB() protected method

Parse the 'expo2VB' rule.

expo2VB ::= '^' accessVB expo2VB | {empty}

protected ParseExpo2VB ( ) : EvalNode
return	EvalNode

ParseExpoVB() protected method

Parse the 'expoVB' rule.

expoVB ::= accessVB expo2VB

protected ParseExpoVB ( ) : EvalNode
return	EvalNode

ParseExpression() protected method

Parse the 'expression' rule.

expression ::= condOr cond2

protected ParseExpression ( ) : EvalNode
return	EvalNode

ParseExpressionCS() protected method

Parse the 'expression' rule.

expression ::= condOr cond2

protected ParseExpressionCS ( ) : EvalNode
return	EvalNode

ParseExpressionVB() protected method

Parse the 'expression' rule.

expression ::= logicalOrVB logicalXor2VB

protected ParseExpressionVB ( ) : EvalNode
return	EvalNode

ParseFactor() protected method

Parse the 'factor' rule.

factor ::= '+' factor | '-' factor | '!' factor | '~' factor | access

protected ParseFactor ( ) : EvalNode
return	EvalNode

ParseFactorVB() protected method

Parse the 'factorVB' rule.

factorVB ::= '+' factorVB | '-' factorVB | expoVB

protected ParseFactorVB ( ) : EvalNode
return	EvalNode

ParseIntDiv2VB() protected method

Process the 'intdiv2VB' rule.

intdiv2VB ::= '\' termVB intdiv2VB | {empty}

protected ParseIntDiv2VB ( ) : EvalNode
return	EvalNode

ParseIntDivVB() protected method

Parse the 'intdivVB' rule.

intdivVB ::= termVB intdiv2VB

protected ParseIntDivVB ( ) : EvalNode
return	EvalNode

ParseLogicalAnd() protected method

Parse the 'logicalAnd' rule.

logicalAnd ::= equality logicalAnd2

protected ParseLogicalAnd ( ) : EvalNode
return	EvalNode

ParseLogicalAnd2() protected method

Parse the 'logicalAnd2' rule.

logicalAnd2 ::= '&' equality logicalAnd2 | {empty}

protected ParseLogicalAnd2 ( ) : EvalNode
return	EvalNode

ParseLogicalAnd2VB() protected method

Parse the 'logicalAnd2VB' rule.

logicalAnd2VB ::= 'And' logicalNotVB logicalAnd2VB | 'AndAlso' logicalNotVB logicalAnd2VB | {empty}

protected ParseLogicalAnd2VB ( ) : EvalNode
return	EvalNode

ParseLogicalAndVB() protected method

Parse the 'logicalAndVB' rule.

logicalAndVB ::= logicalNotVB logicalAnd2VB

protected ParseLogicalAndVB ( ) : EvalNode
return	EvalNode

ParseLogicalNotVB() protected method

Parse the 'logicalNotVB' rule.

logicalNotVB ::= 'Not' logicalNotVB | relationalVB

protected ParseLogicalNotVB ( ) : EvalNode
return	EvalNode

ParseLogicalOr() protected method

Parse the 'logicalOr' rule.

logicalOr ::= logicalXor logicalOr2

protected ParseLogicalOr ( ) : EvalNode
return	EvalNode

ParseLogicalOr2() protected method

Parse the 'logicalOr2' rule.

logicalOr2 ::= '|' logicalXor logicalOr2 | {empty}

protected ParseLogicalOr2 ( ) : EvalNode
return	EvalNode

ParseLogicalOr2VB() protected method

Parse the 'logicalOr2VB' rule.

logicalOr2VB ::= 'Or' logicalAndVB logicalOr2VB | 'OrElse' logicalAndVB logicalOr2VB | {empty}

protected ParseLogicalOr2VB ( ) : EvalNode
return	EvalNode

ParseLogicalOrVB() protected method

Parse the 'logicalOrVB' rule.

logicalOrVB ::= logicalAndVB logicalOr2VB

protected ParseLogicalOrVB ( ) : EvalNode
return	EvalNode

ParseLogicalXor() protected method

Parse the 'logicalXor' rule.

logicalXor ::= logicalAnd logicalXor2

protected ParseLogicalXor ( ) : EvalNode
return	EvalNode

ParseLogicalXor2() protected method

Parse the 'logicalXor2' rule.

logicalXor2 ::= '^' logicalAnd logicalXor2 | {empty}

protected ParseLogicalXor2 ( ) : EvalNode
return	EvalNode

ParseLogicalXor2VB() protected method

Parse the 'logicalXor2VB' rule.

logicalXor2VB ::= 'Xor' logicalOrVB logicalXor2VB | {empty}

protected ParseLogicalXor2VB ( ) : EvalNode
return	EvalNode

ParseMethodCall() protected method

Process the 'methodcall' rule.

methodcall ::= '(' arglist ')' | {empty}

protected ParseMethodCall ( ) : EvalNode
return	EvalNode

ParseMod2VB() protected method

Process the 'mod2VB' rule.

mod2VB ::= 'Mod' intdivVB mod2VB | {empty}

protected ParseMod2VB ( ) : EvalNode
return	EvalNode

ParseModVB() protected method

Parse the 'modVB' rule.

modVB ::= intdivVB mod2VB

protected ParseModVB ( ) : EvalNode
return	EvalNode

ParsePrimary() protected method

Parse the 'primary' rule.

protected ParsePrimary ( ) : EvalNode
return	EvalNode

ParseRelational() protected method

Parse the 'relational' rule.

relational ::= shift relational2

protected ParseRelational ( ) : EvalNode
return	EvalNode

ParseRelational2() protected method

Parse the 'relational2' rule.

relational2 ::= '<' shift relational2 | '>' shift relational2 | '<=' shift relational2 | '>=' shift relational2 | {empty}

protected ParseRelational2 ( ) : EvalNode
return	EvalNode

ParseRelational2VB() protected method

Parse the 'relational2VB' rule.

relational2VB ::= '<' shiftVB relational2VB | '>' shiftVB relational2VB | '<=' shiftVB relational2VB | '>=' shiftVB relational2VB | '=' shiftVB relational2VB | '<>' shiftVB relational2VB | {empty}

protected ParseRelational2VB ( ) : EvalNode
return	EvalNode

ParseRelationalVB() protected method

Parse the 'relationalVB' rule.

relationalVB ::= shiftVB relational2VB

protected ParseRelationalVB ( ) : EvalNode
return	EvalNode

ParseShift() protected method

Parse the 'shift' rule.

shift ::= addsub shift2

protected ParseShift ( ) : EvalNode
return	EvalNode

ParseShift2() protected method

Parse the 'shift2' rule.

shift2 ::= '<<' addsub shift2 | '>>' addsub shift2 | {empty}

protected ParseShift2 ( ) : EvalNode
return	EvalNode

ParseShift2VB() protected method

Process the 'shift2VB' rule.

shift2VB ::= '<<' concatVB shift2VB | '>>' concatVB shift2VB | {empty}

protected ParseShift2VB ( ) : EvalNode
return	EvalNode

ParseShiftVB() protected method

Parse the 'shiftVB' rule.

shiftVB ::= concatVB shift2VB

protected ParseShiftVB ( ) : EvalNode
return	EvalNode

ParseTerm2() protected method

Process the 'term2' rule.

term2 ::= '*' factor term2 | '/' factor term2 | '%' factor term2 | {empty}

protected ParseTerm2 ( ) : EvalNode
return	EvalNode

ParseTerm2VB() protected method

Process the 'term2VB' rule.

term2VB ::= '*' factorVB term2VB | '/' factorVB term2VB | {empty}

protected ParseTerm2VB ( ) : EvalNode
return	EvalNode

ParseTermVB() protected method

Parse the 'termVB' rule.

termVB ::= factorVB term2VB

protected ParseTermVB ( ) : EvalNode
return	EvalNode

PerformResolveIdentifier() public method

Attempt to resolve the provided identifier into a value.

public PerformResolveIdentifier ( string identifier ) : object
identifier	string	Identifier to resolve.
return	object