private static ITextExpression TranslateExpression(ParseTreeNode exprNode)
{
exprNode.Assert(TextExpressionDslParseNodeNames.Expression);
var childNode = exprNode.ChildNodes[0];
switch (childNode.Term.Name)
{
case TextExpressionDslParseNodeNames.DqString:
return(TranslateDqString(childNode));
case TextExpressionDslParseNodeNames.SqString:
return(TranslateSqString(childNode));
case TextExpressionDslParseNodeNames.LiteralNumber:
return(TranslateLiteralNumber(childNode));
case TextExpressionDslParseNodeNames.QualifiedIdentifier:
return(TranslateQualifiedIdentifier(childNode));
case TextExpressionDslParseNodeNames.List:
return(TranslateList(childNode));
case TextExpressionDslParseNodeNames.Dictionary:
return(TranslateDictionary(childNode));
default:
throw new InvalidOperationException("Invalid expression type: " + childNode + " at " + childNode.Span.Location);
}
}
///node is 'Expression_Function_Inputs'
private void translate_Expression_Function_Inputs_2(ParseTreeNode node, out ILanguageExpression expr1, out ILanguageExpression expr2)
{
node.Assert(GMacParseNodeNames.ExpressionFunctionInputs);
expr1 = null;
expr2 = null;
var subNode = node.ChildNodes[0];
if (subNode.Term.ToString() == GMacParseNodeNames.ExpressionFunctionInputsExpressions)
{
var expressionFunctionInputsExpressionsNode = subNode;
if (expressionFunctionInputsExpressionsNode.ChildNodes.Count == 2)
{
expr1 =
GMacExpressionGenerator.Translate(BasicExpressionGenerator, subNode.ChildNodes[0]);
expr2 =
GMacExpressionGenerator.Translate(BasicExpressionGenerator, subNode.ChildNodes[1]);
return;
}
CompilationLog.RaiseGeneratorError <ILanguageExpression>("Expecting a single expression as input", node);
}
CompilationLog.RaiseGeneratorError <ILanguageExpression>("Expecting a single expression as input", node);
}
//public override void ResetOnAcquire()
//{
// base.ResetOnAcquire();
// _vSpaceDim = 0;
// _baseFrame = null;
// _generatedFrame = null;
//}
///Read the list of basis vectors names for the current frame
private string[] translate_Frame_Vectors(ParseTreeNode node)
{
node.Assert(GMacParseNodeNames.FrameVectors);
var basisVectorsNames = new List <string>();
foreach (var subnode in node.ChildNodes)
{
var basisVectorName = GenUtils.Translate_Identifier(subnode);
if (basisVectorsNames.Contains(basisVectorName))
{
CompilationLog.RaiseGeneratorError <int>("Basis vector name already defined", subnode);
}
basisVectorsNames.Add(basisVectorName);
}
if (basisVectorsNames.Count > FrameUtils.MaxVSpaceDimension)
{
CompilationLog.RaiseGeneratorError <int>("Cannot handle spaces with dimension larger than " + FrameUtils.MaxVSpaceDimension, node);
}
return(basisVectorsNames.ToArray());
}
private static TeLiteralNumber TranslateLiteralNumber(ParseTreeNode exprNode)
{
exprNode.Assert(TextExpressionDslParseNodeNames.LiteralNumber);
var numberText = exprNode.FindTokenAndGetText();
return(new TeLiteralNumber(numberText));
}
private static TeLiteralString TranslateSqString(ParseTreeNode exprNode)
{
exprNode.Assert(TextExpressionDslParseNodeNames.SqString);
return(new TeLiteralString(
exprNode.FindTokenAndGetText().QuoteLiteralToValue()
));
}
//Translate the list of macro parameters
private void translate_Macro_Inputs(ParseTreeNode node)
{
node.Assert(GMacParseNodeNames.MacroInputs);
foreach (var subnode in node.ChildNodes)
{
translate_Identifier_Declaration(subnode);
}
}
private static TeIdentifier TranslateExpressionName(ParseTreeNode exprNode)
{
exprNode.Assert(TextExpressionDslParseNodeNames.ExpressionName);
return
(exprNode.ChildNodes.Count == 0
? null
: TranslateQualifiedIdentifier(exprNode.ChildNodes[0]));
}
private static TeIdentifier TranslateQualifiedIdentifier(ParseTreeNode exprNode)
{
exprNode.Assert(TextExpressionDslParseNodeNames.QualifiedIdentifier);
return
(new TeIdentifier(
exprNode.ChildNodes.Select(Translate_Identifier).Concatenate(".")
));
}
/// <summary>
/// Read an identifier qualified list from the given parse tree node
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
public static TrimmedList <string> Translate_Qualified_Identifier(ParseTreeNode node)
{
node.Assert(GMacParseNodeNames.QualifiedIdentifier);
var identList = new TrimmedList <string>(
node.ChildNodes.Select(Translate_Identifier)
);
identList.ResetActiveRange();
return(identList);
}
/// <summary>
/// Read an mathematica expression text from the given parse tree node
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
public static string Translate_StringLiteral(ParseTreeNode node)
{
node.Assert(GMacParseNodeNames.StringLiteral);
var expression = node.ChildNodes[0].FindTokenAndGetText();
return(expression.QuoteLiteralToValue());
//TODO: Use this instead?
//return
// expression[0] == '@'
// ? expression.Substring(2, expression.Length - 3)
// : expression.Substring(1, expression.Length - 2);
}
///node is 'Expression_Function_Inputs'
private ILanguageExpression translate_Expression_Function_Inputs_1(ParseTreeNode node)
{
node.Assert(GMacParseNodeNames.ExpressionFunctionInputs);
var subNode = node.ChildNodes[0];
if (subNode.Term.ToString() != GMacParseNodeNames.ExpressionFunctionInputsExpressions)
{
return(CompilationLog.RaiseGeneratorError <ILanguageExpression>("Expecting a single expression as input", node));
}
var expressionFunctionInputsExpressionsNode = subNode;
return
(expressionFunctionInputsExpressionsNode.ChildNodes.Count == 1
? GMacExpressionGenerator.Translate(BasicExpressionGenerator, subNode.ChildNodes[0])
: CompilationLog.RaiseGeneratorError <ILanguageExpression>("Expecting a single expression as input", node));
}
private static TeList TranslateList(ParseTreeNode exprNode)
{
exprNode.Assert(TextExpressionDslParseNodeNames.List);
var name = TranslateExpressionName(exprNode.ChildNodes[0]);
var listArgsNode = exprNode.ChildNodes[1];
var expr = new TeList()
{
Name = name
};
expr.AddRange(
listArgsNode.ChildNodes.Select(TranslateExpression)
);
return(expr);
}
private LanguageValueAccess translate_Command_Let_LHS_Qualified_Item(ILanguageType rhsType, ParseTreeNode node)
{
node.Assert(GMacParseNodeNames.QualifiedItem);
var subNode = node.ChildNodes[0];
switch (subNode.ToString())
{
case GMacParseNodeNames.QualifiedBasisBladesSet:
case GMacParseNodeNames.QualifiedBasisBladeCoefficient:
return(GMacValueAccessGenerator.Translate(Context, subNode, true));
case GMacParseNodeNames.QualifiedIdentifier:
if (subNode.ChildNodes.Count == 1)
{
LanguageValueAccess varAccess;
var flag = TryTranslate_LValue(Context, subNode, out varAccess);
if (flag)
{
return(varAccess);
}
var identifierName = subNode.ChildNodes[0].FindTokenAndGetText();
if (Context.ActiveParentScope.SymbolExists(identifierName))
{
CompilationLog.RaiseGeneratorError <LanguageValueAccess>("Identifier name already used", node.ChildNodes[0]);
}
var declareCommand = translate_Declare(identifierName, rhsType);
return(LanguageValueAccess.Create(declareCommand.DataStore));
}
return(GMacValueAccessGenerator.Translate(Context, subNode, true));
default:
return(CompilationLog.RaiseGeneratorError <LanguageValueAccess>("Unknown LHS node!!", node));
}
}
/// <summary>
/// This is the main function for translation of expressions
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
public ILanguageExpression translate_Expression(ParseTreeNode node)
{
node.Assert(GMacParseNodeNames.Expression);
var subNode = node.ChildNodes[0];
if (subNode.ToString() == GMacParseNodeNames.ExpressionSum)
{
//A 'Expression_Sum' node
return(translate_Expression_Sum(subNode));
}
//A 'GA_Unary_Operation + Expression_Sum' node
var gaUnaryOperation = subNode.ChildNodes[0].FindTokenAndGetText();
var expr = translate_Expression_Sum(RootParseNode.ChildNodes[1]);
Context.PushState(node);
ILanguageExpression finalExpr;
switch (gaUnaryOperation)
{
case "+":
finalExpr = BasicExpressionGenerator.Generate_UnaryPlus(expr);
break;
case "-":
finalExpr = BasicExpressionGenerator.Generate_UnaryMinus(expr);
break;
default:
return(CompilationLog.RaiseGeneratorError <ILanguageExpression>("Unary operator not recognized", subNode.ChildNodes[0]));
}
Context.PopState();
return(finalExpr);
}
private static TeDictionary TranslateDictionary(ParseTreeNode exprNode)
{
exprNode.Assert(TextExpressionDslParseNodeNames.Dictionary);
var name = TranslateExpressionName(exprNode.ChildNodes[0]);
var dictArgsNode = exprNode.ChildNodes[1];
var expr = new TeDictionary()
{
Name = name
};
foreach (var dictArgNode in dictArgsNode.ChildNodes)
{
var dictArgName = TranslateQualifiedIdentifier(dictArgNode.ChildNodes[0]);
var dictArgExpr = TranslateExpression(dictArgNode.ChildNodes[1]);
expr.Add(dictArgName.Text, dictArgExpr);
}
return(expr);
}
/// <summary>
/// Read a list of identifier qualified lists from the given parse tree node
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
public static List <TrimmedList <string> > Translate_Qualified_Identifier_List(ParseTreeNode node)
{
node.Assert(GMacParseNodeNames.QualifiedIdentifierList);
return(node.ChildNodes.Select(Translate_Qualified_Identifier).ToList());
}
/// <summary>
/// Read an identifier from the given parse tree node
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
public static string Translate_Identifier(ParseTreeNode node)
{
node.Assert(GMacParseNodeNames.Identifier);
return(node.FindTokenAndGetText());
}
