private void InitializeFullTargetNaming(GMacTargetVariablesNaming targetNaming)
{
var valueAccessList =
targetNaming
.CodeBlock
.BaseMacro
.Parameters
.SelectMany(paramInfo => paramInfo.DatastoreValueAccess.ExpandStructures());
foreach (var valueAccess in valueAccessList)
{
if (valueAccess.IsPrimitive)
{
var varName = valueAccess.ValueAccessName;
targetNaming.SetScalarParameter(valueAccess, varName);
continue;
}
var parentName = valueAccess.ValueAccessName;
targetNaming.SetMultivectorParameters(
valueAccess,
id => BasisBladeIdToCode(parentName, id)
);
}
targetNaming.SetTempVariables(v => "tmp" + v.NameIndex);
}
internal void SetBasisBladeToArrayNaming(GMacTargetVariablesNaming targetNaming, string macroParamName, int macroParamGrade, string arrayVarName)
{
targetNaming.SetMultivectorParameters(
macroParamName + ".@G" + macroParamGrade + "@",
id => BasisBladeIdToTargetArrayItem(arrayVarName, id)
);
}
protected override void SetTargetVariablesNames(GMacTargetVariablesNaming targetNaming)
{
targetNaming.SetScalarParameter(targetNaming.BaseMacro.OutputParameterValueAccess, "result");
BladesLibraryGenerator.SetBasisBladeToArrayNaming(targetNaming, "mv", _inGrade, "coefs");
BladesLibraryGenerator.SetTargetTempVariablesNames(targetNaming);
}
//internal void SetBladeParameterBinding(GMacMacroBinding macroBinding, string macroParamName, int macroParamGrade)
//{
// macroBinding.BindMultivectorToVariables(macroParamName, macroParamGrade);
//}
internal void SetBasisBladeToArrayNaming(GMacTargetVariablesNaming targetNaming, AstDatastoreValueAccess macroParam, int macroParamGrade, string arrayVarName)
{
targetNaming.SetMultivectorParameters(
macroParam,
macroParamGrade,
id => BasisBladeIdToTargetArrayItem(arrayVarName, id)
);
}
protected override void SetTargetVariablesNames(GMacTargetVariablesNaming targetNaming)
{
BladesLibraryGenerator.SetBasisBladeToArrayNaming(targetNaming, "result", OutputGrade, "c");
BladesLibraryGenerator.SetBasisBladeToArrayNaming(targetNaming, "v", InputGrade1, "coefs1");
BladesLibraryGenerator.SetBasisBladeToArrayNaming(targetNaming, "mv", InputGrade2, "coefs2");
BladesLibraryGenerator.SetTargetTempVariablesNames(targetNaming);
}
public static void DefaultActionSetTargetVariablesNames(GMacTargetVariablesNaming targetNaming)
{
targetNaming.SetInputVariables(v => v.ValueAccessName);
targetNaming.SetOutputVariables(v => v.ValueAccessName);
//targetNaming.SetTempVariables(v => v.LowLevelName);
targetNaming.SetTempVariables(v => "tmp" + v.NameIndex);
}
internal void SetTargetTempVariablesNames(GMacTargetVariablesNaming targetNaming)
{
//Temp variables target naming
if (targetNaming.CodeBlock.TargetTempVarsCount > MaxTargetLocalVars)
{
//Name as array items
targetNaming.SetTempVariables((int index) => "tempArray[" + index + "]");
}
else
{
//Name as set of local variables
targetNaming.SetTempVariables(index => "tempVar" + index.ToString("X4") + "");
}
}
protected override void SetTargetVariablesNames(GMacTargetVariablesNaming targetNaming)
{
BladesLibraryGenerator.SetBasisBladeToArrayNaming(targetNaming, "result", _outGrade, "coefs");
for (var gradeIdx = 0; gradeIdx < _outGrade; gradeIdx++)
{
var vectorName = "vectors[" + gradeIdx + "].C";
targetNaming.SetMultivectorParameters(
"v" + gradeIdx + ".@G1@",
id => vectorName + (CurrentFrame.BasisBladeIndex(id) + 1)
);
}
BladesLibraryGenerator.SetTargetTempVariablesNames(targetNaming);
}
protected override void SetTargetVariablesNames(GMacTargetVariablesNaming targetNaming)
{
var outputParam = targetNaming.BaseMacro.OutputParameterValueAccess;
if (outputParam.GMacType.IsValidMultivectorType)
{
BladesLibraryGenerator.SetBasisBladeToArrayNaming(targetNaming, outputParam, _outGrade, "c");
}
else
{
targetNaming.SetScalarParameter(outputParam, "c[0]");
}
BladesLibraryGenerator.SetBasisBladeToArrayNaming(targetNaming, "mv", _inGrade, "coefs");
BladesLibraryGenerator.SetTargetTempVariablesNames(targetNaming);
}
protected override void SetTargetVariablesNames(GMacTargetVariablesNaming targetNaming)
{
BladesLibraryGenerator.SetBasisBladeToArrayNaming(targetNaming, "B", InputGrade, "coefs");
for (var idx = 1; idx <= InputGrade; idx++)
{
var valueAccessName = "result.f" + idx + ".@G1@";
var outputName = "vectors[" + (idx - 1) + "].C";
targetNaming.SetMultivectorParameters(
valueAccessName,
vectorId => outputName + (CurrentFrame.BasisBladeIndex(vectorId) + 1)
);
}
BladesLibraryGenerator.SetTargetTempVariablesNames(targetNaming);
}
protected override void SetTargetVariablesNames(GMacTargetVariablesNaming targetNaming)
{
BladesLibraryGenerator.SetBasisBladeToArrayNaming(targetNaming, "result", InputGrade, "coefs");
BladesLibraryGenerator.SetBasisBladeToArrayNaming(targetNaming, "mv", InputGrade, "bladeCoefs");
for (var i = 0; i < CurrentFrame.VSpaceDimension; i++)
{
var id = CurrentFrame.BasisVectorId(i);
for (var j = 0; j < CurrentFrame.VSpaceDimension; j++)
{
var varName = "omCoefs".CoefPart(i, j);
var valueAccessName = "om.ImageV" + (j + 1) + ".#E" + id + "#";
targetNaming.SetScalarParameter(valueAccessName, varName);
}
}
BladesLibraryGenerator.SetTargetTempVariablesNames(targetNaming);
}
protected override void SetTargetVariablesNames(GMacTargetVariablesNaming targetNaming)
{
//Set names of output parameter components
var outputParam = targetNaming.BaseMacro.OutputParameterValueAccess;
if (outputParam.GMacType.IsValidMultivectorType)
{
targetNaming.SetMultivectorParameters(outputParam, b => "result." + b.GradeIndexName);
}
else
{
targetNaming.SetScalarParameter(outputParam, "result");
}
//Set names for input parameters components
targetNaming.SetMultivectorParameters("mv1", b => b.GradeIndexName);
targetNaming.SetMultivectorParameters("mv2", b => "mv." + b.GradeIndexName);
//Set names for temp variables
MvLibraryGenerator.SetTargetTempVariablesNames(targetNaming);
}
private void SetTargetNaming(GMacTargetVariablesNaming targetNaming)
{
//Set default target variables names for macro parameters
var valueAccessList =
targetNaming
.CodeBlock
.BaseMacro
.Parameters
.SelectMany(paramInfo => paramInfo.DatastoreValueAccess.ExpandStructures());
foreach (var valueAccess in valueAccessList)
{
if (valueAccess.IsPrimitive)
{
var varName = valueAccess.ValueAccessName;
targetNaming.SetScalarParameter(valueAccess, varName);
continue;
}
var parentName = valueAccess.ValueAccessName;
targetNaming.SetMultivectorParameters(
valueAccess,
id => BasisBladeIdToCode(parentName, id)
);
}
//Override default target variables names for macro parameters using the
//items in the TargetVariablesNamesDictionary
foreach (var pair in TargetVariablesNamesDictionary)
{
targetNaming.SetScalarParameter(pair.Key, pair.Value);
}
//Set temporary target variables names
targetNaming.SetTempVariables(v => "tmp" + v.NameIndex);
}
protected abstract void SetTargetVariablesNames(GMacTargetVariablesNaming targetNaming);
/// <summary>
/// Generate optimized macro code in the target language given a list of macro parameters bindings
/// </summary>
/// <returns></returns>
public override string Generate()
{
//Initialize components of macro code generator
SyntaxList.Clear();
MacroBinding.Clear();
CodeBlock = null;
TargetVariablesNaming = null;
if (AllowGenerateMacroCode == false)
{
return(string.Empty);
}
LibraryComposer.CheckProgressRequestStop();
var progressId = this.ReportStart(
"Generating Macro Code For: " + BaseMacro.AccessName
);
try
{
//Bind macro parameters to variables and constants as needed
if (ActionSetMacroParametersBindings == null)
{
DefaultActionSetMacroParametersBindings(MacroBinding);
}
else
{
ActionSetMacroParametersBindings(MacroBinding);
}
if (IsMacroBindingReady == false)
{
this.ReportWarning("Macro Binding Not Ready", MacroBinding.ToString());
this.ReportFinish(progressId);
return(string.Empty);
}
this.ReportNormal("Macro Binding Ready", MacroBinding.ToString());
//Create the optimizd code block holding abstract computations based on the macro parameters
//bindings. This step is typically the most time consuming because of many symbolic computations
CodeBlock = MacroBinding.CreateOptimizedCodeBlock();
//Assign target variable names to low-level code block variables. The code block is generated
//automatically in the call to the OptimizedCodeBlock member
TargetVariablesNaming = new GMacTargetVariablesNaming(GMacLanguage, CodeBlock);
if (ActionSetTargetVariablesNames == null)
{
DefaultActionSetTargetVariablesNames(TargetVariablesNaming);
}
else
{
ActionSetTargetVariablesNames(TargetVariablesNaming);
}
//Generate code before computations for comments, temp declarations, and the like
var result =
ActionBeforeGenerateComputations == null
? DefaultActionBeforeGenerateComputations(this)
: ActionBeforeGenerateComputations(this);
//Generate computations code if allowed by last action result
if (result)
{
GenerateProcessingCode();
}
//Generate code after computations for comments, temp destruction, and the like
if (ActionAfterGenerateComputations == null)
{
DefaultActionAfterGenerateComputations(this);
}
else
{
ActionAfterGenerateComputations(this);
}
}
catch (Exception e)
{
this.ReportError(e);
}
//Clean everything up and return final generated code
ExpressionConverter.ActiveCodeBlock = null;
//Un-parse the SyntaxList into the final code
var codeText = CodeGenerator.GenerateCode(SyntaxList);
this.ReportFinish(progressId, codeText);
return(codeText);
}
