/// <summary>
/// Assign a constant value to an input parameter of the base macro
/// </summary>
/// <param name="hlValueAccess">The full or partial macro parameter</param>
/// <param name="assignedValue">The constant value to be assigned to the parameter</param>
internal void DefineParameter(LanguageValueAccess hlValueAccess, ILanguageValue assignedValue)
{
//The parameter must be an input parameter
if (hlValueAccess.RootSymbolAsParameter.DirectionOut)
{
throw new InvalidOperationException("Output parameters cannot be assigned initial values");
}
//If the value access is of primitive type just assign the value directly
var valuePrimitive = assignedValue as ILanguageValuePrimitive;
if (valuePrimitive != null)
{
DataTable.DefineConstantInputParameter(hlValueAccess, valuePrimitive);
return;
}
//If the value access is of compoiste type break it into all primitive components with corresponding
//primitive values
var assignmentsList = hlValueAccess.ExpandAndAssignAll(assignedValue);
foreach (var assignment in assignmentsList)
{
DataTable.DefineConstantInputParameter(assignment.Item1, assignment.Item2);
}
}
/// <summary>
/// Apply the given value access to the source value to read a partial value
/// </summary>
/// <param name="sourceValue"></param>
/// <param name="valueAccess"></param>
/// <returns></returns>
public virtual ILanguageValue ReadPartialValue(ILanguageValue sourceValue, LanguageValueAccess valueAccess)
{
return
(valueAccess
.PartialAccessSteps
.Aggregate(sourceValue, ReadPartialValue));
}
/// <summary>
/// Construct the composite value of a structure value access from the table items.
/// If no low-level items are found this method returns a default structure sparse value
/// </summary>
/// <param name="valueAccess"></param>
/// <returns></returns>
public ValueStructureSparse ReadRhsStructureValue(LanguageValueAccess valueAccess)
{
var structure = (GMacStructure)valueAccess.ExpressionType;
var structValue = ValueStructureSparse.Create(structure);
foreach (var dataMember in structure.DataMembers)
{
ILanguageValue dataMemberValue = null;
var childValueAccess = valueAccess.Duplicate().Append(dataMember.ObjectName, dataMember.SymbolType);
if (dataMember.SymbolType is TypePrimitive)
{
dataMemberValue = ReadRHSPrimitiveValue_ExistingOnly(childValueAccess);
}
else if (dataMember.SymbolType is GMacFrameMultivector)
{
dataMemberValue = ReadRHSMultivectorValue_ExistingOnly(childValueAccess);
}
else if (dataMember.SymbolType is GMacStructure)
{
dataMemberValue = ReadRHSStructureValue_ExistingOnly(childValueAccess);
}
if (ReferenceEquals(dataMemberValue, null) == false)
{
structValue[dataMember.ObjectName] = dataMemberValue;
}
}
return(structValue);
}
internal static SimpleTreeNode <Expr> ToSimpleExprTree(this ILanguageValue value)
{
var scalarValue = value as ValuePrimitive <MathematicaScalar>;
if (ReferenceEquals(scalarValue, null) == false)
{
return(ToSimpleExprTree(scalarValue));
}
var mvValue = value as GMacValueMultivector;
if (ReferenceEquals(mvValue, null) == false)
{
return(ToSimpleExprTree(mvValue));
}
var structValue = value as ValueStructureSparse;
if (ReferenceEquals(structValue, null) == false)
{
return(ToSimpleExprTree(structValue));
}
return(null);
}
protected override ILanguageValue ReadPartialValue(ILanguageValue sourceValue, ValueAccessStep valueAccessStep)
{
if (sourceValue.ExpressionType is GMacStructure)
{
var structureValue = (ValueStructureSparse)sourceValue;
return(structureValue[((ValueAccessStepByKey <string>)valueAccessStep).AccessKey]);
}
if (!(sourceValue.ExpressionType is GMacFrameMultivector))
{
throw new InvalidOperationException("Invalid source value type");
}
var mvValue = (GMacValueMultivector)sourceValue;
var stepByKey = valueAccessStep as ValueAccessStepByKey <int>;
if (stepByKey != null)
{
return(mvValue[stepByKey.AccessKey]);
}
var stepByKeyList = valueAccessStep as ValueAccessStepByKeyList <int>;
if (stepByKeyList != null)
{
return(mvValue[stepByKeyList.AccessKeyList]);
}
throw new InvalidOperationException("Invalid access step for a multivector");
}
internal static AstValue ToAstValue(this ILanguageValue expr)
{
var s2 = expr as ValuePrimitive <MathematicaScalar>;
if (ReferenceEquals(s2, null) == false)
{
return(new AstValueScalar(s2));
}
var s3 = expr as GMacValueMultivector;
if (ReferenceEquals(s3, null) == false)
{
return(new AstValueMultivector(s3));
}
var s4 = expr as ValueStructureSparse;
if (ReferenceEquals(s4, null) == false)
{
return(new AstValueStructure(s4));
}
return(null);
}
/// <summary>
/// Update the low-level variables related to the given high-level variable using the given RHS value
/// </summary>
/// <param name="lhsValueAccess">The high-level LHS variable</param>
/// <param name="rhsValue">The high-level RHS value</param>
private void WriteToLhsVariables(LanguageValueAccess lhsValueAccess, ILanguageValue rhsValue)
{
//The high-level variable is of primitive type
if (lhsValueAccess.ExpressionType is TypePrimitive)
{
DataTable.WriteLhsPrimitiveValue(lhsValueAccess, (ValuePrimitive <MathematicaScalar>)rhsValue);
}
//The high-level variable is of composite multivector type
else if (lhsValueAccess.ExpressionType is GMacFrameMultivector)
{
DataTable.WriteLhsMultivectorValue(lhsValueAccess, (GMacValueMultivector)rhsValue);
}
//The high-level variable is of composite structure type
else if (lhsValueAccess.ExpressionType is GMacStructure)
{
DataTable.WriteLhsStructureValue(lhsValueAccess, (ValueStructureSparse)rhsValue);
}
//This should never happen
else
{
throw new InvalidOperationException();
}
}
protected override void UpdateSymbolValue(LanguageValueAccess valueAccess, ILanguageValue value)
{
if (GMacCompilerOptions.SimplifyLowLevelRhsValues)
{
value.Simplify();
}
base.UpdateSymbolValue(valueAccess, value);
}
/// <summary>
/// Process a high-level RHS value into a form suitable for low-leve code generation
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public override ILanguageValue Visit(ILanguageValue value)
{
//If this is a primitive value convert it into a Mathematica Scalar primitive value
var valuePrimitive = value as ILanguageValuePrimitive;
return
(valuePrimitive == null
? value
: valuePrimitive.ToScalarValue());
}
private TreeNode Visit(string lhsName, ILanguageValue rhsValue)
{
var node = new TreeNode("<ASSIGN> " + lhsName)
{
Tag = lhsName
};
node.Nodes.Add(rhsValue.AcceptVisitor(this));
return(node);
}
/// <summary>
/// Change a partial value inside the source value using the given value access
/// </summary>
/// <param name="sourceValue"></param>
/// <param name="valueAccess"></param>
/// <param name="value"></param>
/// <returns></returns>
public virtual ILanguageValue WritePartialValue(ILanguageValue sourceValue, LanguageValueAccess valueAccess, ILanguageValue value)
{
if (valueAccess.IsFullAccess)
{
throw new InvalidOperationException();
}
sourceValue =
valueAccess
.PartialAccessStepsExceptLast
.Aggregate(sourceValue, ReadPartialValue);
return(WritePartialValue(sourceValue, valueAccess.LastAccessStep, value));
}
/// <summary>
/// Dynamic evaluation extension method
/// </summary>
/// <param name="value1">The first operand</param>
/// <param name="binaryOp">The binaty operation</param>
/// <param name="value2">The second operand</param>
/// <returns>The value of evaluation the operations on the two operands</returns>
public static ILanguageValue AcceptOperation(this ILanguageValue value1, LanguageBasicBinaryDynamicEvaluator binaryOp, ILanguageValue value2)
{
try
{
//Polymorphic Visit call
return(((dynamic)binaryOp).Evaluate((dynamic)value1, (dynamic)value2));
}
catch (RuntimeBinderException excException)
{
//Do not use the fallback method
if (binaryOp.UseExceptions)
{
throw;
}
//Use the fallback method
return(binaryOp.Fallback(value1, value2, excException));
}
}
protected override ILanguageValue WritePartialValue(ILanguageValue sourceValue, ValueAccessStep valueAccessStep, ILanguageValue value)
{
if (sourceValue.ExpressionType is GMacStructure)
{
var structureValue = (ValueStructureSparse)sourceValue;
structureValue[((ValueAccessStepByKey <string>)valueAccessStep).AccessKey] = value;
return(value);
}
if (!(sourceValue.ExpressionType is GMacFrameMultivector))
{
throw new InvalidOperationException("Invalid source value type");
}
var mvValue = (GMacValueMultivector)sourceValue;
var stepByKey = valueAccessStep as ValueAccessStepByKey <int>;
if (stepByKey != null)
{
mvValue[stepByKey.AccessKey] = (ValuePrimitive <MathematicaScalar>)value;
}
else
{
var stepByKeyList = valueAccessStep as ValueAccessStepByKeyList <int>;
if (stepByKeyList == null)
{
throw new InvalidOperationException("Invalid access step for a multivector");
}
mvValue[stepByKeyList.AccessKeyList] = (GMacValueMultivector)value;
}
return(value);
}
/// <summary>
/// Go through every leaf MathematicaScalar in this value and try to simplify its internal
/// expression if possible
/// </summary>
/// <param name="value"></param>
public static void Simplify(this ILanguageValue value)
{
if (ReferenceEquals(value, null))
{
return;
}
var scalarValue = value as ValuePrimitive <MathematicaScalar>;
if (ReferenceEquals(scalarValue, null) == false)
{
scalarValue.Value.Simplify();
return;
}
var mvValue = value as GMacValueMultivector;
if (ReferenceEquals(mvValue, null) == false)
{
mvValue.MultivectorCoefficients.Simplify();
return;
}
var stValue = value as ValueStructureSparse;
if (ReferenceEquals(stValue, null))
{
return;
}
var removeMembersList = new List <string>(stValue.Count);
foreach (var memberValue in stValue)
{
Simplify(memberValue.Value);
var memberScalarValue = memberValue.Value as ValuePrimitive <MathematicaScalar>;
if (ReferenceEquals(memberScalarValue, null) == false)
{
if (memberScalarValue.Value.IsZero())
{
removeMembersList.Add(memberValue.Key);
}
continue;
}
var memberMvValue = memberValue.Value as GMacValueMultivector;
if (ReferenceEquals(memberMvValue, null) == false)
{
if (memberMvValue.MultivectorCoefficients.Count == 0)
{
removeMembersList.Add(memberValue.Key);
}
continue;
}
var memberStValue = memberValue.Value as ValueStructureSparse;
if (ReferenceEquals(memberStValue, null))
{
continue;
}
if (memberStValue.Count == 0)
{
removeMembersList.Add(memberValue.Key);
}
}
foreach (var memberName in removeMembersList)
{
stValue.Remove(memberName);
}
}
internal GMacConstant(string constantName, LanguageScope parentScope, ILanguageValue rhsValue)
: base(constantName, parentScope, RoleNames.Constant, rhsValue.ExpressionType)
{
AssociatedValue = rhsValue;
}
public bool TryGetValue(TK key, out ILanguageValue value)
{
return(InternalDictionary.TryGetValue(key, out value));
}
public void Add(TK key, ILanguageValue value)
{
InternalDictionary.Add(key, value);
}
/// <summary> /// The fall back method that is called if no matching visit method is found and UseExceptions flag is false /// </summary> /// <param name="value1"></param> /// <param name="value2"></param> /// <param name="excException"></param> /// <returns></returns> public abstract ILanguageValue Fallback(ILanguageValue value1, ILanguageValue value2, RuntimeBinderException excException);
/// <summary>
/// Create a child constant
/// </summary>
/// <param name="constantName"></param>
/// <param name="constantValue"></param>
/// <returns></returns>
internal GMacConstant DefineFrameConstant(string constantName, ILanguageValue constantValue)
{
return(new GMacConstant(constantName, ChildSymbolScope, constantValue));
}
ExpandAndAssignAll(this LanguageValueAccess valueAccess, ILanguageValue value)
{
valueAccess = ReduceMultivectorAccess(valueAccess);
var accessStack = new Stack <LanguageValueAccess>();
accessStack.Push(valueAccess);
var valuesStack = new Stack <ILanguageValue>();
valuesStack.Push(value);
while (valuesStack.Count > 0)
{
var rootValueAccess = accessStack.Pop();
var rootValue = valuesStack.Pop();
var valuePrimitive = rootValue as ILanguageValuePrimitive;
if (valuePrimitive != null)
{
yield return
(new Tuple <LanguageValueAccess, ILanguageValuePrimitive>(
rootValueAccess,
valuePrimitive
));
continue;
}
var valueMultivector = rootValue as GMacValueMultivector;
if (valueMultivector != null)
{
var mvValue = valueMultivector;
var scalarType = mvValue.CoefficientType;
var s = rootValueAccess.LastAccessStep as ValueAccessStepByKeyList <int>;
var partialMvFlag = !ReferenceEquals(s, null);
var idsList =
partialMvFlag
? s.AccessKeyList
: null;
foreach (var id in mvValue.SymbolicMultivector.NonZeroBasisBladeIds)
{
if (!ReferenceEquals(idsList, null) && !idsList.Contains(id))
{
continue;
}
var childValueAccess =
partialMvFlag
? rootValueAccess.DuplicateExceptLast().Append(id, scalarType)
: rootValueAccess.Duplicate().Append(id, scalarType);
yield return
(new Tuple <LanguageValueAccess, ILanguageValuePrimitive>(
childValueAccess,
mvValue[id]
));
}
continue;
}
var valueStructureSparse = rootValue as ValueStructureSparse;
if (valueStructureSparse == null)
{
continue;
}
var structValue = valueStructureSparse;
foreach (var pair in structValue)
{
var dataMemberName = pair.Key;
var dataMember = structValue.ValueStructureType.GetDataMember(dataMemberName);
var childValueAccess =
rootValueAccess
.Duplicate()
.Append(dataMember.ObjectName, dataMember.SymbolType);
var languageValuePrimitive = pair.Value as ILanguageValuePrimitive;
if (languageValuePrimitive != null)
{
yield return
(new Tuple <LanguageValueAccess, ILanguageValuePrimitive>(
childValueAccess,
languageValuePrimitive
));
}
else
{
accessStack.Push(childValueAccess);
valuesStack.Push(pair.Value);
}
}
}
}
public static ValueReference Create(TypeReference valueType, ILanguageValue value)
{
return(new ValueReference(valueType, value));
}
protected ValueReference(TypeReference valueType, ILanguageValue value)
{
ValueReferenceType = valueType;
Value = value;
}
public static ValuePointer Create(TypePointer valueType, ILanguageValue value)
{
return(new ValuePointer(valueType, value));
}
ExpandAndAssignAll(this SymbolLValue symbol, ILanguageValue value)
{
return(ExpandAndAssignAll(LanguageValueAccess.Create(symbol), value));
}
/// <summary> /// Read a partial value from the source value using the given value access step /// </summary> /// <param name="sourceValue"></param> /// <param name="valueAccessStep"></param> /// <returns></returns> protected abstract ILanguageValue ReadPartialValue(ILanguageValue sourceValue, ValueAccessStep valueAccessStep);
internal AstValueStructureTerm(GMacStructure structure, string dataMemberName, ILanguageValue dataMemberValue)
{
AssociatedStructure = structure;
DataMemberName = dataMemberName;
TermDataMemberValue = dataMemberValue;
}
/// <summary> /// Change a partial value inside the source value using the given value access step /// </summary> /// <param name="sourceValue"></param> /// <param name="valueAccessStep"></param> /// <param name="value"></param> /// <returns></returns> protected abstract ILanguageValue WritePartialValue(ILanguageValue sourceValue, ValueAccessStep valueAccessStep, ILanguageValue value);
public override ILanguageValue Fallback(ILanguageValue value1, RuntimeBinderException excException)
{
throw new NotImplementedException();
}
protected ValuePointer(TypePointer valueType, ILanguageValue value)
{
ValuePointerType = valueType;
Value = value;
}
public void SetComponentValue(ValueAccessStep accessStep, ILanguageValue value)
{
throw new NotImplementedException();
}
