/// <summary>
/// Parses an expression operand into an IExpressionContainer
/// </summary>
/// <returns>The next token.</returns>
/// <param name="token">Token.</param>
/// <param name="parent">An IExpressionContainer.</param>
private Token ParseOperand(Token token, IExpressionContainer parent)
{
// an operand can be an integer, string, boolean, variable or an expression
// check the token's type to know what we're parsing
switch (token.Type)
{
case TokenType.INT_VAL:
ParseIntegerOperand(token, parent);
break;
case TokenType.STR_VAL:
nodeBuilder.CreateStringValueNode(token, parent);
break;
case TokenType.BOOL_VAL:
nodeBuilder.CreateBoolValueNode(token, parent);
break;
case TokenType.ID:
nodeBuilder.CreateIdNode(token, parent);
break;
case TokenType.PARENTHESIS_LEFT:
Token next = ParseExpression(scanner.getNextToken(token), parent);
match(next, TokenType.PARENTHESIS_RIGHT);
break;
default:
throw new UnexpectedTokenException(token, TokenType.UNDEFINED, ParserConstants.EXPECTATION_SET_EXPRESSION);
}
return(scanner.getNextToken(token));
}
private static bool TryEvaluateExpression <T>(Activity <T> expression, LocationReferenceEnvironment locationReferenceEnvironment, ActivityContext context, out object result)
{
T local;
if (!expression.TryGetValue(context, out local))
{
result = System.Activities.SR.DebugInfoTryGetValueFailed;
return(false);
}
Activity rootActivity = local as Activity;
context.Activity = rootActivity;
if ((rootActivity != null) && !rootActivity.IsRuntimeReady)
{
WorkflowInspectionServices.CacheMetadata(rootActivity, locationReferenceEnvironment);
}
IExpressionContainer container = local as IExpressionContainer;
if (container == null)
{
result = System.Activities.SR.DebugInfoNotAnIExpressionContainer;
return(false);
}
Expression <Func <ActivityContext, object> > expression2 = container.Expression as Expression <Func <ActivityContext, object> >;
if (expression2 == null)
{
result = System.Activities.SR.DebugInfoNoLambda;
return(false);
}
result = expression2.Compile()(context);
return(true);
}
/// <summary>
/// Parses the an expression into a node that implements IExpressionContainer interface.
/// </summary>
/// <returns>The next token.</returns>
/// <param name="token">Token.</param>
/// <param name="node">An IExpressionContainer.</param>
private Token ParseExpression(Token token, IExpressionContainer node)
{
Token next;
switch (token.Type)
{
case TokenType.INT_VAL:
case TokenType.STR_VAL:
case TokenType.BOOL_VAL:
case TokenType.PARENTHESIS_LEFT:
case TokenType.ID:
// parse a binary operation
BinOpNode binOp = nodeBuilder.CreateBinOpNode(node, token);
// parse the first operand
next = ParseOperand(token, binOp);
// parse the rest of the operation
return(ParseBinaryOp(next, binOp));
case TokenType.UNARY_OP_LOG_NEG:
// parse a unary operation
UnOpNode unOp = nodeBuilder.CreateUnOpNode(node, token);
// parse the operation, then the operand
next = ParseUnaryOp(token, unOp);
return(ParseOperand(next, unOp));
default:
throw new UnexpectedTokenException(token, TokenType.UNDEFINED, ParserConstants.EXPECTATION_SET_EXPRESSION);
}
}
public IExpressionNode CreateIdNode(Token t, IExpressionContainer parent)
{
VariableIdNode node = new VariableIdNode(t.Value, symbolTable, t);
parent.AddExpression(node);
return(node);
}
public UnOpNode CreateUnOpNode(IExpressionContainer parent, Token t)
{
UnOpNode unOp = new UnOpNode(t);
parent.AddExpression(unOp);
return(unOp);
}
public IExpressionNode CreateDefaultBoolValueNode(Token t, IExpressionContainer parent)
{
BoolValueNode node = new BoolValueNode(SemanticAnalysisConstants.DEFAULT_BOOL_VALUE, t);
parent.AddExpression(node);
return(node);
}
public IExpressionNode CreateDefaultIntValueNode(Token t, IExpressionContainer parent)
{
IntValueNode node = new IntValueNode(SemanticAnalysisConstants.DEFAULT_INTEGER_VALUE, t);
parent.AddExpression(node);
return(node);
}
public BinOpNode CreateBinOpNode(IExpressionContainer parent, Token t)
{
BinOpNode binOp = new BinOpNode(t);
parent.AddExpression(binOp);
return(binOp);
}
public IExpressionNode CreateDefaultStringValueNode(Token t, IExpressionContainer parent)
{
StringValueNode node = new StringValueNode(SemanticAnalysisConstants.DEFAULT_STRING_VALUE, t);
parent.AddExpression(node);
return(node);
}
public IExpressionNode CreateBoolValueNode(Token t, IExpressionContainer parent)
{
bool value = StringUtils.parseToBoolean(t.Value);
BoolValueNode node = new BoolValueNode(value, t);
parent.AddExpression(node);
return(node);
}
public IExpressionNode CreateStringValueNode(Token t, IExpressionContainer parent)
{
string value = t.Value;
StringValueNode node = new StringValueNode(value, t);
parent.AddExpression(node);
return(node);
}
public IExpressionNode CreateIntValueNode(Token t, IExpressionContainer parent)
{
int value = StringUtils.parseToInt(t.Value);
IntValueNode node = new IntValueNode(value, t);
parent.AddExpression(node);
return(node);
}
public BinOpNode CreateBinOpNode(IExpressionContainer parent, IExpressionNode leftHandSide, Token operation)
{
BinOpNode binOp = new BinOpNode(parent.Token);
binOp.AddExpression(leftHandSide);
binOp.Operation = operation.Type;
parent.AddExpression(binOp);
return(binOp);
}
/// <summary>
/// Parses an integer operand into an IExpressionContainer
/// </summary>
/// <param name="token">Token.</param>
/// <param name="parent">An IExpressionContainer.</param>
private void ParseIntegerOperand(Token token, IExpressionContainer parent)
{
try {
// try to create an IntValueNode for the value
nodeBuilder.CreateIntValueNode(token, parent);
} catch (OverflowException) {
// In case the token's value is an integer that cannot be represented as a
// signed 32-bit integer, an OverflowException is thrown.
// In this case, the parses reports an IntegerOverflowError.
notifyError(new IntegerOverflowError(token));
nodeBuilder.CreateDefaultIntValueNode(token, parent);
}
}
public IExpressionNode CreateValueNode(Token t, IExpressionContainer node, TokenType valueType)
{
switch (valueType)
{
case TokenType.INT_VAL:
return(CreateIntValueNode(t, node));
case TokenType.STR_VAL:
return(CreateStringValueNode(t, node));
case TokenType.BOOL_VAL:
return(CreateBoolValueNode(t, node));
default:
throw new ArgumentException();
}
}
public static string PrepareExpression(string withEmbedded, IExpressionContainer container, string idString, ParserValidationDelegate vd)
{
string checkExpression = withEmbedded;
string retVal = String.Empty;
int leftBrace = 0;
int startPos = 0;
for (leftBrace = checkExpression.IndexOf("{", startPos); startPos >= 0; leftBrace = checkExpression.IndexOf("{", startPos))
{
if (leftBrace == -1)
{
// No more strings to replace.
retVal += checkExpression.Substring(startPos, checkExpression.Length - startPos);
break;
}
else
{
// Concatenate portion of string without embedded references.
retVal += checkExpression.Substring(startPos, leftBrace - startPos);
}
int rightBrace = checkExpression.IndexOf("}", leftBrace);
if (rightBrace == -1)
{
if (vd != null)
{
vd(ParserValidationArgs.NewError("The " + idString + " has a left brace({} with no corresonding right brace(}}"));
}
return("");
}
// Isolate the property reference and concatenate it's expansion.
string expressionReference = checkExpression.Substring(leftBrace + 1, rightBrace - leftBrace - 1);
retVal += container.GetExpressionSubstitution(expressionReference, idString, vd);
// On to the next reference.
startPos = rightBrace + 1;
}
return(retVal);
}
public MainWindow(
ILanguageContainer languageContainer,
IMathExpressionService mathService,
IFileService fileService,
IExpressionExtractor expressionExtractor,
IExpressionContainer expressionContainer)
{
InitializeComponent();
this.languageContainer = languageContainer;
this.mathService = mathService;
this.expressionExtractor = expressionExtractor;
this.fileService = fileService;
this.expressionContainer = expressionContainer;
this.checkedOperations = new HashSet <ExpressionOperation>();
this.InitializeLanguages();
this.CheckExpressionOperations();
this.SetInitialData();
this.InitializeExpressionTypes();
this.ClearAlertBox();
}
public static Expression ToLambda(this IExpressionContainer expressionContainer)
{
return(Expression.Lambda(expressionContainer.Expression));
}
public ExpressionBuilder(IParser parser, IExpressionContainer expressionContainer)
{
_parser = parser;
_expressionContainer = expressionContainer;
}