private ILanguageExpression CompileMacroCall(GMacMacro macro, OperandsByValueAccess operands) { PushRecord(macro.ChildScope, false); foreach (var param in macro.Parameters) { CompileVariable(param); //Set the initial values of all parameters of called macro to their default var defaultAssignmentCommand = new OperandsByValueAccessAssignment( LanguageValueAccess.Create(param), GMacRootAst.CreateDefaultValue(param.SymbolType) ); CompileParameterAssignment(defaultAssignmentCommand); } foreach (var command in operands.AssignmentsList) { CompileParameterAssignment(command); } //this.Visit(macro.ProcedureBody); Visit(macro.OptimizedCompiledBody); var compiledOutputVariable = GetSymbolData(macro.OutputParameter); PopRecord(); return(LanguageValueAccess.Create(compiledOutputVariable)); }
private void translate_Macro() { try { Context.MarkCheckPointState(); string childSymbolName; SymbolWithScope parentSymbol; Translate_ParentSymbolAndChildSymbolName(RootParseNode.ChildNodes[0], out parentSymbol, out childSymbolName); //Determine type of macro (namespace, frame, or structure) and create the macro var nameSpace = parentSymbol as GMacNamespace; if (nameSpace != null) { _generatedMacro = Create_Namespace_Macro(nameSpace, childSymbolName); } else { var structure = parentSymbol as GMacStructure; if (structure != null) { _generatedMacro = Create_Structure_Macro(structure, childSymbolName); } else { var frame = parentSymbol as GMacFrame; if (frame != null) { _generatedMacro = Create_Frame_Macro(frame, childSymbolName); } else { CompilationLog.RaiseGeneratorError <int>("Expecting a Structure, Frame, or Namespace scope", RootParseNode.ChildNodes[0]); } } } _generatedMacro.CodeLocation = Context.GetCodeLocation(RootParseNode); Context.UnmarkCheckPointState(); Context.CompilationLog.ReportNormal("Translated Macro: " + _generatedMacro.SymbolAccessName, ProgressEventArgsResult.Success); } catch (CompilerException) { Context.RestoreToCheckPointState(); Context.CompilationLog.ReportNormal("Translate Macro Failed", ProgressEventArgsResult.Failure); } catch (Exception e) { Context.RestoreToCheckPointState(); Context.CompilationLog.ReportError("Translate Macro Failed With Error", e); } }
internal void Generate_BasicPolyadic_MacroCall(GMacMacro macro, OperandsByValueAccess operands) { //this.Log.Append(macro.OperatorName); Log.Append("("); var flag = false; foreach (var operand in operands.AssignmentsList) { if (flag) { Log.Append(", "); } else { flag = true; } operand.LhsValueAccess.AcceptVisitor(this); Log.Append(" : "); Log.Append(operand.LhsValueAccess.ExpressionType.TypeSignature); Log.Append(" = "); operand.RhsExpression.AcceptVisitor(this); } Log.Append(")"); }
private ILanguageValue EvaluateBasicPolyadicMacroCall(GMacMacro macro, OperandsByValueAccess operands) { PushRecord(macro.ChildScope, false); //Initialize parameters to their default values foreach (var param in macro.Parameters) { var paramValue = GMacRootAst.CreateDefaultValue(param.SymbolType); ActiveAr.AddSymbolData(param, paramValue); } //Modify assigned parameters values from macro call operands foreach (var command in operands.AssignmentsList) { Visit(command); } //Execute macro body macro.SymbolBody.AcceptVisitor(this); //macro.OptimizedCompiledBody.AcceptVisitor(this); //Read output parameter value var value = ActiveAr.GetSymbolData(macro.FirstOutputParameter); PopRecord(); return(value); }
internal LlGenerator(GMacMacro baseMacro) : base(baseMacro.ChildScope, new GMacValueAccessProcessor()) { BaseMacro = baseMacro; DataTable = new LlDataTable(GMacRootAst); }
public static GMacCodeBlock Process(GMacMacro baseMacro, ProgressComposer progress) { var optimizer = new TcbOptimizer(baseMacro); optimizer.BeginProcessing(); return(optimizer.CodeBlock); }
public void Visit(GMacMacro macro) { var node = new TreeNode(macro.SymbolAccessName) { Tag = macro }; RoleNodes[MacrosNode].Nodes.Add(node); }
/// <summary> /// Optimize the compiled body of the given macro /// </summary> /// <param name="baseMacro"></param> /// <returns></returns> public static CommandBlock OptimizeMacro(GMacMacro baseMacro) { var optimizer = new HlOptimizer(baseMacro) { _optimizedBlock = CommandBlock.Create(baseMacro) }; optimizer.Optimize(); return(optimizer._optimizedBlock); }
internal FormMacroExplorer(GMacMacro macro) { InitializeComponent(); SelectedMacro = new AstMacro(macro); AstDescription = new GMacAstDescription(); textBoxMacroName.Text = macro.SymbolAccessName; ResetMacroParameters(); }
private void Generate_Macro_UsingBody(GMacMacro macro, CommandBlock macroBody) { Log.AppendAtNewLine("macro "); Log.Append(macro.SymbolAccessName); Log.AppendLine("("); Log.IncreaseIndentation(); var flag = false; foreach (var parameter in macro.Parameters) { if (flag) { Log.Append(", "); } else { flag = true; } if (parameter.DirectionOut) { Log.AppendAtNewLine("out " + parameter.ObjectName); } else { Log.AppendAtNewLine(parameter.ObjectName); } Log.Append(" : "); Log.Append(parameter.SymbolTypeSignature); } Log.DecreaseIndentation(); Log.AppendAtNewLine(")"); macroBody.AcceptVisitor(this); Log.AppendLineAtNewLine(); }
public void Visit(GMacMacro macro) { Generate_Macro_UsingBody(macro, macro.SymbolBody); //macro.CompiledBody.AcceptVisitor(this); //macro.OptimizedCompiledBody.AcceptVisitor(this); //var gen = new LowLevelGenerator(macro); //gen.DefineAllParameters(); //gen.GenerateLowLevelItems(); //Log.AppendAtNewLine(gen.ToString()); //var genOpt = new LowLevelOptimizer(gen); //genOpt.OptimizeLowLevelItems(); //Log.AppendAtNewLine(genOpt.ToString()); ////LowLevelGeneratorTester gen_test = new LowLevelGeneratorTester(macro); ////this.Log.AppendAtNewLine(gen_test.TestGenerationByConstantInputs()); Log.AppendLineAtNewLine(); }
public TreeNode Visit(GMacMacro macro) { var node = new TreeNode("<MACRO> " + macro.ObjectName) { Tag = macro }; if (ShowMacroParameters) { foreach (var childSymbol in macro.Parameters) { node.Nodes.Add(Visit(childSymbol)); } } if (ShowCommandsAndExpressions) { node.Nodes.Add(Visit(macro.SymbolBody)); } return(node); }
private HlMacroBodyCompiler(GMacMacro baseMacro) : base(baseMacro.ChildScope, new GMacValueAccessProcessor()) { BaseMacro = baseMacro; }
internal void Generate_Macro_UsingRawBody(GMacMacro macro) { Generate_Macro_UsingBody(macro, macro.SymbolBody); }
private HlOptimizer(GMacMacro baseMacro) { BaseMacro = baseMacro; }
internal void Generate_Macro_UsingRawCompiledBody(GMacMacro macro) { Generate_Macro_UsingBody(macro, macro.CompiledBody); }
internal void Generate_Macro_UsingOptimizedCompiledBody(GMacMacro macro) { Generate_Macro_UsingBody(macro, macro.OptimizedCompiledBody); }
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)); }
internal AstMacro(GMacMacro macro) { AssociatedMacro = macro; }
internal static AstMacro ToAstMacro(this GMacMacro macro) { return(new AstMacro(macro)); }
private TcbOptimizer(GMacMacro baseMacro) : base(new GMacCodeBlock(baseMacro.ToAstMacro())) { Generator = new LlGenerator(baseMacro); }
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)); }
public LlGeneratorTester(GMacMacro baseMacro) { BaseMacro = baseMacro; }