public override Expression VisitVariableDeclarationExpression(
DreamGrammarParser.VariableDeclarationExpressionContext context)
{
string type = context.children[0].GetText();
string variableName = context.children[1].GetText();
ParameterExpression expression = null;
switch (type)
{
case "int":
expression = Expression.Parameter(typeof(int), variableName);
break;
case "double":
expression = Expression.Parameter(typeof(double), variableName);
break;
case "string":
expression = Expression.Parameter(typeof(string), variableName);
break;
default:
throw new Exception("variable type not found");
}
//return base.VisitVariableDeclarationExpression(context);
return(expression);
}
private void GenerateBinaryIntExpression(DreamGrammarParser.VariableDeclarationExpressionContext context, string variableName,
List <Expression> variableExpressions)
{
ParameterExpression expression;
binaryExpressionStack.Push(BinaryExpressionTypes.Int);
expression = Expression.Variable(typeof(int), variableName);
variableExpressions.Add(expression);
const int expressionCount = 2;
if (context.ChildCount > expressionCount)
{
for (int iChildCount = expressionCount; iChildCount < context.ChildCount; iChildCount++)
{
var childExpression = context.children[iChildCount].Accept(this);
if (childExpression is ConstantExpression)
{
// Need to do some validation to ensure the operator is really an equal sign.
// Should be the only allowable operator for a variable declaration
if (!RemoveLeadingAndTrailingQuotes(childExpression.ToString()).Equals("="))
{
throw new Exception("Illegal assignment operator");
}
continue;
}
variableExpressions.Add(childExpression);
}
}
if (variableExpressions.Count == expressionCount)
{
//var assignExpression = Expression.Assign(variableExpressions[0], Expression.Constant(1));
var assignExpression = Expression.Assign(variableExpressions[0], variableExpressions[1]);
#if DEBUG
var tempExpression0 = new List <Expression>()
{
assignExpression
};
var tempExpression1 = new List <ParameterExpression>()
{
(ParameterExpression)variableExpressions[0]
};
tempExpression0.Add(Expression.Assign(variableExpressions[0], variableExpressions[1]));
var block = Expression.Block(tempExpression1, tempExpression0);
Expression.Lambda(block).Compile();
#endif
variableExpressions.RemoveAt(expressionCount - 1);
variableExpressions.Add(assignExpression);
}
binaryExpressionStack.Pop();
}
public override CSharpSyntaxNode VisitVariableDeclarationExpression([NotNull] DreamGrammarParser.VariableDeclarationExpressionContext context)
{
string variableName = context.variableDeclarationAssignment().variable().GetText();
var binaryExpression = new GenerateBinaryExpression();
binaryExpression.Walk(context)
.PostWalk()
.PrintPostFix()
.Eval();
return(binaryExpression.GetLocalDeclarationStatementSyntax());
}
public override Expression VisitVariableDeclarationExpression(
DreamGrammarParser.VariableDeclarationExpressionContext context)
{
string type = context.children[0].GetText();
string variableName = context.children[1].GetText();
var variableExpressions = new List <Expression>();
ParameterExpression expression = null;
var mulitipleExpressions = new DreamMulitipleVariableExpressions();
switch (type)
{
case "int":
GenerateBinaryIntExpression(context, variableName, variableExpressions);
break;
case "double":
binaryExpressionStack.Push(BinaryExpressionTypes.Double);
expression = Expression.Variable(typeof(double), variableName);
variableExpressions.Add(expression);
binaryExpressionStack.Pop();
break;
case "string":
binaryExpressionStack.Push(BinaryExpressionTypes.String);
expression = Expression.Variable(typeof(string), variableName);
var constantExpression = Expression.Constant(RemoveLeadingAndTrailingQuotes(context.children[3].GetText()));
var binaryExpression = Expression.Assign(
expression,
constantExpression);
variableExpressions.Add(expression);
variableExpressions.Add(binaryExpression);
#if DEBUG
try
{
// Push a WriteLine into the expression list
// to debug the variable assignement.
var variableType = variableExpressions.GetType();
var writeLineExpression = Expression.Call(null,
typeof(Trace).GetMethod("WriteLine", new Type[] { typeof(object) }) ??
throw new InvalidOperationException(),
expression);
variableExpressions.Add(writeLineExpression);
}
catch (Exception ex)
{
Debug.Assert(true, ex.Message);
}
#endif
binaryExpressionStack.Pop();
break;
default:
throw new Exception("variable type not found");
}
mulitipleExpressions.AddExpressions(variableExpressions.ToArray());
return(mulitipleExpressions);
}