public override AddressingMode GetAddressingMode(AstScope scope)
{
var lhsMode = LHS.GetAddressingMode(scope);
var rhsMode = RHS.GetAddressingMode(scope);
if (lhsMode == AddressingMode.Immediate && rhsMode == AddressingMode.Immediate)
{
return(AddressingMode.Immediate);
}
if (lhsMode == AddressingMode.Immediate && rhsMode == AddressingMode.Register)
{
return(AddressingMode.RegisterPlusImmediate);
}
if (lhsMode == AddressingMode.Register && rhsMode == AddressingMode.Immediate)
{
return(AddressingMode.RegisterPlusImmediate);
}
if (lhsMode == AddressingMode.Immediate && rhsMode == AddressingMode.RegisterPlusImmediate)
{
return(AddressingMode.RegisterPlusImmediate);
}
if (lhsMode == AddressingMode.RegisterPlusImmediate && rhsMode == AddressingMode.Immediate)
{
return(AddressingMode.RegisterPlusImmediate);
}
return(AddressingMode.Invalid);
}
public override void EmitOp(DMObject dmObject, DMProc proc, DMReference reference)
{
proc.PushReferenceValue(reference);
RHS.EmitPushValue(dmObject, proc);
proc.BitShiftRight();
proc.Assign(reference);
}
public override Expression Clone()
{
return(new BinaryOperator(LHS.Clone(), RHS.Clone(), OpcodeStr)
{
DebugText = this.DebugText,
Declaration = this.Declaration,
String = this.String
});
}
public override void EmitPushValue(DMObject dmObject, DMProc proc)
{
string endLabel = proc.NewLabelName();
LHS.EmitPushValue(dmObject, proc);
proc.BooleanAnd(endLabel);
RHS.EmitPushValue(dmObject, proc);
proc.AddLabel(endLabel);
}
public void ToStringTest()
{
var rhs = new RHS('a', new List <string>()
{
"(q0bq1)", "(q2aq1)", "(q0bq0)"
});
Assert.AreEqual(rhs.ToString(), "a(q0bq1)(q2aq1)(q0bq0)");
}
public override string ToString()
{
var orderedRHS = RHS
.Select(e => new { Priority = e.IsEpsilon ? 1 : 0, Expression = e })
.OrderBy(e => e.Priority)
.ThenBy(e => e.Expression.Count)
.Select(e => e.Expression);
return($"{Value} {Grammer.RuleSeperator} {string.Join($" {Grammer.ExpressionSeperator} ", orderedRHS)}");
}
private void rhs(DS ds, Metric value)
{
string key = ds.ToString();
if (RHS.ContainsKey(key))
{
RHS.Remove(key);
}
RHS.Add(key, value);
}
public override string ToString()
{
StringBuilder sbFormat = new StringBuilder();
sbFormat.Append(LHS.ToString());
sbFormat.Append(" ");
sbFormat.Append(ProtoCore.VHDL.Utils.GetBinaryOperatorString(Optr));
sbFormat.Append(" ");
sbFormat.Append(RHS.ToString());
return(sbFormat.ToString());
}
public override bool Equals(object obj)
{
BranchingLeaf <t1, t2, t3> tempLeaf = obj as BranchingLeaf <t1, t2, t3>;
if (tempLeaf == null || !obj.GetType().Equals(this.GetType()))
{
return(false);
}
return(LHS.Equals(tempLeaf.LHS) && RHS.Equals(tempLeaf.RHS));
}
private Metric rhs(DS ds)
{
Metric r;
if (RHS.TryGetValue(ds.ToString(), out r))
{
return(r);
}
else
{
return(Metric.PositiveInfinity);
}
}
public override string ToString()
{
bool showBrackets = true;
string lhs = string.Empty;
if (LHS is Integer)
{
showBrackets = false;
}
if ((LHS is AddOperation || LHS is MinusOperation) && (this is AddOperation || this is MinusOperation) ||
(LHS is MultiplyOperation && this is MultiplyOperation))
{
showBrackets = false;
}
if (showBrackets)
{
lhs = string.Format("({0})", LHS.ToString());
}
else
{
lhs = LHS.ToString();
}
showBrackets = true;
string rhs = string.Empty;
if (RHS is Integer)
{
showBrackets = false;
}
if ((this is AddOperation && RHS is AddOperation) ||
(this is AddOperation && RHS is MinusOperation) ||
(RHS is MultiplyOperation && this is MultiplyOperation))
{
showBrackets = false;
}
if (showBrackets)
{
rhs = string.Format("({0})", RHS.ToString());
}
else
{
rhs = RHS.ToString();
}
return(string.Format("{0} {1} {2}", lhs, symbol, rhs));
}
/// <summary>
/// Override the != equality operator
/// </summary>
/// <param name="LHS">Course 1 to compare</param>
/// <param name="RHS">Course 2 to compare</param>
/// <returns>true if both instances of LHS and RHS are NOT equal to each other.</returns>
public static bool operator !=(Course LHS, Course RHS)
{
if (((object)LHS) == null)
{
if (((object)RHS) == null)
{
return(false);
}
else
{
return(!RHS.Equals((object)LHS));
}
}
return(!LHS.Equals((object)RHS));
}
/// <summary>
/// Override the == equality operator
/// </summary>
/// <param name="LHS">Course 1 to compare</param>
/// <param name="RHS">Course 2 to compare</param>
/// <returns>true if both instances of LHS and RHS are equal to each other.</returns>
public static bool operator ==(Course LHS, Course RHS)
{
if (((object)LHS) == null)
{
if (((object)RHS) == null)
{
return(true);
}
else
{
return(RHS.Equals((object)LHS));
}
}
return(LHS.Equals((object)RHS));
}
public override void EmitOp(DMObject dmObject, DMProc proc, DMReference reference)
{
string skipLabel = proc.NewLabelName();
string endLabel = proc.NewLabelName();
proc.PushReferenceValue(reference);
proc.JumpIfTrue(skipLabel);
RHS.EmitPushValue(dmObject, proc);
proc.Assign(reference);
proc.Jump(endLabel);
proc.AddLabel(skipLabel);
proc.PushReferenceValue(reference);
proc.AddLabel(endLabel);
}
public override long GetImmediateValue(AstScope scope)
{
var lhsMode = LHS.GetAddressingMode(scope);
var rhsMode = RHS.GetAddressingMode(scope);
long val = 0;
if ((lhsMode & AddressingMode.Immediate) != 0)
{
val += LHS.GetImmediateValue(scope);
}
if ((rhsMode & AddressingMode.Immediate) != 0)
{
val += RHS.GetImmediateValue(scope);
}
return(val);
}
public override void CheckTypes(ErrorHandler errorHandler)
{
LHS.CheckTypes(errorHandler);
RHS.CheckTypes(errorHandler);
bool canApply = true;
var intType = new PrimType(PrimTypeName.INT);
var floatType = new PrimType(PrimTypeName.FLOAT);
var boolType = new PrimType(PrimTypeName.BOOL);
var stringType = new PrimType(PrimTypeName.STRING);
if (Op == BinaryOp.ADD && !CanBothConvertTo(stringType, errorHandler) &&
!CanBothConvertTo(intType, errorHandler) && !CanBothConvertTo(floatType, errorHandler))
{
canApply = false;
}
if ((Op == BinaryOp.AND || Op == BinaryOp.OR) && !CanBothConvertTo(boolType, errorHandler))
{
canApply = false;
}
if ((Op == BinaryOp.DIV || Op == BinaryOp.MUL || Op == BinaryOp.SUB) &&
!CanBothConvertTo(intType, errorHandler) && !CanBothConvertTo(floatType, errorHandler))
{
canApply = false;
}
if (Op == BinaryOp.MOD && !CanBothConvertTo(intType, errorHandler))
{
canApply = false;
}
if ((Op == BinaryOp.L || Op == BinaryOp.LE || Op == BinaryOp.G || Op == BinaryOp.GE || Op == BinaryOp.NE ||
Op == BinaryOp.EQ) && !CanBothConvertTo(boolType, errorHandler))
{
canApply = false;
}
if ((Op == BinaryOp.B_AND || Op == BinaryOp.B_NOT || Op == BinaryOp.B_OR || Op == BinaryOp.B_SHL ||
Op == BinaryOp.B_SHR || Op == BinaryOp.B_XOR) && !CanBothConvertTo(intType, errorHandler))
{
canApply = false;
}
if (!canApply)
{
errorHandler.AddMessage(Severity.Error, $"Cannot apply operator {OpName(Op)} to operands of types {LHS.GetExprType(errorHandler)} ans {RHS.GetExprType(errorHandler)}", OpToken);
}
}
public override string ToString()
{
StringBuilder sbFormat = new StringBuilder();
sbFormat.Append(LHS.ToString());
sbFormat.Append(" ");
if (IsSignalAssignment)
{
sbFormat.Append(ProtoCore.VHDL.Constants.Naming.kSignalAssignSymbol);
}
else
{
sbFormat.Append(ProtoCore.VHDL.Constants.Naming.kVariableAssignSymbol);
}
sbFormat.Append(" ");
sbFormat.Append(RHS.ToString());
sbFormat.Append(";");
return(sbFormat.ToString());
}
public override Value code(IRBuilder builder)
{
Value L = LHS.code(builder);
Value R = RHS.code(builder);
// import strcmp function
LLVM.Type[] argTypes = new LLVM.Type[] { Parser.i8p, Parser.i8p };
FunctionType stringStringToInt = new FunctionType(Parser.i8, argTypes);
Value strcmp = Parser.module.GetOrInsertFunction("strcmp", stringStringToInt);
LLVM.Value[] args = new LLVM.Value[] { L, R };
Value strCmpResult = builder.CreateCall(strcmp, args);
Predicate comparison = (relation == EqualityRelation.EQUAL) ? Predicate.Equal : Predicate.NotEqual;
Value output = builder.CreateFCmp(comparison, strCmpResult, Parser.zero, "tempStrEqExp");
return(output);
}
public override Value code(IRBuilder builder)
{
Value L = LHS.code(builder);
Value R = RHS.code(builder);
Predicate fcmpPredicate;
switch (rel)
{
case Relation.EQUAL:
fcmpPredicate = Predicate.OrderedEqual;
break;
case Relation.NOTEQUAL:
fcmpPredicate = Predicate.OrderedNotEqual;
break;
case Relation.GREATERTHAN:
fcmpPredicate = Predicate.OrderedGreaterThan;
break;
case Relation.LESSTHAN:
fcmpPredicate = Predicate.OrderedLessThan;
break;
case Relation.NOTGREATER:
fcmpPredicate = Predicate.OrderedLessOrEqual;
break;
case Relation.NOTLESS:
fcmpPredicate = Predicate.OrderedGreaterOrEqual;
break;
default:
fcmpPredicate = Predicate.OrderedEqual;
break;
}
return(builder.CreateFCmp(fcmpPredicate, L, R, "tempNumEqExp"));
}
/// <inheritdoc />
/// <summary>
/// Evaluates <see langword="this" /> instance.
/// </summary>
/// <returns><see cref="T:System.Object" />.</returns>
/// <exception cref="T:System.Exception">
/// </exception>
public override object Evaluate()
{
Test.Evaluate();
LHS.Evaluate();
RHS.Evaluate();
if (Test.EvaluatedValue == null)
{
throw new Exception("Test null value");
}
if (LHS.EvaluatedValue == null)
{
throw new Exception("LHS null value");
}
if (RHS.EvaluatedValue == null)
{
throw new Exception("RHS null value");
}
EvaluatedValue = Convert.ToBoolean(Test.Evaluate()) ? LHS.Evaluate() : RHS.Evaluate();
EvaluatedType = Helper.GetType(EvaluatedValue);
return(EvaluatedValue);
}
public override void EmitPushValue(DMObject dmObject, DMProc proc)
{
LHS.EmitPushValue(dmObject, proc);
RHS.EmitPushValue(dmObject, proc);
proc.NotEquivalent();
}
private void RKstageImplicit(double PhysTime, double dt, double[][] k, int s, BlockMsrMatrix[] Mass, CoordinateVector u0, double ActualLevSetRelTime, double[] RK_as, double RelTime)
{
Debug.Assert(s < m_RKscheme.Stages);
Debug.Assert(m_RKscheme.c[s] > 0);
Debug.Assert(RK_as[s] != 0);
int Ndof = m_CurrentState.Count;
// =========
// RHS setup
// =========
m_ImplStParams = new ImplicitStage_AssiParams()
{
m_CurrentDt = dt,
m_CurrentPhystime = PhysTime,
m_IterationCounter = 0,
m_ActualLevSetRelTime = ActualLevSetRelTime,
m_RelTime = RelTime,
m_k = k,
m_u0 = u0,
m_Mass = Mass,
m_RK_as = RK_as,
m_s = s
};
// ================
// solve the system
// ================
NonlinearSolver nonlinSolver;
ISolverSmootherTemplate linearSolver;
GetSolver(out nonlinSolver, out linearSolver);
if (RequiresNonlinearSolver)
{
// Nonlinear Solver (Navier-Stokes)
// --------------------------------
nonlinSolver.SolverDriver(m_CurrentState, default(double[])); // Note: the RHS is passed as the affine part via 'this.SolverCallback'
}
else
{
// Linear Solver (Stokes)
// ----------------------
// build the saddle-point matrix
BlockMsrMatrix System, MaMa;
double[] RHS;
this.AssembleMatrixCallback(out System, out RHS, out MaMa, CurrentStateMapping.Fields.ToArray(), true);
RHS.ScaleV(-1);
// update the multigrid operator
MultigridOperator mgOperator = new MultigridOperator(this.MultigridBasis, CurrentStateMapping,
System, MaMa,
this.Config_MultigridOperator);
// init linear solver
linearSolver.Init(mgOperator);
// try to solve the saddle-point system.
mgOperator.UseSolver(linearSolver, m_CurrentState, RHS);
// 'revert' agglomeration
m_CurrentAgglomeration.Extrapolate(CurrentStateMapping);
}
// ================
// reset
// ================
m_ImplStParams = null;
}
public override void EmitPushValue(DMObject dmObject, DMProc proc)
{
LHS.EmitPushValue(dmObject, proc);
RHS.EmitPushValue(dmObject, proc);
proc.BitShiftRight();
}
public override void EmitPushValue(DMObject dmObject, DMProc proc)
{
LHS.EmitPushValue(dmObject, proc);
RHS.EmitPushValue(dmObject, proc);
proc.GreaterThan();
}
public override void EmitPushValue(DMObject dmObject, DMProc proc)
{
LHS.EmitPushValue(dmObject, proc);
RHS.EmitPushValue(dmObject, proc);
proc.BinaryOr();
}
/// <summary> /// /// </summary> /// <returns> subtract of the count of LHS & RHS </returns> public override double Evaluate() => (LHS.Evaluate() - RHS.Evaluate());
public override void EmitPushValue(DMObject dmObject, DMProc proc)
{
LHS.EmitPushValue(dmObject, proc);
RHS.EmitPushValue(dmObject, proc);
proc.Multiply();
}
public override void EmitOp(DMObject dmObject, DMProc proc, DMReference reference)
{
RHS.EmitPushValue(dmObject, proc);
proc.ModulusReference(reference);
}
public override void EmitPushValue(DMObject dmObject, DMProc proc)
{
LHS.EmitPushValue(dmObject, proc);
RHS.EmitPushValue(dmObject, proc);
proc.LessThanOrEqual();
}
public override void EmitPushValue(DMObject dmObject, DMProc proc)
{
LHS.EmitPushValue(dmObject, proc);
RHS.EmitPushValue(dmObject, proc);
proc.Subtract();
}
