private LanguageValueAccess translate_FollowComponentsSequence(GMacStructure structure, LanguageValueAccess valAccess)
{
while (true)
{
//TODO: Search for a structure macro here
SymbolStructureDataMember dataMember;
if (structure.LookupDataMember(_qualList.FirstItem, out dataMember) == false)
{
CompilationLog.RaiseGeneratorError <LanguageValueAccess>("Structure member '" + _qualList.FirstItem + "' not recognized", RootParseNode);
}
valAccess.Append(dataMember.ObjectName, dataMember.SymbolType);
_qualList.IncreaseActiveStartOffset();
if (_qualList.ActiveLength <= 0)
{
return(valAccess);
}
if (!dataMember.SymbolType.IsStructure())
{
return(CompilationLog.RaiseGeneratorError <LanguageValueAccess>("Data components not recognized", RootParseNode));
}
structure = (GMacStructure)dataMember.SymbolType;
}
}
//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());
}
///node is 'Expression_Function_Inputs'
private void translate_Expression_Function_Inputs_2(ParseTreeNode node, out ILanguageExpression expr1, out ILanguageExpression expr2)
{
node.Assert(GMacParseNodeNames.ExpressionFunctionInputs);
expr1 = null;
expr2 = null;
var subNode = node.ChildNodes[0];
if (subNode.Term.ToString() == GMacParseNodeNames.ExpressionFunctionInputsExpressions)
{
var expressionFunctionInputsExpressionsNode = subNode;
if (expressionFunctionInputsExpressionsNode.ChildNodes.Count == 2)
{
expr1 =
GMacExpressionGenerator.Translate(BasicExpressionGenerator, subNode.ChildNodes[0]);
expr2 =
GMacExpressionGenerator.Translate(BasicExpressionGenerator, subNode.ChildNodes[1]);
return;
}
CompilationLog.RaiseGeneratorError <ILanguageExpression>("Expecting a single expression as input", node);
}
CompilationLog.RaiseGeneratorError <ILanguageExpression>("Expecting a single expression as input", node);
}
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));
}
}
private void translate_Command_Return(ParseTreeNode node)
{
var macro = Context.NearestParentMacro;
if (macro == null)
{
CompilationLog.RaiseGeneratorError <int>("Cannot use a return command outside of a macro definition body", node);
}
else
{
var lhsValue = LanguageValueAccess.Create(macro.OutputParameter);
var rhsExpr = GMacExpressionGenerator.Translate(Context, node.ChildNodes[0]);
if (lhsValue.ExpressionType.CanAssignValue(rhsExpr.ExpressionType))
{
Context.ActiveParentCommandBlock.AddCommand_Assign(lhsValue, rhsExpr);
}
else
{
CompilationLog.RaiseGeneratorError <int>(
"Cannot assign RHS of type " + rhsExpr.ExpressionType.TypeSignature + " to LHS of type " +
lhsValue.ExpressionType.TypeSignature, node);
}
}
}
///Select the signature definition method of the current frame
private GaFrame translate_Frame_Signature(ParseTreeNode node)
{
var subnode = node.ChildNodes[0];
switch (subnode.ToString())
{
case GMacParseNodeNames.FrameSignatureEuclidean:
return(GaFrame.CreateEuclidean(_vSpaceDim));
case GMacParseNodeNames.FrameSignatureIpm:
return(translate_Frame_Signature_IPM(subnode));
case GMacParseNodeNames.FrameSignatureCbm:
return(translate_Frame_Signature_CBM(subnode));
case GMacParseNodeNames.FrameSignatureOrthonormal:
return(translate_Frame_Signature_Orthonormal(subnode));
case GMacParseNodeNames.FrameSignatureOrthogonal:
return(translate_Frame_Signature_Orthogonal(subnode));
case GMacParseNodeNames.FrameSignatureReciprocal:
return(translate_Frame_Signature_Reciprocal(subnode));
default:
return(CompilationLog.RaiseGeneratorError <GaFrame>("Illegal frame signature definition", subnode));
}
}
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);
}
}
///Translate a constant number (Int32 or Double)
private ILanguageExpression translate_Constant_Number(ParseTreeNode node)
{
var numberText = node.FindTokenAndGetText();
Int32 intNumber;
if (Int32.TryParse(numberText, out intNumber))
{
return(ValuePrimitive <MathematicaScalar> .Create(
GMacRootAst.ScalarType,
MathematicaScalar.Create(SymbolicUtils.Cas, intNumber)
));
}
Double doubleNumber;
if (Double.TryParse(numberText, out doubleNumber))
{
return(ValuePrimitive <MathematicaScalar> .Create(
GMacRootAst.ScalarType,
MathematicaScalar.Create(SymbolicUtils.Cas, doubleNumber)
));
}
return(CompilationLog.RaiseGeneratorError <ILanguageExpression>("Constant number not recognized", node));
}
private LanguageValueAccess translate_StartAt_DirectSymbol(LanguageSymbol startSymbol)
{
return
(_qualList.ActiveLength == 0
? LanguageValueAccess.Create(startSymbol)
: CompilationLog.RaiseGeneratorError <LanguageValueAccess>("Components not recognized", RootParseNode));
}
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));
}
///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 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));
}
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);
}
}
private GMacMacro Create_Structure_Macro(GMacStructure structure, string macroName)
{
if (structure.CanDefineChildSymbol(macroName) == false)
{
CompilationLog.RaiseGeneratorError <int>("Symbol name already used", RootParseNode);
}
//Create the macro and add it to the symbol table
return(structure.DefineStructureMacro(macroName));
//TODO: add the 'this' parameter after the result parameter for structure macros
}
///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));
}
///node is 'Expression_Function_Inputs_opt'
private ILanguageExpression translate_Expression_Function_Transform(GMacMultivectorTransform transform, ParseTreeNode node)
{
if (node.ChildNodes.Count != 1)
{
return
(CompilationLog.RaiseGeneratorError <ILanguageExpression>(
"Expecting a single expression as input to the transform", node));
}
var expr = translate_Expression_Function_Inputs_1(node.ChildNodes[0]);
return(BasicExpressionGenerator.Generate_TransformApplication(transform, expr));
}
private ILanguageExpression translate_BuiltinMacro_grade_inv(ParseTreeNode node)
{
if (node.ChildNodes.Count != 1)
{
return
(CompilationLog.RaiseGeneratorError <ILanguageExpression>(
"Expecting a single expression as input to the builtin macro", node));
}
var expr = translate_Expression_Function_Inputs_1(node.ChildNodes[0]);
return(BasicExpressionGenerator.Generate_UnaryGradeInversion(expr));
}
private ILanguageExpression translate_Expression_Function_Cast(TypePrimitive targetType, ParseTreeNode node)
{
if (node.ChildNodes.Count != 1)
{
return
(CompilationLog.RaiseGeneratorError <ILanguageExpression>(
"Expecting a single expression as input to the type cast operation", node));
}
var expr = translate_Expression_Function_Inputs_1(node.ChildNodes[0]);
return(BasicExpressionGenerator.Generate_TypeCast(targetType, targetType, expr));
}
/// <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));
}
private void translate_Constant()
{
try
{
Context.MarkCheckPointState();
string childSymbolName;
SymbolWithScope parentSymbol;
Translate_ParentSymbolAndChildSymbolName(RootParseNode.ChildNodes[0], out parentSymbol, out childSymbolName);
var nameSpace = parentSymbol as GMacNamespace;
if (nameSpace != null)
{
_generatedConstant = Create_Namespace_Constant(nameSpace, childSymbolName);
}
else
{
var frame = parentSymbol as GMacFrame;
if (frame != null)
{
_generatedConstant = Create_Frame_Constant(frame, childSymbolName);
}
else
{
CompilationLog.RaiseGeneratorError <int>("Expecting a Frame or Namespace scope", RootParseNode.ChildNodes[0]);
}
}
_generatedConstant.CodeLocation = Context.GetCodeLocation(RootParseNode);
Context.UnmarkCheckPointState();
Context.CompilationLog.ReportNormal("Translated Constant: " + _generatedConstant.SymbolAccessName, ProgressEventArgsResult.Success);
}
catch (CompilerException)
{
Context.RestoreToCheckPointState();
Context.CompilationLog.ReportNormal("Translate Constant", ProgressEventArgsResult.Failure);
}
catch (Exception e)
{
Context.RestoreToCheckPointState();
Context.CompilationLog.ReportError("Translate Constant Failed With Error", e);
}
}
private GMacMacro Create_Namespace_Macro(GMacNamespace nameSpace, string macroName)
{
if (GMacCompilerFeatures.CanDefineNamespaceMacros == false)
{
CompilationLog.RaiseGeneratorError <int>("Can't define a macro inside a namespace", RootParseNode);
}
if (nameSpace.CanDefineChildSymbol(macroName) == false)
{
CompilationLog.RaiseGeneratorError <int>("Symbol name already used", RootParseNode);
}
//Create the macro and add it to the symbol table
return(nameSpace.DefineNamespaceMacro(macroName));
}
private ILanguageExpression translate_BuiltinMacro_diff(ParseTreeNode node)
{
if (node.ChildNodes.Count != 1)
{
return
(CompilationLog.RaiseGeneratorError <ILanguageExpression>(
"Expecting two expressions as input to the builtin macro", node));
}
ILanguageExpression expr1, expr2;
translate_Expression_Function_Inputs_2(node.ChildNodes[0], out expr1, out expr2);
return(BasicExpressionGenerator.Generate_Diff(expr1, expr2));
}
///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);
}
private LanguageValueAccess translate_Qualified_BasisBladeCoefficient(ParseTreeNode node)
{
var valAccess = translate_Qualified_Identifier(node.ChildNodes[0]);
if (!valAccess.ExpressionType.IsFrameMultivector())
{
return(CompilationLog.RaiseGeneratorError <LanguageValueAccess>("cannot find basis blade coefficient",
RootParseNode));
}
var frame = ((GMacFrameMultivector)valAccess.ExpressionType).ParentFrame;
var basisBladesIds = GMacFrameSubspacePatternGenerator.Translate(Context, node.ChildNodes[1], frame);
return(valAccess.Append(basisBladesIds.FirstTrueIndex, GMacRootAst.ScalarType));
}
private GMacFrame DefineFrame(string frameName, string[] basisVectorsNames, GaFrame attachedSymbolicFrame, bool defineDefaultObjects)
{
if (Context.GMacRootAst.FramesCount + 1 > GMacCompilerFeatures.MaxFramesNumber)
{
CompilationLog.RaiseGeneratorError <int>($"Can't define more than {GMacCompilerFeatures.MaxFramesNumber} frames", RootParseNode);
}
var frame = Context.ParentNamespace.DefineFrame(frameName, basisVectorsNames, attachedSymbolicFrame);
if (defineDefaultObjects)
{
DefineFrameDefaultObjects(frame);
}
return(frame);
}
/// <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 LanguageValueAccess translate_StartAt_NamespaceDefinition(GMacNamespace nameSpace)
{
while (true)
{
if (_qualList.ActiveLength == 0)
{
return(LanguageValueAccess.Create(nameSpace));
}
LanguageSymbol symbol;
if (nameSpace.ChildSymbolScope.LookupSymbol(_qualList.FirstItem, out symbol) == false)
{
CompilationLog.RaiseGeneratorError <LanguageValueAccess>("Symbol name not recognized", RootParseNode);
}
_qualList.IncreaseActiveStartOffset(1);
if (_isLValue)
{
CompilationLog.RaiseGeneratorError <int>("LValue symbol name not recognized", RootParseNode);
}
switch (symbol.SymbolRoleName)
{
case RoleNames.Constant:
return(translate_StartAt_DataSymbol((SymbolDataStore)symbol));
case RoleNames.Structure:
case RoleNames.Macro:
case RoleNames.Transform:
return(translate_StartAt_DirectSymbol(symbol));
case RoleNames.Frame:
return(translate_StartAt_FrameDefinition((GMacFrame)symbol));
case RoleNames.Namespace:
nameSpace = (GMacNamespace)symbol;
continue;
default:
return(CompilationLog.RaiseGeneratorError <LanguageValueAccess>("RValue symbol name not recognized", RootParseNode));
}
}
}
private GMacStructure Create_Namespace_Structure(GMacNamespace nameSpace, string structureName)
{
if (GMacCompilerFeatures.CanDefineNamespaceStructures == false)
{
CompilationLog.RaiseGeneratorError <int>("Can't define a structure inside a namespace", RootParseNode);
}
Context.PushState(nameSpace.ChildSymbolScope);
if (nameSpace.CanDefineChildSymbol(structureName) == false)
{
CompilationLog.RaiseGeneratorError <int>("Symbol name already used", RootParseNode);
}
Context.PopState();
return(nameSpace.DefineNamespaceStructure(structureName));
}
///node is 'Expression_Function_Inputs'
private ILanguageExpression translate_Expression_Function_Inputs_1(ParseTreeNode node)
{
node.Assert(GMacParseNodeNames.ExpressionFunctionInputs);
var subNode = node.ChildNodes[0];
if (subNode.Term.ToString() != GMacParseNodeNames.ExpressionFunctionInputsExpressions)
{
return(CompilationLog.RaiseGeneratorError <ILanguageExpression>("Expecting a single expression as input", node));
}
var expressionFunctionInputsExpressionsNode = subNode;
return
(expressionFunctionInputsExpressionsNode.ChildNodes.Count == 1
? GMacExpressionGenerator.Translate(BasicExpressionGenerator, subNode.ChildNodes[0])
: CompilationLog.RaiseGeneratorError <ILanguageExpression>("Expecting a single expression as input", node));
}
