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()); }