public AstDatastoreValueAccess GetMacroParameterValueAccess(AstMacro macroInfo, string codeText)
{
if (InitializeCompiler(macroInfo.AssociatedMacro.ChildScope, "Macro Parameter Value Access", codeText) == false)
{
return(null);
}
var progressTitle = CompileProgressTitle("Macro Parameter Value Access");
try
{
RootParseNode = RootParseNode.ChildNodes[0];
var valueAccess =
GMacValueAccessGenerator.Translate_LValue_MacroParameter(Context, RootParseNode, macroInfo.AssociatedMacro);
this.ReportNormal(progressTitle, valueAccess.GetName(), ProgressEventArgsResult.Success);
return(new AstDatastoreValueAccess(valueAccess));
}
catch (Exception e)
{
this.ReportError(progressTitle, e);
return(null);
}
}
private void AddCalledMacros(AstMacro macro)
{
var macroDep = _dependencyGraph[macro.AccessName];
if (macroDep.UsedCount == 0)
{
return;
}
foreach (var calledMacro in macroDep.UsedItems)
{
if (_dict.ContainsKey(calledMacro.AccessName) == false)
{
_dict.Add(calledMacro.AccessName, calledMacro.AccessName);
Graph
.AddNode(calledMacro.AccessName)
.SetFillColor(Color.White.ToDotRgbColor())
.SetLabel(
Graph.Table(
"Macro",
calledMacro.AccessName
)
);
}
Graph.AddEdge(calledMacro.AccessName, macro.AccessName);
AddCalledMacros(calledMacro);
}
}
public static GMacMacroTreeBinding Create(AstMacro baseMacroInfo, GMacBindOutputToConstantBehavior outputToConstAction = GMacBindOutputToConstantBehavior.Prevent)
{
return(new GMacMacroTreeBinding(baseMacroInfo)
{
BindOutputToConstantAction = outputToConstAction
});
}
/// <summary>
/// Create an empty macro parameters list binding pattern
/// </summary>
/// <param name="baseMacro"></param>
/// <param name="outputToConstAction"></param>
/// <returns></returns>
public static GMacMacroBinding Create(AstMacro baseMacro, GMacBindOutputToConstantBehavior outputToConstAction = GMacBindOutputToConstantBehavior.BindToVariable)
{
return(new GMacMacroBinding(baseMacro)
{
BindOutputToConstantBehavior = outputToConstAction
});
}
internal DpDualMethodsFileGenerator(BladesLibrary libGen, string opName)
: base(libGen)
{
OperatorName = opName;
EgpDualMacro = CurrentFrame.Macro(DefaultMacro.EuclideanBinary.GeometricProductDual);
}
public static DotGraph ToLowLevelGraphViz(this AstMacro macro)
{
var random = new Random();
var macroBinding = GMacMacroBinding.Create(macro);
var lowLevelParameters = macro.InputParameters.SelectMany(p => p.DatastoreValueAccess.ExpandAll());
foreach (var llp in lowLevelParameters)
{
if (random.Next(1, 10) > -1)
{
macroBinding.BindToVariables(llp);
}
else
{
macroBinding.BindScalarToConstant(llp, 1);
}
}
lowLevelParameters = macro.OutputParameter.DatastoreValueAccess.ExpandAll();
foreach (var llp in lowLevelParameters)
{
macroBinding.BindToVariables(llp);
}
var codeBlock = macroBinding.CreateOptimizedCodeBlock();
//var visitor = new MacroBindingToGraphViz(macroBinding, codeBlock);
var visitor = new GMacCodeBlockToGraphViz(codeBlock);
return(visitor.ToGraphViz());
}
//private GMacInfoMacro AddEuclideanDualGMacMacro()
//{
// var codeText =
// Templates["edual_macro"].GenerateUsing(CurrentFrameName);
// var gmacMacro =
// _tempSymbolsCompiler.CompileMacro(
// codeText,
// _currentFrame.AssociatedFrame.ChildScope
// );
// return new GMacInfoMacro(gmacMacro);
//}
private void GenerateEuclideanDualFunction(int inGrade, AstMacro macroInfo)
{
var macroGenerator = LibraryComposer.CreateMacroCodeGenerator(macroInfo);
var outGrade = CurrentFrame.VSpaceDimension - inGrade;
macroGenerator.ActionSetMacroParametersBindings =
macroBinding =>
{
macroBinding.BindMultivectorPartToVariables("result", outGrade);
macroBinding.BindMultivectorPartToVariables("mv", inGrade);
};
macroGenerator.ActionSetTargetVariablesNames =
targetNaming =>
{
BladesLibraryGenerator.SetBasisBladeToArrayNaming(targetNaming, "result", outGrade, "c");
BladesLibraryGenerator.SetBasisBladeToArrayNaming(targetNaming, "mv", inGrade, "coefs");
BladesLibraryGenerator.SetTargetTempVariablesNames(targetNaming);
};
//Generate code from macro binding
var computationsText = macroGenerator.Generate();
TextComposer.Append(
Templates["edual"],
"double", GMacLanguage.ScalarTypeName,
"grade", inGrade,
"num", CurrentFrame.KvSpaceDimension(inGrade),
"computations", computationsText
);
}
private void AddInputsCluster(AstMacro macro)
{
var inputsGraph = Graph;
// Graph
// .AddSubGraph("Inputs")
// .SetRank(DotRankType.Min);
////.SetLabel("Input Parameters".Bold());
foreach (var inParam in macro.InputParameters)
{
var node = inputsGraph
.AddNode(inParam.Name)
.SetLabel(
Graph.Table(
"Input",
Graph.SimpleTable(inParam.GMacTypeSignature, "Input"),
inParam.Name
)
);
inputsGraph
.AddEdge(
macro.AccessName.ToNodeRef(DotCompass.Center),
node.ToNodeRef(DotCompass.Center)
)
.SetColor(Color.Black.ToDotRgbColor());
}
}
public static DotGraph ToGraphViz(this AstMacro macro)
{
var visitor = new MacroToGraphViz();
macro.AcceptVisitor(visitor);
return(visitor.Graph);
}
public static DotGraph ToDependenciesGraphViz(this AstMacro macro)
{
var visitor = new MacroDependenciesToGraphViz();
visitor.Visit(macro);
return(visitor.Graph);
}
private void GenerateMacroCode(AstMacro macro)
{
var macroBinding = GMacMacroBinding.Create(macro);
InitializeFullMacroBinding(macroBinding);
GenerateMacroCode(macroBinding);
}
public GMacMacroCodeComposer(GMacMacroCodeComposerDefaults codeGenDefaults, AstMacro baseMacro = null)
: base(codeGenDefaults.LibraryComposer)
{
SyntaxList = new SteSyntaxElementsList();
MacroBinding = baseMacro.IsNullOrInvalid() ? null : GMacMacroBinding.Create(baseMacro);
UsedDefaults = codeGenDefaults.Duplicate();
SetDefaults();
}
public TreeNode Visit(AstMacro item)
{
var node = new TreeNode(item.Name)
{
Tag = item,
ImageKey = @"Macro64.png",
SelectedImageKey = @"Macro64.png"
};
return(node);
}
/// <summary>
/// Used to replace the base macro by another one. This sets the defaults of the generator and clears
/// the internal code composer
/// </summary>
/// <param name="baseMacro"></param>
public void SetBaseMacro(AstMacro baseMacro)
{
SyntaxList.Clear();
CodeBlock = null;
TargetVariablesNaming = null;
MacroBinding = GMacMacroBinding.Create(baseMacro);
SetDefaults();
}
internal FormMacroExplorer(GMacMacro macro)
{
InitializeComponent();
SelectedMacro = new AstMacro(macro);
AstDescription = new GMacAstDescription();
textBoxMacroName.Text = macro.SymbolAccessName;
ResetMacroParameters();
}
public string Visit(AstMacro item)
{
var composer = CreateColumnsComposer();
composer
.AppendToColumns("Macro Name:", item.AccessName)
.AppendEmptyStringsToColumns()
.AppendToColumns(
"Output Parameter:",
item.OutputParameterName + " : " + item.OutputParameter.GMacTypeSignature
)
.AppendEmptyStringsToColumns()
.AppendToColumns(
"Input Parameters:",
item
.InputParameters
.Select(t => t.AccessName + " : " + t.GMacTypeSignature)
.Concatenate(Environment.NewLine)
)
.AppendEmptyStringsToColumns()
.AppendToColumns(
"Macros calling this macro:",
_macroDepGraph
.GetAllUserItems(item)
.Select(d => d.BaseItem.AccessName)
.Concatenate(Environment.NewLine)
)
.AppendEmptyStringsToColumns()
.AppendToColumns(
"Macros called by this macro:",
_macroDepGraph
.GetAllUsedItems(item)
.Select(d => d.BaseItem.AccessName)
.Concatenate(Environment.NewLine)
)
.AppendEmptyStringsToColumns()
.AppendToColumns(
"Main Command Block:",
Visit(item.CommandBlock)
)
.AppendEmptyStringsToColumns()
.AppendToColumns(
"Compiled Command Block:",
Visit(item.CompiledCommandBlock)
)
.AppendEmptyStringsToColumns()
.AppendToColumns(
"Optimized Command Block:",
Visit(item.OptimizedCommandBlock)
);
return composer.GenerateText();
}
private void GenerateSelfDpGradeFunction(int inGrade, AstMacro selfEgpMacroInfo)
{
var macroGenerator = LibraryComposer.CreateMacroCodeGenerator(selfEgpMacroInfo);
var outGradesList =
CurrentFrame
.GradesOfEGp(inGrade, inGrade)
.Where(grade => grade > 0)
.OrderByDescending(g => g);
macroGenerator.ActionSetMacroParametersBindings =
macroBinding =>
{
foreach (var outGrade in outGradesList)
{
macroBinding.BindMultivectorPartToVariables("result", outGrade);
}
macroBinding.BindMultivectorPartToVariables("mv", inGrade);
};
macroGenerator.ActionSetTargetVariablesNames =
targetNaming =>
{
foreach (var outGrade in outGradesList)
{
targetNaming.SetMultivectorParameters("result", outGrade, id => "c");
}
BladesLibraryGenerator.SetBasisBladeToArrayNaming(targetNaming, "mv", inGrade, "coefs");
BladesLibraryGenerator.SetTargetTempVariablesNames(targetNaming);
};
macroGenerator.ActionBeforeGenerateSingleComputation =
TestSelfDpGradeFunctionComputationCondition;
macroGenerator.ActionAfterGenerateSingleComputation =
AddSelfDpGradeFunctionComputationCondition;
macroGenerator.MacroBinding.FixOutputComputationsOrder = true;
//Generate code from macro binding
var computationsText = macroGenerator.Generate();
TextComposer.Append(
Templates["self_dp_grade"],
"grade", inGrade,
"double", GMacLanguage.ScalarTypeName,
"computations", computationsText
);
}
private void GenerateFactorMethod(int inGrade, int inId, AstMacro gmacMacroInfo)
{
CodeFilesComposer.DownFolder("Factor");
CodeFilesComposer.InitalizeFile("Factor" + inId + ".cs");
var fileGen = new FactorMethodFileGenerator(this, inGrade, inId, gmacMacroInfo);
fileGen.Generate();
CodeFilesComposer.UnselectActiveFile();
CodeFilesComposer.UpFolder();
}
private void AddOutputsCluster(AstMacro macro)
{
var outputsGraph =
Graph
.AddSubGraph("Outputs")
.SetRank(DotRankType.Max);
outputsGraph
.AddNode(macro.OutputParameter.Name)
.SetLabel(
Graph.Table(
"Output",
Graph.SimpleTable(macro.OutputParameter.GMacTypeSignature, "Output"),
macro.OutputParameter.Name
)
);
}
private void AddStepsCluster(AstMacro macro)
{
StepsCluster =
Graph
.AddSubGraph("Processing");
//.SetLabel("Optimized Processing Steps".Bold());
var commands =
macro
.OptimizedCommandBlock
.Commands
.Where(command => command.IsValidCommandLet);
foreach (var command in commands)
{
command.AcceptVisitor(this);
}
}
public AstMacro CompileMacro(string codeText)
{
if (InitializeCompiler(codeText, GMacSourceParser.ParseMacro, RefResContext) == false)
{
this.ReportNormal(
"Initializing Compile Temp Macro",
codeText,
ProgressEventArgsResult.Failure
);
return(null);
}
this.ReportNormal(
"Initializing Compile Temp Macro",
codeText,
ProgressEventArgsResult.Success
);
try
{
var compiledSymbol =
new AstMacro(GMacMacroGenerator.Translate(Context, RootParseNode));
CompiledMacros.Add(compiledSymbol.AccessName, compiledSymbol);
this.ReportNormal(
"Compiling Temp Macro",
compiledSymbol.AccessName,
ProgressEventArgsResult.Success
);
return(compiledSymbol);
}
catch (Exception e)
{
this.ReportError("Error Compiling Temp Macro", e);
return(null);
}
}
private void GenerateMacroInputsCode(AstMacro macroInfo)
{
var flag = false;
foreach (var paramInfo in macroInfo.InputParameters)
{
if (flag)
{
ActiveFileTextComposer.Append(", ");
}
else
{
flag = true;
}
GenerateTypeName(paramInfo.GMacType);
ActiveFileTextComposer.Append(" ");
ActiveFileTextComposer.Append(paramInfo.Name);
}
}
public void Visit(AstMacro macro)
{
//Graph = AstVisitorDotGraph.Create();
_nodesStack.Clear();
Graph
.SetRankDir(DotRankDirection.LeftToRight);
Graph
.AddNode(macro.AccessName)
.SetLabel(
Graph.Table("Macro", macro.AccessName)
);
AddInputsCluster(macro);
AddOutputsCluster(macro);
AddStepsCluster(macro);
}
///// <summary>
///// Find a structure data member given a text reference starting at the current scope information
///// </summary>
///// <param name="symbolName"></param>
///// <returns></returns>
//public GMacInfoStructureDataMember DataMember(string symbolName)
//{
// GMacInfoStructureDataMember symbolInfo;
// LanguageSymbol symbol;
// if (_symbolsCache.TryGetValue(symbolName, out symbol))
// {
// symbolInfo = new GMacInfoStructureDataMember(symbol as SymbolStructureDataMember);
// }
// else
// {
// symbolInfo = _expressionCompiler.DataMember(symbolName);
// AddToSymbolsCache(symbolName, symbolInfo.AssociatedDataMember);
// }
// _requests.Add(
// new InterpreterRequest(InterpreterRequestType.GetSymbol, symbolName)
// { IsSuccess = symbolInfo.IsReady }
// );
// return symbolInfo;
//}
/// <summary>
/// Find a macro given a text reference starting at the current scope information
/// </summary>
/// <param name="symbolName"></param>
/// <returns></returns>
public AstMacro Macro(string symbolName)
{
symbolName = symbolName.Trim();
AstMacro symbolInfo;
LanguageSymbol symbol;
if (_symbolsCache.TryGetValue(symbolName, out symbol))
{
symbolInfo = new AstMacro(symbol as GMacMacro);
}
else
{
symbolInfo = _expressionCompiler.GetMacro(symbolName);
AddToSymbolsCache(symbolName, symbolInfo.AssociatedMacro);
}
this.ReportNormal("Request Macro " + symbolName.DoubleQuote(), symbolInfo.IsNotNullAndValid());
return(symbolInfo);
}
public void Visit(AstMacro macro)
{
_dependencyGraph = macro.Root.GetMacroDependencies();
Graph.SetRankDir(DotRankDirection.LeftToRight);
Graph
.AddNode(macro.AccessName)
.SetFillColor(Color.GreenYellow.ToDotRgbColor())
.SetLabel(
Graph.Table(
"Macro",
macro.AccessName
)
);
_dict.Clear();
AddCallerMacros(macro);
_dict.Clear();
AddCalledMacros(macro);
}
internal VectorsOpMethodsFileGenerator(BladesLibrary libGen, AstMacro macroInfo)
: base(libGen, macroInfo)
{
}
public bool ContainsScope(AstMacro scopeSymbol)
{
return(ContainsScope(scopeSymbol.AssociatedMacro.ChildScope));
}
public GMacRefResContextInfo(AstMacro scopeSymbol)
{
MainScope = scopeSymbol.AssociatedMacro.ChildScope;
}
public GMacRefResContextInfo CloseScope(AstMacro scopeSymbol)
{
return(CloseScope(scopeSymbol.AssociatedMacro.ChildScope));
}
internal GMacCodeBlock(AstMacro baseMacro)
{
BaseMacro = baseMacro;
}
