protected override void Translate()
{
var expressionText = GenUtils.Translate_StringLiteral(RootParseNode);
if (
expressionText.First() == '$' &&
expressionText.Last() == '$' &&
expressionText.Count(c => c == '$') == 2
)
{
//If the expression is on the form '$ anything $' convert it into a normal multivector expression
//based on (anything) alone; not a symbolic expression
expressionText = expressionText.Substring(1, expressionText.Length - 2).Trim();
_generatedExpression = translate_LanguageExpression(expressionText);
return;
}
MathematicaScalar scalar;
OperandsByName operands;
translate_Dependency_List(expressionText, out scalar, out operands);
_generatedExpression = BasicExpressionGenerator.Generate_SymbolicExpression(scalar, operands);
}
private void translate_Dependency_List(string expressionText, out MathematicaScalar scalar, out OperandsByName operands)
{
var finalScalarText = new StringBuilder(expressionText);
operands = OperandsByName.Create();
var varIdx = 1;
var allMatches = GenUtils.ExtractDistinctInternalExpressions(expressionText);
foreach (var rgexMatch in allMatches)
{
var rhsExprText = rgexMatch.Value.Substring(1, rgexMatch.Value.Length - 2);
var rhsExpr =
BasicExpressionGenerator.Generate_PolyadicOperand(
GMacRootAst.ScalarType,
translate_LanguageExpression(rhsExprText)
);
var lhsVarName = "var" + (varIdx++).ToString("0000");
finalScalarText = finalScalarText.Replace(rgexMatch.Value, lhsVarName);
operands.AddOperand(lhsVarName, rhsExpr);
}
scalar = MathematicaScalar.Create(Cas, finalScalarText.ToString());
}
//public override void ResetOnAcquire()
//{
// base.ResetOnAcquire();
// _vSpaceDim = 0;
// _baseFrame = null;
// _generatedFrame = null;
//}
///Read the list of basis vectors names for the current frame
private string[] translate_Frame_Vectors(ParseTreeNode node)
{
node.Assert(GMacParseNodeNames.FrameVectors);
var basisVectorsNames = new List <string>();
foreach (var subnode in node.ChildNodes)
{
var basisVectorName = GenUtils.Translate_Identifier(subnode);
if (basisVectorsNames.Contains(basisVectorName))
{
CompilationLog.RaiseGeneratorError <int>("Basis vector name already defined", subnode);
}
basisVectorsNames.Add(basisVectorName);
}
if (basisVectorsNames.Count > FrameUtils.MaxVSpaceDimension)
{
CompilationLog.RaiseGeneratorError <int>("Cannot handle spaces with dimension larger than " + FrameUtils.MaxVSpaceDimension, node);
}
return(basisVectorsNames.ToArray());
}
private void translate_Outerproduct_List_SingleIdentifier(ParseTreeNode node)
{
var identName = GenUtils.Translate_Identifier(node);
GMacFrameSubspace subspace;
if (_frame.LookupSubspace(identName, out subspace))
{
AddBasisBladeIDs(subspace);
}
else
{
GMacFrameBasisVector basisVector;
if (_frame.LookupBasisVector(identName, out basisVector))
{
AddBasisBladeId(basisVector.BasisVectorId);
}
else
{
translate_PredefinedBasisBladeIDs(identName, node);
}
}
}
///Set the signature of the current frame to a signature vector (diagonal IPM)
private GaFrame translate_Frame_Signature_Orthogonal(ParseTreeNode node)
{
var bvSigVector = MathematicaVector.Create(Cas, GenUtils.Translate_StringLiteral(node.ChildNodes[0]));
if (bvSigVector.Size != _vSpaceDim)
{
CompilationLog.RaiseGeneratorError <int>("Expecting a vector with " + _vSpaceDim + " items", node.ChildNodes[0]);
}
return(GaFrame.CreateOrthogonal(bvSigVector));
}
///Set the signature of the current frame to a signature vector of +1's and -1's (diagonal IPM)
private GaFrame translate_Frame_Signature_Orthonormal(ParseTreeNode node)
{
var bvSigString = GenUtils.Translate_StringLiteral(node.ChildNodes[0]).Trim();
if (bvSigString.Count(c => c == '+' || c == '-') != _vSpaceDim || bvSigString.Length != _vSpaceDim)
{
CompilationLog.RaiseGeneratorError <int>("Expecting a vector of " + _vSpaceDim + @" (+\-) items", node.ChildNodes[0]);
}
return(GaFrame.CreateOrthonormal(bvSigString));
}
///Set the signature of the current frame to be defined by IPM
private GaFrame translate_Frame_Signature_IPM(ParseTreeNode node)
{
//Read the IPM symbolic matrix
var ipmMatrix = MathematicaMatrix.Create(Cas, GenUtils.Translate_StringLiteral(node.ChildNodes[0]));
if (ipmMatrix.IsSymmetric() == false || ipmMatrix.Rows != _vSpaceDim)
{
CompilationLog.RaiseGeneratorError <int>("Expecting a square symmetric matrix with " + _vSpaceDim + " rows", node.ChildNodes[0]);
}
return(GaFrame.CreateFromIpm(ipmMatrix));
}
/// <summary>
/// For the given parent scope this method extracts an identifier from the given node and
/// returns it if it isn't already used for a child symbol of the scope.
/// Else it raises a generator exception
/// </summary>
/// <param name="parentScope"></param>
/// <param name="node"></param>
/// <returns></returns>
protected string TranslateChildSymbolName(LanguageScope parentScope, ParseTreeNode node)
{
//Read the name of the new child symbol
var childSymbolName = GenUtils.Translate_Identifier(node);
//Make sure the child symbol name is not used inside the parent scope
if (parentScope.SymbolExists(childSymbolName))
{
CompilationLog.RaiseGeneratorError <int>("Child symbol name already used", node);
}
return(childSymbolName);
}
private CommandDeclareVariable translate_Identifier_Declaration(ParseTreeNode node)
{
//Read the name of the member
var identifierName = GenUtils.Translate_Identifier(node.ChildNodes[0]);
if (Context.ActiveParentScope.SymbolExists(identifierName))
{
return(CompilationLog.RaiseGeneratorError <CommandDeclareVariable>("Identifier name already used", node.ChildNodes[0]));
}
var identifierType = GMacValueAccessGenerator.Translate_Direct_LanguageType(Context, node.ChildNodes[1]);
return(translate_Declare(identifierName, identifierType));
}
//public override void ResetOnAcquire()
//{
// base.ResetOnAcquire();
// _generatedExpression = null;
//}
//public GMacExpressionBasicGenerator BasicExpressionGenerator { get; private set; }
//private GMacExpressionCompositeGenerator(GMacSymbolTranslatorContext context)
// : base(context)
//{
// //BasicExpressionGenerator = new GMacExpressionBasicGenerator(context);
//}
//private GMacExpressionCompositeGenerator(GMacExpressionBasicGenerator basic_expr_gen)
// : base(basic_expr_gen.Context)
//{
// BasicExpressionGenerator = basic_expr_gen;
//}
private SymbolLocalVariable translate_Identifier_Declaration(ParseTreeNode node)
{
//Read the name of the member
var identifierName = GenUtils.Translate_Identifier(node.ChildNodes[0]);
if (Context.ActiveParentScope.SymbolExists(identifierName))
{
return(CompilationLog.RaiseGeneratorError <SymbolLocalVariable>("Identifier name already used", node.ChildNodes[0]));
}
var identifierType = GMacValueAccessGenerator.Translate_Direct_LanguageType(Context, node.ChildNodes[1]);
//Create the member in the symbol table
return
(Context
.ActiveParentCompositeExpression
.DefineLocalVariable(identifierName, identifierType)
.LocalVariable);
}
//protected void SetContext(GMacSymbolTranslatorContext context)
//{
// this.SetContext((SymbolTranslatorContext)context);
//}
/// <summary>
/// Take a qualified indetifier node and separate it into a parent symbol and a child symbol name
/// </summary>
/// <param name="node"></param>
/// <param name="parentSymbol"></param>
/// <param name="childSymbolName"></param>
protected bool Translate_ParentSymbolAndChildSymbolName(ParseTreeNode node, out SymbolWithScope parentSymbol, out string childSymbolName)
{
var qualList = GenUtils.Translate_Qualified_Identifier(node);
childSymbolName = qualList.LastItem;
if (qualList.ActiveLength == 1)
{
parentSymbol = Context.ActiveParentSymbol;
}
else
{
qualList.DecreaseActiveEndOffset();
parentSymbol = GMacValueAccessGenerator.Translate_Direct(Context, node, qualList) as SymbolWithScope;
}
return(ReferenceEquals(parentSymbol, null) == false);
}
private static bool TryTranslate_LValue(GMacSymbolTranslatorContext context, ParseTreeNode node, out LanguageValueAccess varAccess)
{
var qualList = GenUtils.Translate_Qualified_Identifier(node);
LanguageSymbol symbol;
var flag =
context
.OpenedDistinctScopes()
.LookupSymbol(qualList.FirstItem, out symbol);
if (flag == false || (symbol is SymbolLValue) == false)
{
varAccess = null;
return(false);
}
varAccess = LanguageValueAccess.Create(symbol);
return(true);
}
//public override void ResetOnAcquire()
//{
// base.ResetOnAcquire();
// _generatedMacroTemplate = null;
//}
private void translate_MacroTemplate()
{
try
{
Context.MarkCheckPointState();
var nodeMacro = RootParseNode.ChildNodes[0];
//Read the name of the new macro template
var qualList = GenUtils.Translate_Qualified_Identifier(nodeMacro.ChildNodes[0]);
if (qualList.ActiveLength > 1)
{
CompilationLog.RaiseGeneratorError <int>("Template name cannot be a qualified name", RootParseNode.ChildNodes[0]);
}
var templateName = qualList.FirstItem;
if (Context.ParentNamespace.CanDefineChildSymbol(templateName) == false)
{
CompilationLog.RaiseGeneratorError <int>("Symbol name already used", RootParseNode.ChildNodes[0]);
}
_generatedMacroTemplate =
Context.ParentNamespace.DefineMacroTemplate(templateName, nodeMacro);
_generatedMacroTemplate.CodeLocation = Context.GetCodeLocation(RootParseNode);
Context.UnmarkCheckPointState();
}
catch (CompilerException)
{
Context.RestoreToCheckPointState();
}
catch (Exception e)
{
Context.RestoreToCheckPointState();
throw new Exception("Unhandled Exception", e);
}
}
private void translate_BasisBladesSet_List_Item_GASpan(ParseTreeNode node)
{
var nodeIdentifierList = node.ChildNodes[0];
//Create the set of unique spanning vectors for the GA subspace
var basisVectorsList = new List <int>(nodeIdentifierList.ChildNodes.Count);
foreach (var nodeIdentifier in nodeIdentifierList.ChildNodes)
{
GMacFrameBasisVector basisVector;
var basisVectorName = GenUtils.Translate_Identifier(nodeIdentifier);
if (_frame.LookupBasisVector(basisVectorName, out basisVector) == false)
{
CompilationLog.RaiseGeneratorError <int>("Basis vector not recognized", nodeIdentifier);
}
//Only add unique basis vectors to the spanning set
if (basisVectorsList.Exists(x => x == basisVector.BasisVectorId) == false)
{
basisVectorsList.Add(basisVector.BasisVectorId);
}
}
//Compute the dimension of the GA spanned by the basis vectors
var subspaceDimension = 1 << basisVectorsList.Count;
//Scalars are always part of the GA subspace based on any given set of basis vectors
AddBasisBladeId(0);
//Add the remaining basis blades to the GA subspace
for (var idIndex = 1; idIndex <= subspaceDimension - 1; idIndex++)
{
var id = FrameUtils.ComposeGaSubspaceBasisBladeId(basisVectorsList, idIndex);
AddBasisBladeId(id);
}
}
///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);
}
private void translate_Outerproduct_List(ParseTreeNode node)
{
if (node.ChildNodes.Count == 1)
{
translate_Outerproduct_List_SingleIdentifier(node.ChildNodes[0]);
}
else if (node.ChildNodes.Count > 1)
{
var basisVectorsList = new List <GMacFrameBasisVector>(node.ChildNodes.Count);
var basisBladeId = 0;
foreach (var nodeIdentifier in node.ChildNodes)
{
GMacFrameBasisVector basisVector;
var basisVectorName = GenUtils.Translate_Identifier(nodeIdentifier);
if (_frame.LookupBasisVector(basisVectorName, out basisVector) == false)
{
CompilationLog.RaiseGeneratorError <int>("Basis vector not recognized", nodeIdentifier);
}
if (basisVectorsList.Exists(x => x.BasisVectorId == basisVector.BasisVectorId))
{
CompilationLog.RaiseGeneratorError <int>("Basis blades set not recognized", node);
}
basisVectorsList.Add(basisVector);
basisBladeId = basisBladeId | basisVector.BasisVectorId;
}
AddBasisBladeId(basisBladeId);
}
else
{
CompilationLog.RaiseGeneratorError <int>("Basis blades set not recognized", node);
}
}
//public override void ResetOnAcquire()
//{
// base.ResetOnAcquire();
// _generatedNamespace = null;
//}
private void translate_Namespace()
{
try
{
Context.MarkCheckPointState();
//Read the namespace name: for example main.conformal.cga5d
var qualList = GenUtils.Translate_Qualified_Identifier(RootParseNode.ChildNodes[0]);
//Find the root namespace inside the root global scope of the GMacDSL (search for a namespace called 'main')
GMacNamespace nameSpace;
if (GMacRootAst.LookupRootNamespace(qualList.FirstItem, out nameSpace) == false)
{
if (GMacRootAst.RootScope.SymbolExists(qualList.FirstItem))
{
CompilationLog.RaiseGeneratorError <int>("Namespace name already used", RootParseNode.ChildNodes[0]);
}
nameSpace = GMacRootAst.DefineRootNamespace(qualList.FirstItem);
}
//Starting from the created\found root namespace, repeat the previous operation for each child namespace in qual_list
for (var i = 1; i < qualList.ActiveLength; i++)
{
GMacNamespace childNamespace;
if (nameSpace.LookupNamespace(qualList[i], out childNamespace))
{
nameSpace = childNamespace;
}
else
{
if (nameSpace.CanDefineChildSymbol(qualList[i]) == false)
{
CompilationLog.RaiseGeneratorError <int>("Symbol with same name already exists", RootParseNode.ChildNodes[0]);
}
nameSpace = nameSpace.DefineNamespace(qualList[i]);
}
}
_generatedNamespace = nameSpace;
_generatedNamespace.AddCodeLocation(Context.GetCodeLocation(RootParseNode));
Context.UnmarkCheckPointState();
Context.CompilationLog.ReportNormal("Translated Namespace: " + _generatedNamespace.SymbolAccessName, ProgressEventArgsResult.Success);
}
catch (CompilerException)
{
Context.RestoreToCheckPointState();
Context.CompilationLog.ReportNormal("Translate Namespace Failed", ProgressEventArgsResult.Failure);
}
catch (Exception e)
{
Context.RestoreToCheckPointState();
Context.CompilationLog.ReportError("Translate Namespace Failed With Error", e);
}
}
private LanguageValueAccess translate_Qualified_Identifier(ParseTreeNode node)
{
//If _QualList is not already filled, translate the current parse node into a list of identifiers
if (_qualList == null)
{
_qualList = GenUtils.Translate_Qualified_Identifier(node);
}
//Lookup the first item of the translated list of identifiers within the current context
LanguageSymbol symbol;
var flag =
_followScopeChain
//? Context.LookupSymbolInOpenedDistinctScopes(_qualList.FirstItem, out symbol)
? Context.OpenedDistinctScopes().LookupSymbol(_qualList.FirstItem, out symbol)
: Context.ActiveParentScope.LookupSymbol(_qualList.FirstItem, out symbol);
if (flag == false)
{
return(CompilationLog.RaiseGeneratorError <LanguageValueAccess>("Symbol name not recognized", RootParseNode));
}
//Ignore the first item from the list
_qualList.IncreaseActiveStartOffset(1);
if (_isLValue)
{
//This is an l-value
switch (symbol.SymbolRoleName)
{
case RoleNames.StructureDataMember:
case RoleNames.MacroParameter:
case RoleNames.LocalVariable:
return(translate_StartAt_DataSymbol((SymbolDataStore)symbol));
default:
return(CompilationLog.RaiseGeneratorError <LanguageValueAccess>("LValue symbol name not recognized", RootParseNode));
}
}
//This is an r-value
switch (symbol.SymbolRoleName)
{
case RoleNames.MacroParameter:
case RoleNames.LocalVariable:
case RoleNames.Constant:
return(translate_StartAt_DataSymbol((SymbolDataStore)symbol));
case RoleNames.FrameBasisVector:
case RoleNames.BuiltinType:
case RoleNames.FrameMultivector:
case RoleNames.Structure:
case RoleNames.Macro:
case RoleNames.MacroTemplate:
case RoleNames.Transform:
case RoleNames.FrameSubspace:
//case RoleNames.Binding:
return(translate_StartAt_DirectSymbol(symbol));
case RoleNames.Frame:
return(translate_StartAt_FrameDefinition((GMacFrame)symbol));
case RoleNames.Namespace:
return(translate_StartAt_NamespaceDefinition((GMacNamespace)symbol));
default:
return(CompilationLog.RaiseGeneratorError <LanguageValueAccess>("RValue symbol name not recognized", RootParseNode));
}
}
