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