private void VerifyOperation_Times()
{
if (Operand1Type.IsNumber() && Operand2Type.IsNumber())
{
ForceAtomicScalarOperands(ScalarType);
}
else if (Operand1Type.IsFrameMultivector() && Operand2Type.IsNumber())
{
_resultType = Operand1Type;
_atomicOperand1 = Context.ActiveParentCommandBlock.ExpressionToMultivectorAtomicExpression(OperandsMultivectorType, _operand1);
_atomicOperand2 = Context.ActiveParentCommandBlock.ExpressionToScalarAtomicExpression(_operand2);
}
else if (Operand1Type.IsNumber() && Operand2Type.IsFrameMultivector())
{
_resultType = Operand2Type;
_atomicOperand1 = Context.ActiveParentCommandBlock.ExpressionToScalarAtomicExpression(_operand1);
_atomicOperand2 = Context.ActiveParentCommandBlock.ExpressionToMultivectorAtomicExpression(OperandsMultivectorType, _operand2);
}
else
{
Context.CreateTypeMismatch("cannot apply Times to expressions of type " + Operand1TypeSignature + " and " + Operand2TypeSignature);
}
}
private void ForceAtomicMultivectorOperands(ILanguageType resultType)
{
_resultType = resultType;
_atomicOperand1 = Context.ActiveParentCommandBlock.ExpressionToMultivectorAtomicExpression(OperandsMultivectorType, _operand1);
_atomicOperand2 = ReferenceEquals(_operand2, null) ? null : Context.ActiveParentCommandBlock.ExpressionToMultivectorAtomicExpression(OperandsMultivectorType, _operand2);
}
internal BasicPolyadic CreateConstructorExpression(ILanguageExpressionAtomic defaultValueSource)
{
return
(BasicPolyadic.Create(
this,
GMacStructureConstructor.Create(this, defaultValueSource)
));
}
internal static GMacStructureConstructor Create(GMacStructure structure, ILanguageExpressionAtomic defaultValueSource)
{
return
(new GMacStructureConstructor(structure)
{
DefaultValueSource = defaultValueSource
});
}
internal void SetDefaultValueSource(ILanguageExpressionAtomic defaultValueSource)
{
if (!defaultValueSource.ExpressionType.IsSameType(MultivectorType))
{
throw new InvalidOperationException("Default value source must be of type " + MultivectorType.TypeSignature);
}
DefaultValueSource = defaultValueSource;
}
internal BasicPolyadic CreateConstructorExpression(ILanguageExpressionAtomic defaultValueSource, OperandsByValueAccess operands)
{
return
(BasicPolyadic.Create(
this,
GMacStructureConstructor.Create(this, defaultValueSource),
operands
));
}
internal BasicPolyadic CreateConstructorExpression(ILanguageExpressionAtomic defaultValueSource, OperandsByIndex operands)
{
return
(BasicPolyadic.Create(
this,
GMacFrameMultivectorConstructor.Create(this, defaultValueSource),
operands
));
}
public ILanguageExpressionAtomic ReplaceLValueByExpression(ILanguageExpressionAtomic oldExpr, SymbolLValue oldLvalue, ILanguageExpressionAtomic newExpr)
{
var expr = oldExpr as LanguageValueAccess;
return
(expr == null ?
oldExpr :
ReplaceLValueByExpression(expr, oldLvalue, newExpr));
}
public void ChangeOperand2(ILanguageExpressionAtomic operand)
{
if (operand.ExpressionType.IsSameType(Operand2.ExpressionType))
{
Operand2 = operand;
}
else
{
throw new InvalidOperationException();
}
}
public void ChangeOperand(string opName, ILanguageExpressionAtomic opExpr)
{
if (OperandsDictionary[opName].ExpressionType.IsSameType(opExpr.ExpressionType))
{
OperandsDictionary[opName] = opExpr;
}
else
{
throw new InvalidOperationException();
}
}
public void ChangeRhsExpression(ILanguageExpressionAtomic rhsExpr)
{
if (rhsExpr.ExpressionType.IsSameType(RhsExpression.ExpressionType))
{
RhsExpression = rhsExpr;
}
else
{
throw new InvalidOperationException();
}
}
public void ChangeOperand(int opIndex, ILanguageExpressionAtomic opExpr)
{
if (Operands[opIndex].ExpressionType.IsSameType(opExpr.ExpressionType))
{
Operands[opIndex] = opExpr;
}
else
{
throw new InvalidOperationException();
}
}
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 CompileStructureConstructor(GMacStructureConstructor structureCons, OperandsByValueAccess operands)
{
ILanguageExpressionAtomic compiledDefaultValueSource = null;
if (structureCons.HasDefaultValueSource)
{
compiledDefaultValueSource =
(ILanguageExpressionAtomic)CompileExpression(structureCons.DefaultValueSource);
}
var compiledOperands = OperandsByValueAccess.Create();
foreach (var command in operands.AssignmentsList)
{
var compiledLhsValue = CompileLhsValueAccess(command.LhsValueAccess);
var compiledRhsExpr =
(ILanguageExpressionAtomic)CompileExpression(command.RhsExpression);
compiledOperands.AddOperand(compiledLhsValue, compiledRhsExpr);
}
return(structureCons.Structure.CreateConstructorExpression(compiledDefaultValueSource, compiledOperands));
}
public OperandsByValueAccessAssignment(LanguageValueAccess lhsValue, ILanguageExpressionAtomic rhsExpr)
{
LhsValueAccess = lhsValue;
RhsExpression = rhsExpr;
}
internal GMacStructureConstructor CreateConstructorOperator(ILanguageExpressionAtomic defaultValueSource)
{
return(GMacStructureConstructor.Create(this, defaultValueSource));
}
internal static GMacFrameMultivectorConstructor Create(GMacFrameMultivector mvType, ILanguageExpressionAtomic defaultValueSource)
{
return(new GMacFrameMultivectorConstructor(mvType)
{
DefaultValueSource = defaultValueSource
});
}
public OperandsByName ReplaceLValueByExpression(OperandsByName oldOperands, SymbolLValue oldLvalue, ILanguageExpressionAtomic newExpr)
{
var newOperands = new Dictionary <string, 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);
}
/// <summary> /// Replace the occurances of the given l-value inside the given language operator with the given atomic expression /// </summary> /// <param name="oldLangOperator"></param> /// <param name="oldLvalue"></param> /// <param name="newExpr"></param> /// <returns></returns> public abstract ILanguageOperator ReplaceLValueByExpression(ILanguageOperator oldLangOperator, SymbolLValue oldLvalue, ILanguageExpressionAtomic newExpr);
internal BasicUnary CreateTransformExpression(ILanguageExpressionAtomic operand)
{
return(BasicUnary.Create(TargetFrame.MultivectorType, this, operand));
}
public OperandsByValueAccess ReplaceLValueByExpression(OperandsByValueAccess oldOperands, SymbolLValue oldLvalue, ILanguageExpressionAtomic newExpr)
{
foreach (var assignment in oldOperands.AssignmentsList)
{
var newOpExpr = ReplaceLValueByExpression(assignment.RhsExpression, oldLvalue, newExpr);
assignment.ChangeRhsExpression(newOpExpr);
}
return(oldOperands);
}
public OperandsList ReplaceLValueByExpression(OperandsList oldOperands, SymbolLValue oldLvalue, ILanguageExpressionAtomic newExpr)
{
for (var i = 0; i < oldOperands.Operands.Count; i++)
{
var newOpExpr = ReplaceLValueByExpression(oldOperands.Operands[i], oldLvalue, newExpr);
oldOperands.ChangeOperand(i, newOpExpr);
}
return(oldOperands);
}
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>
/// Add a new operand to this list
/// </summary>
/// <param name="lhsValAccess">The value access process for this operand</param>
/// <param name="rhsExpr">The RHS expression of the operand</param>
public void AddOperand(LanguageValueAccess lhsValAccess, ILanguageExpressionAtomic rhsExpr)
{
AssignmentsList.Add(new OperandsByValueAccessAssignment(lhsValAccess, rhsExpr));
}
public BasicUnary ReplaceLValueByExpression(BasicUnary oldExpr, SymbolLValue oldLvalue, ILanguageExpressionAtomic newExpr)
{
ReplaceLValueByExpression(oldExpr.Operator, oldLvalue, newExpr);
oldExpr.ChangeOperand(ReplaceLValueByExpression(oldExpr.Operand, oldLvalue, newExpr));
return(oldExpr);
}
public BasicPolyadic ReplaceLValueByExpression(BasicPolyadic oldExpr, SymbolLValue oldLvalue, ILanguageExpressionAtomic newExpr)
{
ReplaceLValueByExpression(oldExpr.Operator, oldLvalue, newExpr);
var t1 = oldExpr.Operands as OperandsByIndex;
if (t1 != null)
{
ReplaceLValueByExpression(t1, oldLvalue, newExpr);
return(oldExpr);
}
var t2 = oldExpr.Operands as OperandsByName;
if (t2 != null)
{
ReplaceLValueByExpression(t2, oldLvalue, newExpr);
return(oldExpr);
}
var t3 = oldExpr.Operands as OperandsList;
if (t3 != null)
{
ReplaceLValueByExpression(t3, oldLvalue, newExpr);
return(oldExpr);
}
var t4 = oldExpr.Operands as OperandsByValueAccess;
if (t4 == null)
{
return(oldExpr);
}
ReplaceLValueByExpression(t4, oldLvalue, newExpr);
return(oldExpr);
}
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));
}
public ILanguageExpressionAtomic ReplaceLValueByExpression(LanguageValueAccess oldValueAccess, SymbolLValue oldLvalue, ILanguageExpressionAtomic newExpr)
{
//If the old value acceess does not depend on the old_lvalue just return the old value access as is
if (oldValueAccess.HasAccessStepWithSymbol(oldLvalue) == false)
{
return(oldValueAccess);
}
//If the old value access is a full access just return the new atomic expression
if (oldValueAccess.IsFullAccess)
{
return(newExpr);
}
//If the new expression is a language value access
var valAccess = newExpr as LanguageValueAccess;
if (valAccess != null)
{
oldValueAccess.ReplaceRootSymbol(valAccess);
foreach (var component in oldValueAccess.PartialAccessStepsByLValue(oldLvalue))
{
if (valAccess.IsFullAccess)
{
component.ReplaceComponentSymbol(valAccess.RootSymbolAsLValue);
}
else
{
throw new InvalidOperationException("Can't replace a symbol with a non-symbol in this access step");
}
}
return(oldValueAccess);
}
if (!(newExpr is ILanguageValue))
{
return(oldValueAccess);
}
if (oldValueAccess.IsVariableAccess)
{
throw new InvalidOperationException("Can't replace a symbol with a non-symbol in this access process");
}
return(ReadPartialValue((ILanguageValue)newExpr, oldValueAccess));
}
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));
}
public virtual ILanguageExpression ReplaceLValueByExpression(ILanguageExpression oldExpr, SymbolLValue oldLvalue, ILanguageExpressionAtomic newExpr)
{
var t1 = oldExpr as LanguageValueAccess;
if (t1 != null)
{
return(ReplaceLValueByExpression(t1, oldLvalue, newExpr));
}
var t2 = oldExpr as BasicUnary;
if (t2 != null)
{
return(ReplaceLValueByExpression(t2, oldLvalue, newExpr));
}
var t3 = oldExpr as BasicBinary;
if (t3 != null)
{
return(ReplaceLValueByExpression(t3, oldLvalue, newExpr));
}
var t4 = oldExpr as BasicPolyadic;
return
(t4 == null
? oldExpr
: ReplaceLValueByExpression(t4, oldLvalue, newExpr));
}
