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);
}
}
}
///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 ILanguageExpression translate_Expression_Scoped(ParseTreeNode node)
{
var frame =
(GMacFrame)GMacValueAccessGenerator.Translate_Direct(Context, node.ChildNodes[0], RoleNames.Frame);
Context.OpenScope(frame);
var expr = GMacExpressionGenerator.Translate(Context, node.ChildNodes[1]);
Context.CloseScope(frame);
return(expr);
}
/// <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));
}
///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));
}
public static ILanguageExpression Translate(GMacExpressionBasicGenerator basicExprGen, ParseTreeNode node)
{
var context = basicExprGen.Context;
context.PushState(node);
var translator = new GMacExpressionGenerator();//new GMacExpressionGenerator(basicExprGen);
translator.SetContext(basicExprGen);
translator.Translate();
context.PopState();
var result = translator._generatedExpression;
//MasterPool.Release(translator);
return(result);
}
//public override void ResetOnAcquire()
//{
// base.ResetOnAcquire();
// _generatedConstant = null;
//}
/// <summary>
/// Generate a constant defined inside a namespace
/// </summary>
/// <param name="nameSpace"></param>
/// <param name="constantName"></param>
/// <returns></returns>
private GMacConstant Create_Namespace_Constant(GMacNamespace nameSpace, string constantName)
{
if (GMacCompilerFeatures.CanDefineNamespaceConstants == false)
{
CompilationLog.RaiseGeneratorError <int>("Can't define a constant inside a namespace", RootParseNode);
}
Context.PushState(nameSpace.ChildSymbolScope);
if (nameSpace.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(nameSpace.DefineNamespaceConstant(constantName, constantValue));
}
//private ILanguageExpression translate_Expression_Cast(ParseTreeNode node)
//{
// var langType = GMacValueAccessGenerator.Translate_Direct_LanguageType(this.Context, node.ChildNodes[0]);
// var expr = GMacExpressionGenerator.Translate(this.BasicExpressionGenerator, node.ChildNodes[0]);
// return this.BasicExpressionGenerator.Generate_TypeCast(langType, expr);
//}
protected override void Translate()
{
var subNode = RootParseNode.ChildNodes[0];
switch (subNode.Term.Name)
{
case GMacParseNodeNames.ConstantNumber:
_generatedExpression = translate_Constant_Number(subNode);
break;
case GMacParseNodeNames.ExpressionScoped:
_generatedExpression = translate_Expression_Scoped(subNode);
break;
case GMacParseNodeNames.QualifiedItem:
_generatedExpression = GMacValueAccessGenerator.Translate(Context, subNode.ChildNodes[0], false);
break;
case GMacParseNodeNames.ExpressionBracketed:
_generatedExpression = GMacExpressionGenerator.Translate(BasicExpressionGenerator, subNode.ChildNodes[0]);
break;
case GMacParseNodeNames.StringLiteral:
_generatedExpression = GMacExpressionAtomicSymbolicGenerator.Translate(Context, subNode);
break;
case GMacParseNodeNames.ExpressionComposite:
_generatedExpression = GMacExpressionCompositeGenerator.Translate(Context, subNode);
break;
case GMacParseNodeNames.ExpressionFunction:
_generatedExpression = GMacExpressionAtomicFunctionGenerator.Translate(BasicExpressionGenerator, subNode);
break;
default:
CompilationLog.RaiseGeneratorError <ILanguageExpression>("Expression not recognized", RootParseNode);
break;
}
}
//Translate a 'let' statement
private void translate_Command_Let(ParseTreeNode node)
{
var rhsExpr = GMacExpressionGenerator.Translate(Context, node.ChildNodes[1]);
var lhsValue = translate_Command_Let_LHS(rhsExpr.ExpressionType, node.ChildNodes[0]);
if (lhsValue.IsOutputParameter)
{
CompilationLog.RaiseGeneratorError <int>("Assignment to the output parameter not allowed. Use return <expression> instead", node);
}
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);
}
}
private ILanguageExpression translate_Expression_Function_Macro(GMacMacro macro, ParseTreeNode node)
{
var operands = OperandsByValueAccess.Create();
if (node.ChildNodes.Count == 0)
{
return(BasicPolyadic.Create(macro.OutputParameterType, macro, operands));
}
var expressionFunctionInputsNode = node.ChildNodes[0];
var subNode = expressionFunctionInputsNode.ChildNodes[0];
switch (subNode.Term.ToString())
{
case GMacParseNodeNames.ExpressionFunctionInputsAssignments:
var expressionFunctionInputsAssignmentsNode = subNode;
foreach (var nodeExpressionFunctionInputsAssignmentsItem in expressionFunctionInputsAssignmentsNode.ChildNodes)
{
var lhsNode = nodeExpressionFunctionInputsAssignmentsItem.ChildNodes[0].ChildNodes[0];
var rhsNode = nodeExpressionFunctionInputsAssignmentsItem.ChildNodes[1];
var lhsValAccess = GMacValueAccessGenerator.Translate_LValue_MacroParameter(Context, lhsNode, macro);
var rhsExpr =
BasicExpressionGenerator.Generate_PolyadicOperand(
lhsValAccess.ExpressionType,
GMacExpressionGenerator.Translate(BasicExpressionGenerator, rhsNode)
);
operands.AddOperand(lhsValAccess, rhsExpr);
}
break;
case GMacParseNodeNames.ExpressionFunctionInputsExpressions:
var nodeExpressionFunctionInputsExpressions = subNode;
var i = -1;
foreach (var parameter in macro.Parameters)
{
if (i >= nodeExpressionFunctionInputsExpressions.ChildNodes.Count)
{
break;
}
//The first parameter of any macro is the 'result' output parameter; ignore it
if (i >= 0)
{
var rhsNode = nodeExpressionFunctionInputsExpressions.ChildNodes[i];
var lhsValAccess = LanguageValueAccess.Create(parameter);
var rhsExpr =
BasicExpressionGenerator.Generate_PolyadicOperand(
lhsValAccess.ExpressionType,
GMacExpressionGenerator.Translate(BasicExpressionGenerator, rhsNode)
);
operands.AddOperand(lhsValAccess, rhsExpr);
}
i = i + 1;
}
if (nodeExpressionFunctionInputsExpressions.ChildNodes.Count > i)
{
return(CompilationLog.RaiseGeneratorError <ILanguageExpression>("Expecting a list of at most " + i + " expression as input to the macro call", node));
}
break;
default:
return(CompilationLog.RaiseGeneratorError <ILanguageExpression>("Expecting a list of expressions or list of parameter assignments as input to the macro call", node));
}
return(BasicPolyadic.Create(macro.OutputParameterType, macro, operands));
}
private ILanguageExpression translate_Expression_Function(ParseTreeNode node)
{
var expr = translate_TryBuiltinMacro(node);
if (expr != null)
{
return(expr);
}
var nodeQualifiedIdentifier = node.ChildNodes[0];
var nodeDefaultValueOpt = node.ChildNodes[1];
var nodeInputsOpt = node.ChildNodes[2];
ILanguageExpressionAtomic defaultValueSource;
var symbol = GMacValueAccessGenerator.Translate_Direct(Context, nodeQualifiedIdentifier);
var macro = symbol as GMacMacro;
if (macro != null)
{
return
(nodeDefaultValueOpt.ChildNodes.Count == 0
? translate_Expression_Function_Macro(macro, nodeInputsOpt)
: CompilationLog.RaiseGeneratorError <ILanguageExpression>("A default value cannot be used for a macro call operation", nodeDefaultValueOpt));
}
var structure = symbol as GMacStructure;
if (structure != null)
{
if (nodeDefaultValueOpt.ChildNodes.Count <= 0)
{
return(translate_Expression_Function_Structure(structure, null,
nodeInputsOpt));
}
var nodeDefaultValue = nodeDefaultValueOpt.ChildNodes[0];
defaultValueSource =
BasicExpressionGenerator.Generate_PolyadicOperand(
structure,
GMacExpressionGenerator.Translate(BasicExpressionGenerator, nodeDefaultValue.ChildNodes[0])
);
return(translate_Expression_Function_Structure(structure, defaultValueSource, nodeInputsOpt));
}
var subspace = symbol as GMacFrameSubspace;
if (subspace != null)
{
if (nodeDefaultValueOpt.ChildNodes.Count <= 0)
{
return(translate_Expression_Function_Subspace(subspace, null, nodeInputsOpt));
}
var nodeDefaultValue = nodeDefaultValueOpt.ChildNodes[0];
defaultValueSource =
BasicExpressionGenerator.Generate_PolyadicOperand(
subspace.ParentFrame.MultivectorType,
GMacExpressionGenerator.Translate(BasicExpressionGenerator, nodeDefaultValue.ChildNodes[0])
);
return(translate_Expression_Function_Subspace(subspace, defaultValueSource, nodeInputsOpt));
}
var multivector = symbol as GMacFrameMultivector;
if (multivector != null)
{
if (nodeDefaultValueOpt.ChildNodes.Count <= 0)
{
return(translate_Expression_Function_MultivectorType(multivector,
null, nodeInputsOpt));
}
var nodeDefaultValue = nodeDefaultValueOpt.ChildNodes[0];
defaultValueSource =
BasicExpressionGenerator.Generate_PolyadicOperand(
multivector,
GMacExpressionGenerator.Translate(BasicExpressionGenerator, nodeDefaultValue.ChildNodes[0])
);
return(translate_Expression_Function_MultivectorType(multivector, defaultValueSource, nodeInputsOpt));
}
var typePrimitive = symbol as TypePrimitive;
if (typePrimitive != null)
{
return
(nodeDefaultValueOpt.ChildNodes.Count == 0
? translate_Expression_Function_Cast(typePrimitive, nodeInputsOpt)
: CompilationLog.RaiseGeneratorError <ILanguageExpression>("A default value cannot be used for a type cast operation", nodeDefaultValueOpt));
}
var transform = symbol as GMacMultivectorTransform;
if (transform != null)
{
return
(nodeDefaultValueOpt.ChildNodes.Count == 0
? translate_Expression_Function_Transform(transform, nodeInputsOpt)
: CompilationLog.RaiseGeneratorError <ILanguageExpression>("A default value cannot be used for a multivector transform operation", nodeDefaultValueOpt));
}
return(CompilationLog.RaiseGeneratorError <ILanguageExpression>("Expecting a macro, structure, transform, or multivector class", node));
}
private ILanguageExpression translate_Expression_Function_MultivectorType(GMacFrameMultivector mvType, ILanguageExpressionAtomic defaultValueSource, ParseTreeNode node)
{
var operands = OperandsByIndex.Create();
if (node.ChildNodes.Count <= 0)
{
return
(ReferenceEquals(defaultValueSource, null)
? mvType.CreateConstructorExpression(operands)
: mvType.CreateConstructorExpression(defaultValueSource, operands));
}
var expressionFunctionInputsNode = node.ChildNodes[0];
var subNode = expressionFunctionInputsNode.ChildNodes[0];
switch (subNode.Term.ToString())
{
case GMacParseNodeNames.ExpressionFunctionInputsAssignments:
var expressionFunctionInputsAssignmentsNode = subNode;
foreach (var nodeExpressionFunctionInputsAssignmentsItem in expressionFunctionInputsAssignmentsNode.ChildNodes)
{
var lhsNode = nodeExpressionFunctionInputsAssignmentsItem.ChildNodes[0].ChildNodes[0];
var rhsNode = nodeExpressionFunctionInputsAssignmentsItem.ChildNodes[1];
if (lhsNode.Term.Name == GMacParseNodeNames.BasisBladeCoefficient)
{
var basisBladeId = translate_BasisBladeCoefficient(mvType, lhsNode);
var rhsExpr =
BasicExpressionGenerator.Generate_PolyadicOperand(
GMacRootAst.ScalarType,
GMacExpressionGenerator.Translate(BasicExpressionGenerator, rhsNode)
);
operands.AddOperand(basisBladeId, rhsExpr);
}
else
{
return(CompilationLog.RaiseGeneratorError <ILanguageExpression>("Expecting a list of basis blade assignments as input to the multivector construction", node));
}
}
break;
case GMacParseNodeNames.ExpressionFunctionInputsExpressions:
return
(ReferenceEquals(defaultValueSource, null)
? translate_Expression_Function_Cast(mvType, node)
: CompilationLog.RaiseGeneratorError <ILanguageExpression>("A default value cannot be used for a type cast operation", node));
default:
return(CompilationLog.RaiseGeneratorError <ILanguageExpression>("Expecting a list of basis blade assignments as input to the multivector construction", node));
}
return
(ReferenceEquals(defaultValueSource, null)
? mvType.CreateConstructorExpression(operands)
: mvType.CreateConstructorExpression(defaultValueSource, operands));
}
private ILanguageExpression translate_Expression_Function_Subspace(GMacFrameSubspace subspace, ILanguageExpressionAtomic defaultValueSource, ParseTreeNode node)
{
var operands = OperandsByIndex.Create();
if (node.ChildNodes.Count <= 0)
{
return
(ReferenceEquals(defaultValueSource, null)
? subspace.ParentFrame.MultivectorType.CreateConstructorExpression(operands)
: subspace.ParentFrame.MultivectorType.CreateConstructorExpression(defaultValueSource, operands));
}
var expressionFunctionInputsNode = node.ChildNodes[0];
var subNode = expressionFunctionInputsNode.ChildNodes[0];
switch (subNode.Term.ToString())
{
//case GMacParseNodeNames.ExpressionFunctionInputsAssignments:
// var expressionFunctionInputsAssignmentsNode = subNode;
// foreach (var nodeExpressionFunctionInputsAssignmentsItem in expressionFunctionInputsAssignmentsNode.ChildNodes)
// {
// var lhsNode = nodeExpressionFunctionInputsAssignmentsItem.ChildNodes[0].ChildNodes[0];
// var rhsNode = nodeExpressionFunctionInputsAssignmentsItem.ChildNodes[1];
// if (lhsNode.Term.Name == GMacParseNodeNames.BasisBladeCoefficient)
// {
// var basisBladeId = translate_BasisBladeCoefficient(subspace.ParentFrame.MultivectorType, lhsNode);
// var rhsExpr =
// BasicExpressionGenerator.Generate_PolyadicOperand(
// GMacRootAst.ScalarType,
// GMacExpressionGenerator.Translate(BasicExpressionGenerator, rhsNode)
// );
// operands.AddOperand(basisBladeId, rhsExpr);
// }
// else
// return CompilationLog.RaiseGeneratorError<ILanguageExpression>("Expecting a list of basis blade assignments as input to the multivector construction", node);
// }
// break;
case GMacParseNodeNames.ExpressionFunctionInputsExpressions:
var expressionFunctionInputsExpressionsNode = subNode;
var i = 0;
foreach (var basisBladeId in subspace.SubspaceSignaturePattern.TrueIndexes)
{
if (i >= expressionFunctionInputsExpressionsNode.ChildNodes.Count)
{
break;
}
var rhsNode = expressionFunctionInputsExpressionsNode.ChildNodes[i];
var rhsExpr =
BasicExpressionGenerator.Generate_PolyadicOperand(
GMacRootAst.ScalarType,
GMacExpressionGenerator.Translate(BasicExpressionGenerator, rhsNode)
);
operands.AddOperand(basisBladeId, rhsExpr);
i = i + 1;
}
if (expressionFunctionInputsExpressionsNode.ChildNodes.Count > i)
{
return(CompilationLog.RaiseGeneratorError <ILanguageExpression>("Expecting a list of at most " + i + " expression as input to the multivector subspace construction", node));
}
break;
default:
return(CompilationLog.RaiseGeneratorError <ILanguageExpression>("Expecting a list of expressions as input to the multivector subspace construction", node));
}
return
(ReferenceEquals(defaultValueSource, null)
? subspace.ParentFrame.MultivectorType.CreateConstructorExpression(operands)
: subspace.ParentFrame.MultivectorType.CreateConstructorExpression(defaultValueSource, operands));
}
private ILanguageExpression translate_Expression_Function_Structure(GMacStructure structure, ILanguageExpressionAtomic defaultValueSource, ParseTreeNode node)
{
var operands = OperandsByValueAccess.Create();
if (node.ChildNodes.Count == 0)
{
return
(defaultValueSource == null
? structure.CreateConstructorExpression(operands)
: structure.CreateConstructorExpression(defaultValueSource, operands));
}
var expressionFunctionInputsNode = node.ChildNodes[0];
var subNode = expressionFunctionInputsNode.ChildNodes[0];
switch (subNode.Term.ToString())
{
case GMacParseNodeNames.ExpressionFunctionInputsAssignments:
var expressionFunctionInputsAssignmentsNode = subNode;
foreach (var nodeExpressionFunctionInputsAssignmentsItem in expressionFunctionInputsAssignmentsNode.ChildNodes)
{
var lhsNode = nodeExpressionFunctionInputsAssignmentsItem.ChildNodes[0].ChildNodes[0];
var rhsNode = nodeExpressionFunctionInputsAssignmentsItem.ChildNodes[1];
var lhsValAccess = GMacValueAccessGenerator.Translate_LValue_StructureMember(Context, lhsNode, structure);
var rhsExpr =
BasicExpressionGenerator.Generate_PolyadicOperand(
lhsValAccess.ExpressionType,
GMacExpressionGenerator.Translate(BasicExpressionGenerator, rhsNode)
);
operands.AddOperand(lhsValAccess, rhsExpr);
}
break;
case GMacParseNodeNames.ExpressionFunctionInputsExpressions:
var expressionFunctionInputsExpressionsNode = subNode;
var i = 0;
foreach (var dataMember in structure.DataMembers)
{
if (i >= expressionFunctionInputsExpressionsNode.ChildNodes.Count)
{
break;
}
var rhsNode = expressionFunctionInputsExpressionsNode.ChildNodes[i];
var lhsValAccess = LanguageValueAccess.Create(dataMember);
var rhsExpr =
BasicExpressionGenerator.Generate_PolyadicOperand(
lhsValAccess.ExpressionType,
GMacExpressionGenerator.Translate(BasicExpressionGenerator, rhsNode)
);
operands.AddOperand(lhsValAccess, rhsExpr);
i = i + 1;
}
if (expressionFunctionInputsExpressionsNode.ChildNodes.Count > i)
{
return(CompilationLog.RaiseGeneratorError <ILanguageExpression>("Expecting a list of at most " + i + " expression as input to the structure construction", node));
}
break;
default:
return(CompilationLog.RaiseGeneratorError <ILanguageExpression>("Expecting a list of expressions or a list of member assignments as input to the structure construction", node));
}
return
(defaultValueSource == null
? structure.CreateConstructorExpression(operands)
: structure.CreateConstructorExpression(defaultValueSource, operands));
}
private ILanguageExpression translate_LanguageExpression(string expressionText)
{
var rootParseNode = GMacSourceParser.ParseExpression(expressionText, CompilationLog);
return(GMacExpressionGenerator.Translate(Context, rootParseNode));
}
