//public override void ResetOnAcquire() //{ // base.ResetOnAcquire(); // _generatedStructure = null; //} private void translate_Identifier_Declaration(ParseTreeNode node) { try { Context.MarkCheckPointState(); //Read the name of the member var identifierName = TranslateChildSymbolName(_generatedStructure, node.ChildNodes[0]); //Read the type of the member var identifierType = GMacValueAccessGenerator.Translate_Direct_LanguageType(Context, node.ChildNodes[1]); //Create the member in the symbol table _generatedStructure.DefineReadWriteDataMember(identifierName, identifierType); Context.UnmarkCheckPointState(); Context.CompilationLog.ReportNormal("Translated Structure Member: " + identifierName, ProgressEventArgsResult.Success); } catch (CompilerException) { Context.RestoreToCheckPointState(); Context.CompilationLog.ReportNormal("Translate Structure Member Failed: " + _generatedStructure.SymbolAccessName, ProgressEventArgsResult.Failure); } catch (Exception e) { Context.RestoreToCheckPointState(); Context.CompilationLog.ReportError("Translate Structure Member Failed:" + _generatedStructure.SymbolAccessName, e); } }
private List <GMacFrame> translate_Frames_List(ParseTreeNode node) { var framesList = new List <GMacFrame>(node.ChildNodes.Count); foreach (var subnode in node.ChildNodes) { try { Context.MarkCheckPointState(); var frame = (GMacFrame)GMacValueAccessGenerator.Translate_Direct(Context, subnode, RoleNames.Frame); framesList.Add(frame); Context.UnmarkCheckPointState(); } catch (CompilerException) { Context.RestoreToCheckPointState(); } catch (Exception e) { Context.RestoreToCheckPointState(); throw (new Exception("Unhandled Exception", e)); } } return(framesList); }
private ILanguageExpression translate_Expression_Scoped(ParseTreeNode node) { var frame = (GMacFrame)GMacValueAccessGenerator.Translate_Direct(Context, node.ChildNodes[0], RoleNames.Frame); Context.OpenScope(frame); var expr = GMacExpressionGenerator.Translate(Context, node.ChildNodes[1]); Context.CloseScope(frame); return(expr); }
private CommandDeclareVariable translate_Identifier_Declaration(ParseTreeNode node) { //Read the name of the member var identifierName = GenUtils.Translate_Identifier(node.ChildNodes[0]); if (Context.ActiveParentScope.SymbolExists(identifierName)) { return(CompilationLog.RaiseGeneratorError <CommandDeclareVariable>("Identifier name already used", node.ChildNodes[0])); } var identifierType = GMacValueAccessGenerator.Translate_Direct_LanguageType(Context, node.ChildNodes[1]); return(translate_Declare(identifierName, identifierType)); }
///Set the signature of the current frame to a reciprocal frame private GaFrame translate_Frame_Signature_Reciprocal(ParseTreeNode node) { var baseFrame = (GMacFrame)GMacValueAccessGenerator.Translate_Direct(Context, node.ChildNodes[0], RoleNames.Frame); if (baseFrame.VSpaceDimension != _vSpaceDim) { CompilationLog.RaiseGeneratorError <int>("Base frame must be of dimension " + _vSpaceDim, node.ChildNodes[0]); } _baseFrame = baseFrame; var derivedFrameSystem = GaFrame.CreateReciprocalCbmFrameSystem(baseFrame.AssociatedSymbolicFrame); return(derivedFrameSystem.DerivedFrame); }
//public static bool TryTranslate_LValue(GMacSymbolTranslatorContext context, ParseTreeNode node, out LanguageValueAccess varAccess) //{ // var qualList = GenUtils.Translate_Qualified_Identifier(node); // LanguageSymbol symbol; // var flag = // context // .OpenedDistinctScopes() // .LookupSymbol(qualList.FirstItem, out symbol); // if (flag == false || (symbol is SymbolLValue) == false) // { // varAccess = null; // return false; // } // varAccess = LanguageValueAccess.Create(symbol); // return true; //} public static LanguageValueAccess Translate(GMacSymbolTranslatorContext context, ParseTreeNode node, bool isLvalue, TrimmedList <string> qualList) { context.PushState(node); var translator = new GMacValueAccessGenerator();//new GMacValueAccessGenerator(qualList, context, isLvalue, true); translator.SetContext(qualList, context, isLvalue, true); translator.Translate(); context.PopState(); var result = translator._generatedValueAccess; //MasterPool.Release(translator); return(result); }
//public override void ResetOnAcquire() //{ // base.ResetOnAcquire(); // _generatedExpression = null; //} //public GMacExpressionBasicGenerator BasicExpressionGenerator { get; private set; } //private GMacExpressionCompositeGenerator(GMacSymbolTranslatorContext context) // : base(context) //{ // //BasicExpressionGenerator = new GMacExpressionBasicGenerator(context); //} //private GMacExpressionCompositeGenerator(GMacExpressionBasicGenerator basic_expr_gen) // : base(basic_expr_gen.Context) //{ // BasicExpressionGenerator = basic_expr_gen; //} private SymbolLocalVariable translate_Identifier_Declaration(ParseTreeNode node) { //Read the name of the member var identifierName = GenUtils.Translate_Identifier(node.ChildNodes[0]); if (Context.ActiveParentScope.SymbolExists(identifierName)) { return(CompilationLog.RaiseGeneratorError <SymbolLocalVariable>("Identifier name already used", node.ChildNodes[0])); } var identifierType = GMacValueAccessGenerator.Translate_Direct_LanguageType(Context, node.ChildNodes[1]); //Create the member in the symbol table return (Context .ActiveParentCompositeExpression .DefineLocalVariable(identifierName, identifierType) .LocalVariable); }
//protected void SetContext(GMacSymbolTranslatorContext context) //{ // this.SetContext((SymbolTranslatorContext)context); //} /// <summary> /// Take a qualified indetifier node and separate it into a parent symbol and a child symbol name /// </summary> /// <param name="node"></param> /// <param name="parentSymbol"></param> /// <param name="childSymbolName"></param> protected bool Translate_ParentSymbolAndChildSymbolName(ParseTreeNode node, out SymbolWithScope parentSymbol, out string childSymbolName) { var qualList = GenUtils.Translate_Qualified_Identifier(node); childSymbolName = qualList.LastItem; if (qualList.ActiveLength == 1) { parentSymbol = Context.ActiveParentSymbol; } else { qualList.DecreaseActiveEndOffset(); parentSymbol = GMacValueAccessGenerator.Translate_Direct(Context, node, qualList) as SymbolWithScope; } return(ReferenceEquals(parentSymbol, null) == false); }
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)); } }
public static LanguageValueAccess Translate_LValue_MacroParameter(GMacSymbolTranslatorContext context, ParseTreeNode node, GMacMacro macro) { context.PushState(macro.ChildSymbolScope, node); var translator = new GMacValueAccessGenerator();//new GMacValueAccessGenerator(context, true, false); translator.SetContext(context, true, false); translator.Translate(); context.PopState(); if (translator._generatedValueAccess.RootSymbol is SymbolProcedureParameter) { var result = translator._generatedValueAccess; //MasterPool.Release(translator); return(result); } return(context.CompilationLog.RaiseGeneratorError <LanguageValueAccess>("Expecting a macro parameter", node)); }
//private ILanguageExpression translate_Expression_Cast(ParseTreeNode node) //{ // var langType = GMacValueAccessGenerator.Translate_Direct_LanguageType(this.Context, node.ChildNodes[0]); // var expr = GMacExpressionGenerator.Translate(this.BasicExpressionGenerator, node.ChildNodes[0]); // return this.BasicExpressionGenerator.Generate_TypeCast(langType, expr); //} protected override void Translate() { var subNode = RootParseNode.ChildNodes[0]; switch (subNode.Term.Name) { case GMacParseNodeNames.ConstantNumber: _generatedExpression = translate_Constant_Number(subNode); break; case GMacParseNodeNames.ExpressionScoped: _generatedExpression = translate_Expression_Scoped(subNode); break; case GMacParseNodeNames.QualifiedItem: _generatedExpression = GMacValueAccessGenerator.Translate(Context, subNode.ChildNodes[0], false); break; case GMacParseNodeNames.ExpressionBracketed: _generatedExpression = GMacExpressionGenerator.Translate(BasicExpressionGenerator, subNode.ChildNodes[0]); break; case GMacParseNodeNames.StringLiteral: _generatedExpression = GMacExpressionAtomicSymbolicGenerator.Translate(Context, subNode); break; case GMacParseNodeNames.ExpressionComposite: _generatedExpression = GMacExpressionCompositeGenerator.Translate(Context, subNode); break; case GMacParseNodeNames.ExpressionFunction: _generatedExpression = GMacExpressionAtomicFunctionGenerator.Translate(BasicExpressionGenerator, subNode); break; default: CompilationLog.RaiseGeneratorError <ILanguageExpression>("Expression not recognized", RootParseNode); break; } }
///Set the signature of the current frame to a base frame with a change of basis matrix private GaFrame translate_Frame_Signature_CBM(ParseTreeNode node) { var baseFrame = (GMacFrame)GMacValueAccessGenerator.Translate_Direct(Context, node.ChildNodes[0], RoleNames.Frame); if (baseFrame.VSpaceDimension != _vSpaceDim) { CompilationLog.RaiseGeneratorError <int>("Base frame must be of dimension " + _vSpaceDim, node.ChildNodes[0]); } var cbmMatrix = MathematicaMatrix.Create(Cas, GenUtils.Translate_StringLiteral(node.ChildNodes[1])); if (cbmMatrix.IsInvertable() == false || cbmMatrix.Rows != _vSpaceDim) { CompilationLog.RaiseGeneratorError <int>("Expecting a square invertable matrix with " + _vSpaceDim + " rows", node.ChildNodes[1]); } _baseFrame = baseFrame; var derivedFrameSystem = GaFrame.CreateDerivedCbmFrameSystem(baseFrame.AssociatedSymbolicFrame, cbmMatrix); return(derivedFrameSystem.DerivedFrame); }
private void translate_Macro_OutputType(ParseTreeNode node) { try { Context.MarkCheckPointState(); var macroOutputType = GMacValueAccessGenerator.Translate_Direct_LanguageType(Context, node); _generatedMacro.DefineOutputParameter(GeneralConstants.MacroOutputParameterName, macroOutputType); Context.UnmarkCheckPointState(); Context.CompilationLog.ReportNormal("Translated Macro Output Type: " + _generatedMacro.SymbolAccessName, ProgressEventArgsResult.Success); } catch (CompilerException) { Context.RestoreToCheckPointState(); Context.CompilationLog.ReportNormal("Translate Macro Output Type: " + _generatedMacro.SymbolAccessName, ProgressEventArgsResult.Failure); } catch (Exception e) { Context.RestoreToCheckPointState(); Context.CompilationLog.ReportError("Translate Macro Output Type Failed: " + _generatedMacro.SymbolAccessName, e); } }
private ILanguageExpression translate_Expression_Function_Macro(GMacMacro macro, ParseTreeNode node) { var operands = OperandsByValueAccess.Create(); if (node.ChildNodes.Count == 0) { return(BasicPolyadic.Create(macro.OutputParameterType, macro, operands)); } var expressionFunctionInputsNode = node.ChildNodes[0]; var subNode = expressionFunctionInputsNode.ChildNodes[0]; switch (subNode.Term.ToString()) { case GMacParseNodeNames.ExpressionFunctionInputsAssignments: var expressionFunctionInputsAssignmentsNode = subNode; foreach (var nodeExpressionFunctionInputsAssignmentsItem in expressionFunctionInputsAssignmentsNode.ChildNodes) { var lhsNode = nodeExpressionFunctionInputsAssignmentsItem.ChildNodes[0].ChildNodes[0]; var rhsNode = nodeExpressionFunctionInputsAssignmentsItem.ChildNodes[1]; var lhsValAccess = GMacValueAccessGenerator.Translate_LValue_MacroParameter(Context, lhsNode, macro); var rhsExpr = BasicExpressionGenerator.Generate_PolyadicOperand( lhsValAccess.ExpressionType, GMacExpressionGenerator.Translate(BasicExpressionGenerator, rhsNode) ); operands.AddOperand(lhsValAccess, rhsExpr); } break; case GMacParseNodeNames.ExpressionFunctionInputsExpressions: var nodeExpressionFunctionInputsExpressions = subNode; var i = -1; foreach (var parameter in macro.Parameters) { if (i >= nodeExpressionFunctionInputsExpressions.ChildNodes.Count) { break; } //The first parameter of any macro is the 'result' output parameter; ignore it if (i >= 0) { var rhsNode = nodeExpressionFunctionInputsExpressions.ChildNodes[i]; var lhsValAccess = LanguageValueAccess.Create(parameter); var rhsExpr = BasicExpressionGenerator.Generate_PolyadicOperand( lhsValAccess.ExpressionType, GMacExpressionGenerator.Translate(BasicExpressionGenerator, rhsNode) ); operands.AddOperand(lhsValAccess, rhsExpr); } i = i + 1; } if (nodeExpressionFunctionInputsExpressions.ChildNodes.Count > i) { return(CompilationLog.RaiseGeneratorError <ILanguageExpression>("Expecting a list of at most " + i + " expression as input to the macro call", node)); } break; default: return(CompilationLog.RaiseGeneratorError <ILanguageExpression>("Expecting a list of expressions or list of parameter assignments as input to the macro call", node)); } return(BasicPolyadic.Create(macro.OutputParameterType, macro, operands)); }
private ILanguageExpression translate_Expression_Function(ParseTreeNode node) { var expr = translate_TryBuiltinMacro(node); if (expr != null) { return(expr); } var nodeQualifiedIdentifier = node.ChildNodes[0]; var nodeDefaultValueOpt = node.ChildNodes[1]; var nodeInputsOpt = node.ChildNodes[2]; ILanguageExpressionAtomic defaultValueSource; var symbol = GMacValueAccessGenerator.Translate_Direct(Context, nodeQualifiedIdentifier); var macro = symbol as GMacMacro; if (macro != null) { return (nodeDefaultValueOpt.ChildNodes.Count == 0 ? translate_Expression_Function_Macro(macro, nodeInputsOpt) : CompilationLog.RaiseGeneratorError <ILanguageExpression>("A default value cannot be used for a macro call operation", nodeDefaultValueOpt)); } var structure = symbol as GMacStructure; if (structure != null) { if (nodeDefaultValueOpt.ChildNodes.Count <= 0) { return(translate_Expression_Function_Structure(structure, null, nodeInputsOpt)); } var nodeDefaultValue = nodeDefaultValueOpt.ChildNodes[0]; defaultValueSource = BasicExpressionGenerator.Generate_PolyadicOperand( structure, GMacExpressionGenerator.Translate(BasicExpressionGenerator, nodeDefaultValue.ChildNodes[0]) ); return(translate_Expression_Function_Structure(structure, defaultValueSource, nodeInputsOpt)); } var subspace = symbol as GMacFrameSubspace; if (subspace != null) { if (nodeDefaultValueOpt.ChildNodes.Count <= 0) { return(translate_Expression_Function_Subspace(subspace, null, nodeInputsOpt)); } var nodeDefaultValue = nodeDefaultValueOpt.ChildNodes[0]; defaultValueSource = BasicExpressionGenerator.Generate_PolyadicOperand( subspace.ParentFrame.MultivectorType, GMacExpressionGenerator.Translate(BasicExpressionGenerator, nodeDefaultValue.ChildNodes[0]) ); return(translate_Expression_Function_Subspace(subspace, defaultValueSource, nodeInputsOpt)); } var multivector = symbol as GMacFrameMultivector; if (multivector != null) { if (nodeDefaultValueOpt.ChildNodes.Count <= 0) { return(translate_Expression_Function_MultivectorType(multivector, null, nodeInputsOpt)); } var nodeDefaultValue = nodeDefaultValueOpt.ChildNodes[0]; defaultValueSource = BasicExpressionGenerator.Generate_PolyadicOperand( multivector, GMacExpressionGenerator.Translate(BasicExpressionGenerator, nodeDefaultValue.ChildNodes[0]) ); return(translate_Expression_Function_MultivectorType(multivector, defaultValueSource, nodeInputsOpt)); } var typePrimitive = symbol as TypePrimitive; if (typePrimitive != null) { return (nodeDefaultValueOpt.ChildNodes.Count == 0 ? translate_Expression_Function_Cast(typePrimitive, nodeInputsOpt) : CompilationLog.RaiseGeneratorError <ILanguageExpression>("A default value cannot be used for a type cast operation", nodeDefaultValueOpt)); } var transform = symbol as GMacMultivectorTransform; if (transform != null) { return (nodeDefaultValueOpt.ChildNodes.Count == 0 ? translate_Expression_Function_Transform(transform, nodeInputsOpt) : CompilationLog.RaiseGeneratorError <ILanguageExpression>("A default value cannot be used for a multivector transform operation", nodeDefaultValueOpt)); } return(CompilationLog.RaiseGeneratorError <ILanguageExpression>("Expecting a macro, structure, transform, or multivector class", node)); }
private ILanguageExpression translate_Expression_Function_Structure(GMacStructure structure, ILanguageExpressionAtomic defaultValueSource, ParseTreeNode node) { var operands = OperandsByValueAccess.Create(); if (node.ChildNodes.Count == 0) { return (defaultValueSource == null ? structure.CreateConstructorExpression(operands) : structure.CreateConstructorExpression(defaultValueSource, operands)); } var expressionFunctionInputsNode = node.ChildNodes[0]; var subNode = expressionFunctionInputsNode.ChildNodes[0]; switch (subNode.Term.ToString()) { case GMacParseNodeNames.ExpressionFunctionInputsAssignments: var expressionFunctionInputsAssignmentsNode = subNode; foreach (var nodeExpressionFunctionInputsAssignmentsItem in expressionFunctionInputsAssignmentsNode.ChildNodes) { var lhsNode = nodeExpressionFunctionInputsAssignmentsItem.ChildNodes[0].ChildNodes[0]; var rhsNode = nodeExpressionFunctionInputsAssignmentsItem.ChildNodes[1]; var lhsValAccess = GMacValueAccessGenerator.Translate_LValue_StructureMember(Context, lhsNode, structure); var rhsExpr = BasicExpressionGenerator.Generate_PolyadicOperand( lhsValAccess.ExpressionType, GMacExpressionGenerator.Translate(BasicExpressionGenerator, rhsNode) ); operands.AddOperand(lhsValAccess, rhsExpr); } break; case GMacParseNodeNames.ExpressionFunctionInputsExpressions: var expressionFunctionInputsExpressionsNode = subNode; var i = 0; foreach (var dataMember in structure.DataMembers) { if (i >= expressionFunctionInputsExpressionsNode.ChildNodes.Count) { break; } var rhsNode = expressionFunctionInputsExpressionsNode.ChildNodes[i]; var lhsValAccess = LanguageValueAccess.Create(dataMember); var rhsExpr = BasicExpressionGenerator.Generate_PolyadicOperand( lhsValAccess.ExpressionType, GMacExpressionGenerator.Translate(BasicExpressionGenerator, rhsNode) ); operands.AddOperand(lhsValAccess, rhsExpr); i = i + 1; } if (expressionFunctionInputsExpressionsNode.ChildNodes.Count > i) { return(CompilationLog.RaiseGeneratorError <ILanguageExpression>("Expecting a list of at most " + i + " expression as input to the structure construction", node)); } break; default: return(CompilationLog.RaiseGeneratorError <ILanguageExpression>("Expecting a list of expressions or a list of member assignments as input to the structure construction", node)); } return (defaultValueSource == null ? structure.CreateConstructorExpression(operands) : structure.CreateConstructorExpression(defaultValueSource, operands)); }
private void translate_GMacDSL_Items_List(ParseTreeNode node) { if (CompilationLog.HasErrors && CompilationLog.StopOnFirstError) { return; } var subnode = node.ChildNodes[0]; if (_translateNamespaceFirst && subnode.Term.ToString() != GMacParseNodeNames.Namespace) { CompilationLog.RaiseGeneratorError <int>("DSL definitions must start with a namespace", subnode); } _translateNamespaceFirst = false; switch (subnode.Term.ToString()) { case GMacParseNodeNames.Breakpoint: GMacRootAst.EnableBreakpoints = true; break; case GMacParseNodeNames.Namespace: GMacNamespaceGenerator.Translate(Context, subnode); break; case GMacParseNodeNames.OpenNamespace: //Only namespaces and frames can be used in the 'open' statement Context.OpenScope( (SymbolWithScope)GMacValueAccessGenerator.Translate_Direct( Context, subnode.ChildNodes[0], new[] { RoleNames.Namespace, RoleNames.Frame } ) ); break; case GMacParseNodeNames.Frame: GMacFrameGenerator.Translate(Context, subnode); break; case GMacParseNodeNames.Constant: GMacConstantGenerator.Translate(Context, subnode); break; case GMacParseNodeNames.Structure: GMacStructureGenerator.Translate(Context, subnode); break; case GMacParseNodeNames.Transform: GMacTransformGenerator.Translate(Context, subnode); break; case GMacParseNodeNames.Macro: GMacMacroGenerator.Translate(Context, subnode); break; case GMacParseNodeNames.MacroTemplate: GMacMacroTemplateGenerator.Translate(Context, subnode); break; case GMacParseNodeNames.TemplatesImplementation: GMacTemplatesImplementationGenerator.Translate(Context, subnode); break; default: CompilationLog.RaiseGeneratorError <int>("DSL definitions item not recognized", subnode); break; } }