private void Implement_Template(GMacMacroTemplate macroTemplate, GMacFrame frame)
{
try
{
Context.MarkCheckPointState();
Context.PushState(frame.ChildSymbolScope);
var macro = GMacMacroGenerator.Translate(Context, macroTemplate.TemplateParseNode);
_generatedMacros.Add(macro);
Context.PopState();
Context.UnmarkCheckPointState();
}
catch (CompilerException)
{
Context.RestoreToCheckPointState();
}
catch (Exception e)
{
Context.RestoreToCheckPointState();
throw (new Exception("Unhandled Exception", e));
}
}
private LanguageValueAccess translate_StartAt_FrameDefinition(GMacFrame frame)
{
if (_qualList.ActiveLength == 0)
{
return(LanguageValueAccess.Create(frame));
}
LanguageSymbol symbol;
var flag = frame.ChildSymbolScope.LookupSymbol(_qualList.FirstItem, out symbol);
_qualList.IncreaseActiveStartOffset(1);
if (flag == false)
{
return(CompilationLog.RaiseGeneratorError <LanguageValueAccess>("Frame component not recognized", RootParseNode));
}
switch (symbol.SymbolRoleName)
{
case RoleNames.Constant:
return(translate_StartAt_DataSymbol((SymbolDataStore)symbol));
case RoleNames.FrameBasisVector:
case RoleNames.FrameMultivector:
case RoleNames.Macro:
return(translate_StartAt_DirectSymbol(symbol));
default:
return(CompilationLog.RaiseGeneratorError <LanguageValueAccess>("Frame component name not recognized", RootParseNode));
}
}
public void Visit(GMacFrame frame)
{
var node = new TreeNode(frame.SymbolAccessName)
{
Tag = frame
};
RoleNodes[FramesNode].Nodes.Add(node);
foreach (var childSymbol in frame.FrameSubspaces)
{
Visit(childSymbol);
}
foreach (var childSymbol in frame.ChildConstants)
{
Visit(childSymbol);
}
foreach (var childSymbol in frame.Structures)
{
Visit(childSymbol);
}
foreach (var childSymbol in frame.ChildMacros)
{
Visit(childSymbol);
}
}
/// <summary>
/// Create the default subspaces for this frame
/// </summary>
public void DefineDefaultSubspaces(GMacFrame frame)
{
//DefineDefaultSubspaces_PseudoScalar(frame);
DefineDefaultSubspaces_KVectors(frame);
DefineDefaultSubspaces_Even(frame);
DefineDefaultSubspaces_Odd(frame);
DefineDefaultSubspaces_FullGA(frame);
}
/// <summary>
/// Create the default constant I for this frame (the unit pseudoscalar)
/// </summary>
/// <returns></returns>
public GMacConstant DefineDefaultConstants_I(GMacFrame frame)
{
var finalExpr = GMacValueMultivector.CreateBasisBlade(frame.MultivectorType, frame.MaxBasisBladeId);
var constant = frame.DefineFrameConstant("I", finalExpr);
constant.AddCodeLocation(Context.GetCodeLocation(frame.ParseNode));
return(constant);
}
private GMacFrame DefineFrameDefaultObjects(GMacFrame frame)
{
DefineDefaultSubspaces(frame);
DefineDefaultConstants(frame);
//DefineFrameDefaultSymbols(frame);
return(frame);
}
private GMacMacro Create_Frame_Macro(GMacFrame frame, string macroName)
{
if (frame.CanDefineChildSymbol(macroName) == false)
{
CompilationLog.RaiseGeneratorError <int>("Symbol name already used", RootParseNode);
}
//Create the macro and add it to the symbol table
return(frame.DefineFrameMacro(macroName));
}
private void translate_Frame()
{
try
{
//Mark the active context state for error recovery
Context.MarkCheckPointState();
//Read the name of the new frame
var frameName = TranslateChildSymbolName(RootParseNode.ChildNodes[0]);
//Check if the name is already used
if (Context.ParentNamespace.CanDefineChildSymbol(frameName) == false)
{
CompilationLog.RaiseGeneratorError <int>("Symbol name already used", RootParseNode);
}
//Read the basis vectors names to be added later to the frame scope
var basisVectorsNames = translate_Frame_Vectors(RootParseNode.ChildNodes[1]);
_vSpaceDim = basisVectorsNames.Length;
//Read and construct the attached symbolic GA frame
var attachedSymbolicFrame = translate_Frame_Signature(RootParseNode.ChildNodes[2]);
//Define the frame and all its default sub-objects
_generatedFrame = DefineFrame(frameName, basisVectorsNames, attachedSymbolicFrame, false);
//Set the derived frame system information for this derived frame
if (_generatedFrame.AssociatedSymbolicFrame.IsNonOrthogonal || ReferenceEquals(_baseFrame, null) == false)
{
translate_Frame_DerivedFrameSystem(_generatedFrame, _baseFrame);
}
_generatedFrame.CodeLocation = Context.GetCodeLocation(RootParseNode);
//Define all default sub-objects for the generated frame
DefineFrameDefaultObjects(_generatedFrame);
//Unmark the active state
Context.UnmarkCheckPointState();
Context.CompilationLog.ReportNormal("Translated Frame: " + _generatedFrame.SymbolAccessName, ProgressEventArgsResult.Success);
}
catch (CompilerException)
{
Context.RestoreToCheckPointState();
Context.CompilationLog.ReportNormal("Translate Frame", ProgressEventArgsResult.Failure);
}
catch (Exception e)
{
Context.RestoreToCheckPointState();
Context.CompilationLog.ReportError("Translate Frame Failed With Error", e);
}
}
/// <summary>
/// Create the default subspaces of k-vectors named @G0@, @G1@, @G2@, ... etc.
/// </summary>
private void DefineDefaultSubspaces_KVectors(GMacFrame frame)
{
for (var grade = 0; grade <= frame.VSpaceDimension; grade++)
{
DefineDefaultSubspaces_KVectors(frame, grade, "G" + grade);
}
DefineDefaultSubspaces_KVectors(frame, 0, "Scalar");
DefineDefaultSubspaces_KVectors(frame, 1, "Vector");
DefineDefaultSubspaces_KVectors(frame, 2, "Bivector");
DefineDefaultSubspaces_KVectors(frame, frame.VSpaceDimension - 1, "PseudoVector");
DefineDefaultSubspaces_KVectors(frame, frame.VSpaceDimension, "PseudoScalar");
}
/// <summary>
/// Create the Full GA subspace named @ga@
/// </summary>
/// <returns></returns>
private GMacFrameSubspace DefineDefaultSubspaces_FullGA(GMacFrame frame)
{
var idsList = Enumerable.Range(0, frame.GaSpaceDimension).ToList();
const string subspaceName = "GA";
var subspaceSignature = BooleanPattern.CreateFromTrueIndexes(frame.GaSpaceDimension, idsList);
var subspace = frame.DefineSubspace(subspaceName, subspaceSignature);
subspace.AddCodeLocation(Context.GetCodeLocation(frame.ParseNode));
return(subspace);
}
public TreeNode Visit(GMacFrame frame)
{
var node = new TreeNode("<FRAME> " + frame.ObjectName)
{
Tag = frame
};
if (ShowFrameBasisVectors)
{
foreach (var childSymbol in frame.FrameBasisVectors)
{
node.Nodes.Add(Visit(childSymbol));
}
}
if (ShowFrameMultivectorType)
{
node.Nodes.Add(Visit(frame.MultivectorType));
}
if (ShowFrameSubspaces)
{
foreach (var childSymbol in frame.FrameSubspaces)
{
node.Nodes.Add(Visit(childSymbol));
}
}
if (ShowConstants)
{
foreach (var childSymbol in frame.ChildConstants)
{
node.Nodes.Add(Visit(childSymbol));
}
}
if (!ShowMacros)
{
return(node);
}
foreach (var childSymbol in frame.ChildMacros)
{
node.Nodes.Add(Visit(childSymbol));
}
return(node);
}
/// <summary>
/// Create a default subspaces of k-vectors with a given grade and name
/// </summary>
private void DefineDefaultSubspaces_KVectors(GMacFrame frame, int grade, string subspaceName)
{
var basisCount = FrameUtils.KvSpaceDimension(frame.VSpaceDimension, grade);
var idsList = new List <int>(basisCount);
for (var index = 0; index < basisCount; index++)
{
idsList.Add(FrameUtils.BasisBladeId(grade, index));
}
var subspaceSignature = BooleanPattern.CreateFromTrueIndexes(frame.GaSpaceDimension, idsList);
var subspace = frame.DefineSubspace(subspaceName, subspaceSignature);
subspace.AddCodeLocation(Context.GetCodeLocation(frame.ParseNode));
}
///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 void Visit(GMacFrame frame)
{
Log.AppendAtNewLine("frame ");
Log.Append(frame.SymbolQualifiedName);
Log.Append("(");
Log.Append(
Generate_StringList(frame.BasisVectorNames)
);
Log.Append(")");
Log.IncreaseIndentation();
Log.AppendAtNewLine("signature ");
Log.Append("IPM ' ");
Log.Append(frame.SymbolicFrame.Ipm.ToString());
Log.AppendLine(" '");
Log.AppendLineAtNewLine();
foreach (var itam in frame.FrameSubspaces)
{
itam.AcceptVisitor(this);
}
Log.DecreaseIndentation();
Log.AppendLineAtNewLine();
foreach (var itam in frame.ChildConstants)
{
itam.AcceptVisitor(this);
}
foreach (var itam in frame.Structures)
{
itam.AcceptVisitor(this);
}
foreach (var itam in frame.ChildMacros)
{
itam.AcceptVisitor(this);
}
}
/// <summary>
/// Generate a constant defined inside a frame
/// </summary>
/// <param name="frame"></param>
/// <param name="constantName"></param>
/// <returns></returns>
private GMacConstant Create_Frame_Constant(GMacFrame frame, string constantName)
{
Context.PushState(frame.ChildSymbolScope);
if (frame.CanDefineChildSymbol(constantName) == false)
{
CompilationLog.RaiseGeneratorError <int>("Symbol name already used", RootParseNode);
}
var constantExpr = GMacExpressionGenerator.Translate(Context, RootParseNode.ChildNodes[1]);
var constantValue = GMacExpressionEvaluator.EvaluateExpression(Context.ActiveParentScope, constantExpr);
Context.PopState();
return(frame.DefineFrameConstant(constantName, constantValue));
}
private GMacStructure Create_Frame_Structure(GMacFrame frame, string structureName)
{
if (GMacCompilerFeatures.CanDefineFrameStructures == false)
{
CompilationLog.RaiseGeneratorError <int>("Can't define a structure inside a frame", RootParseNode);
}
Context.PushState(frame.ChildSymbolScope);
if (frame.CanDefineChildSymbol(structureName) == false)
{
CompilationLog.RaiseGeneratorError <int>("Symbol name already used", RootParseNode);
}
Context.PopState();
return(frame.DefineFrameStructure(structureName));
}
private static void DefineFrameDefaultSymbols(GMacFrame frame, GMacSymbolTranslatorContext context)
{
if (GMacCompilerFeatures.DefineFrameDefaultSymbols == false)
{
return;
}
if (frame.DefaultSymbolsReady)
{
return;
}
var gmacCode = FrameLibrary.Generate(new AstFrame(frame));
//context.CompilationLog.Trace.AppendLineAtNewLine("Generating default frame objects GMacDSL code");
//context.CompilationLog.Trace.AppendLineAtNewLine(gmacCode);
context.ParentProjectCompiler.CompileGeneratedCode(frame.SymbolAccessName + ".default.gmac", gmacCode);
frame.DefaultSymbolsReady = true;
}
private void translate_Frame_DerivedFrameSystem(GMacFrame derivedFrame, GMacFrame baseFrame)
{
var symbolicDerivedFrame = (GaFrameNonOrthogonal)derivedFrame.AssociatedSymbolicFrame;
if (ReferenceEquals(baseFrame, null))
{
var basisVectorsNames =
Enumerable
.Range(1, derivedFrame.VSpaceDimension)
.Select(i => "e" + i.ToString())
.ToArray();
baseFrame = DefineFrame(
derivedFrame.ObjectName + "_ortho_base",
basisVectorsNames,
symbolicDerivedFrame.BaseOrthogonalFrame,
true
);
}
var d2BOm =
new GMacMultivectorTransform(
derivedFrame.ObjectName + "_d2b_om",
derivedFrame.ParentScope,
derivedFrame,
baseFrame,
symbolicDerivedFrame.ThisToBaseFrameOm
);
var b2DOm =
new GMacMultivectorTransform(
derivedFrame.ObjectName + "_b2d_om",
derivedFrame.ParentScope,
baseFrame,
derivedFrame,
symbolicDerivedFrame.BaseFrameToThisOm
);
derivedFrame.SetDfs(baseFrame, d2BOm, b2DOm);
}
/// <summary>
/// Create the default subspace of odd multivectors named @odd@
/// </summary>
/// <returns></returns>
private GMacFrameSubspace DefineDefaultSubspaces_Odd(GMacFrame frame)
{
var idsList = new List <int>(frame.GaSpaceDimension);
for (var grade = 1; grade <= frame.VSpaceDimension; grade = grade + 2)
{
var basisCount = FrameUtils.KvSpaceDimension(frame.VSpaceDimension, grade);
for (var index = 0; index < basisCount; index++)
{
idsList.Add(FrameUtils.BasisBladeId(grade, index));
}
}
const string subspaceName = "Odd";
var subspaceSignature = BooleanPattern.CreateFromTrueIndexes(frame.GaSpaceDimension, idsList);
var subspace = frame.DefineSubspace(subspaceName, subspaceSignature);
subspace.AddCodeLocation(Context.GetCodeLocation(frame.ParseNode));
return(subspace);
}
///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);
}
internal AstFrameBasisBlade(GMacFrame frame, int grade, int index)
{
AssociatedMultivector = frame.MultivectorType;
BasisBladeId = GMacMathUtils.BasisBladeId(grade, index);
}
internal AstFrameBasisBlade(GMacFrame frame, int id)
{
AssociatedMultivector = frame.MultivectorType;
BasisBladeId = id;
}
internal AstFrame(GMacFrame frame)
{
AssociatedFrame = frame;
}
/// <summary>
/// Create the default constants for this frame
/// </summary>
public void DefineDefaultConstants(GMacFrame frame)
{
DefineDefaultConstants_I(frame);
}
internal static AstFrame ToAstFrame(this GMacFrame frame)
{
return(new AstFrame(frame));
}
/// <summary>
/// Translate the boolean pattern of a GMac frame subspace
/// </summary>
/// <param name="context"></param>
/// <param name="node"></param>
/// <param name="frame"></param>
/// <returns></returns>
public static MutableBooleanPattern Translate(GMacSymbolTranslatorContext context, ParseTreeNode node, GMacFrame frame)
{
context.PushState(node);
var translator = new GMacFrameSubspacePatternGenerator();//new GMacFrameSubspacePatternGenerator(context, frame);
translator.SetContext(context, frame);
translator.Translate();
context.PopState();
var result = translator._generatedBooleanPattern;
//MasterPool.Release(translator);
return(result);
}
//public override void ResetOnAcquire()
//{
// base.ResetOnAcquire();
// _frame = null;
// _generatedBooleanPattern = null;
//}
private void SetContext(GMacSymbolTranslatorContext context, GMacFrame frame)
{
SetContext(context);
_frame = frame;
_generatedBooleanPattern = new MutableBooleanPattern(frame.GaSpaceDimension, false);
}
private GMacMultivectorTransform Create_Frame_Transform(GMacFrame frame, string constantName)
{
//TODO: Complete this
return(null);
}
internal static AstFrameBasisBlade ToAstFrameBasisBlade(this GMacFrame frame, int id)
{
return(new AstFrameBasisBlade(frame, id));
}
internal static AstFrameBasisBlade ToAstFrameBasisBlade(this GMacFrame frame, int grade, int index)
{
return(new AstFrameBasisBlade(frame, grade, index));
}
