internal BasicPolyadic CreateConstructorExpression(OperandsByIndex operands)
{
return
(BasicPolyadic.Create(
this,
GMacFrameMultivectorConstructor.Create(this),
operands
));
}
public IEnumerable <SymbolLValue> GetLValues(OperandsByIndex operands)
{
var lvalues = Enumerable.Empty <SymbolLValue>();
return
(operands
.OperandsDictionary
.Where(pair => pair.Value is LanguageValueAccess)
.Aggregate(
lvalues,
(current, pair) => current.Concat(((LanguageValueAccess)pair.Value).AccessLValues)
));
}
public OperandsByIndex ReplaceLValueByExpression(OperandsByIndex oldOperands, SymbolLValue oldLvalue, ILanguageExpressionAtomic newExpr)
{
var newOperands = new Dictionary <int, ILanguageExpressionAtomic>();
foreach (var pair in oldOperands.OperandsDictionary)
{
var newOpExpr = ReplaceLValueByExpression(pair.Value, oldLvalue, newExpr);
newOperands.Add(pair.Key, newOpExpr);
}
oldOperands.OperandsDictionary.Clear();
foreach (var pair in newOperands)
{
oldOperands.AddOperand(pair.Key, pair.Value);
}
return(oldOperands);
}
private ILanguageExpression CompileMultivectorConstructor(GMacFrameMultivectorConstructor mvTypeCons, OperandsByIndex operands)
{
ILanguageExpressionAtomic compiledDefaultValueSource = null;
if (mvTypeCons.HasDefaultValueSource)
{
compiledDefaultValueSource =
(ILanguageExpressionAtomic)CompileExpression(mvTypeCons.DefaultValueSource);
}
var compiledOperands = OperandsByIndex.Create();
foreach (var pair in operands.OperandsDictionary)
{
var compiledRhsExpr =
(ILanguageExpressionAtomic)CompileExpression(pair.Value);
compiledOperands.AddOperand(pair.Key, compiledRhsExpr);
}
return(mvTypeCons.MultivectorType.CreateConstructorExpression(compiledDefaultValueSource, compiledOperands));
}
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));
}
/// <summary>
/// Evaluate a multivector construction operation
/// </summary>
/// <param name="mvTypeCons"></param>
/// <param name="operands"></param>
/// <returns></returns>
private GMacValueMultivector EvaluateBasicPolyadicMultivectorConstructor(GMacFrameMultivectorConstructor mvTypeCons, OperandsByIndex operands)
{
GMacValueMultivector value;
if (mvTypeCons.HasDefaultValueSource)
{
value =
(GMacValueMultivector)mvTypeCons
.DefaultValueSource
.AcceptVisitor(this)
.DuplicateValue(true);
}
else
{
value =
(GMacValueMultivector)GMacRootAst
.CreateDefaultValue(mvTypeCons.MultivectorType);
}
foreach (var pair in operands.OperandsDictionary)
{
var rhsValue = (ValuePrimitive <MathematicaScalar>)pair.Value.AcceptVisitor(this);
//TODO: Is it necessary to make a copy of the RHS value in all cases?
value[pair.Key] = (ValuePrimitive <MathematicaScalar>)rhsValue.DuplicateValue(true);
}
return(value);
}
/// <summary>
/// Create a composite type initialized constructor RHS expression based on the given command with
/// partial LHS value access and a new temporary local variable as explained in Optimize_ReplaceAllLHSPartialAccess
/// </summary>
/// <param name="commandInfo"></param>
/// <param name="newLvalue"></param>
/// <returns></returns>
private BasicPolyadic CreateConstructorExpression(HlCommandInfo commandInfo, SymbolLValue newLvalue)
{
var oldValueAccess = commandInfo.AssociatedCommand.LhsValueAccess;
var oldLvalue = oldValueAccess.RootSymbolAsLValue;
var firstDefStId = _lValuesTable.GetFirstDefiningCommandInfo(oldLvalue).CommandInfoId;
var useDefaultSource =
firstDefStId < 0 || firstDefStId != commandInfo.CommandInfoId;
var typeStructure = oldValueAccess.RootSymbolAsLValue.SymbolType as GMacStructure;
if (typeStructure != null)
{
var structure = typeStructure;
var operands = OperandsByValueAccess.Create();
var dataMemberName = ((ValueAccessStepByKey <string>)oldValueAccess.LastAccessStep).AccessKey;
var dataMember = structure.GetDataMember(dataMemberName);
var operandLhsValueAccess = LanguageValueAccess.Create(dataMember);
var operandRhsExpr = LanguageValueAccess.Create(newLvalue);
operandLhsValueAccess.Append(oldValueAccess.AccessSteps.Skip(2));
operands.AddOperand(operandLhsValueAccess, operandRhsExpr);
if (useDefaultSource)
{
return(structure.CreateConstructorExpression(
LanguageValueAccess.Create(oldLvalue),
operands
));
}
return(structure.CreateConstructorExpression(operands));
}
if (!(oldValueAccess.RootSymbolAsLValue.SymbolType is GMacFrameMultivector))
{
throw new InvalidOperationException("Unknown composite type to be constructed");
}
var mvType = (GMacFrameMultivector)oldValueAccess.RootSymbolAsLValue.SymbolType;
var operandsByIndex = OperandsByIndex.Create();
var stepByKey = oldValueAccess.LastAccessStep as ValueAccessStepByKey <int>;
if (stepByKey != null)
{
var id = stepByKey.AccessKey;
operandsByIndex.AddOperand(id, LanguageValueAccess.Create(newLvalue));
}
else
{
var stepByKeyList = oldValueAccess.LastAccessStep as ValueAccessStepByKeyList <int>;
if (stepByKeyList == null)
{
throw new InvalidOperationException("Invalid access step for a multivector");
}
var idsList = stepByKeyList.AccessKeyList;
foreach (var id in idsList)
{
operandsByIndex.AddOperand(id,
LanguageValueAccess.Create(newLvalue).Append(id, ((GMacAst)BaseMacro.RootAst).ScalarType));
}
}
if (useDefaultSource)
{
return(mvType.CreateConstructorExpression(
LanguageValueAccess.Create(oldLvalue),
operandsByIndex
));
}
return(mvType.CreateConstructorExpression(operandsByIndex));
}
internal void Generate_BasicPolyadic_FrameMultivectorConstruction(GMacFrameMultivectorConstructor mvTypeCons, OperandsByIndex operands)
{
//this.Log.Append(mv_type_cons.OperatorName);
Log.Append("{");
if (mvTypeCons.HasDefaultValueSource)
{
mvTypeCons.DefaultValueSource.AcceptVisitor(this);
}
Log.Append("}");
Log.Append("(");
var flag = false;
foreach (var pair in operands.OperandsDictionary)
{
if (flag)
{
Log.Append(", ");
}
else
{
flag = true;
}
Log.Append("#");
Log.Append(mvTypeCons.MultivectorType.ParentFrame.BasisBladeName(pair.Key));
Log.Append("#");
Log.Append(" = ");
pair.Value.AcceptVisitor(this);
}
Log.Append(")");
}
internal BasicPolyadic CreateConstructorExpression(ILanguageExpressionAtomic defaultValueSource, OperandsByIndex operands)
{
return
(BasicPolyadic.Create(
this,
GMacFrameMultivectorConstructor.Create(this, defaultValueSource),
operands
));
}