public ILanguageExpressionBasic Generate_TransformApplication(GMacMultivectorTransform transform, ILanguageExpression expr)
{
SetOperands(expr);
VerifyOperation_TransformApplication(transform);
return(BasicUnary.Create(_resultType, transform, _atomicOperand1));
}
public void Visit(GMacMultivectorTransform transform)
{
Log.AppendAtNewLine("transform ");
Log.Append(transform.SymbolAccessName);
Log.Append(" from ");
Log.Append(transform.SourceFrame.SymbolAccessName);
Log.Append(" to ");
Log.Append(transform.TargetFrame.SymbolAccessName);
Log.AppendLineAtNewLine();
}
///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));
}
public void Visit(GMacMultivectorTransform transform)
{
var nodeName =
transform.SymbolAccessName + " : " +
transform.SourceFrame.SymbolAccessName + " -> " +
transform.TargetFrame.SymbolAccessName;
var node = new TreeNode(nodeName)
{
Tag = transform
};
RoleNodes[TransformsNode].Nodes.Add(node);
}
private void translate_Transform()
{
try
{
Context.MarkCheckPointState();
string childSymbolName;
SymbolWithScope parentSymbol;
Translate_ParentSymbolAndChildSymbolName(RootParseNode.ChildNodes[0], out parentSymbol, out childSymbolName);
var nameSpace = parentSymbol as GMacNamespace;
if (nameSpace != null)
{
_generatedTransform = Create_Namespace_Transform(nameSpace, childSymbolName);
}
else
{
var frame = parentSymbol as GMacFrame;
if (frame != null)
{
_generatedTransform = Create_Frame_Transform(frame, childSymbolName);
}
else
{
CompilationLog.RaiseGeneratorError <int>("Expecting a Frame or Namespace scope", RootParseNode.ChildNodes[0]);
}
}
_generatedTransform.CodeLocation = Context.GetCodeLocation(RootParseNode);
Context.UnmarkCheckPointState();
Context.CompilationLog.ReportNormal("Translated Transform: " + _generatedTransform.SymbolAccessName, ProgressEventArgsResult.Success);
}
catch (CompilerException)
{
Context.RestoreToCheckPointState();
Context.CompilationLog.ReportNormal("Translate Transform", ProgressEventArgsResult.Failure);
}
catch (Exception e)
{
Context.RestoreToCheckPointState();
Context.CompilationLog.ReportError("Translate Transform Failed With Error", e);
}
}
private void VerifyOperation_TransformApplication(GMacMultivectorTransform transform)
{
if (Operand1Type.IsNumber())
{
ForceAtomicScalarOperands(transform.TargetFrame.MultivectorType);
}
else if (Operand1Type.IsFrameMultivector() && ((GMacFrameMultivector)Operand1Type).ParentFrame.ObjectId == transform.SourceFrame.ObjectId)
{
ForceAtomicMultivectorOperands(transform.TargetFrame.MultivectorType);
}
else
{
Context.CreateTypeMismatch("Cannot apply transform " + transform.SymbolQualifiedName + " to expression of type " + Operand1TypeSignature);
}
}
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);
}
public TreeNode Visit(GMacMultivectorTransform transform)
{
var node = new TreeNode("<TRANSFORM> " + transform.ObjectName)
{
Tag = transform
};
var subNode = new TreeNode("<FROM> " + transform.SourceFrame.SymbolAccessName)
{
Tag = transform.SourceFrame
};
node.Nodes.Add(subNode);
subNode = new TreeNode("<TO> " + transform.TargetFrame.SymbolAccessName)
{
Tag = transform.TargetFrame
};
node.Nodes.Add(subNode);
return(node);
}
internal static AstTransform ToAstTransform(this GMacMultivectorTransform transform)
{
return(new AstTransform(transform));
}
internal AstTransform(GMacMultivectorTransform transform)
{
AssociatedTransform = transform;
}
