/// <summary>
/// Returns the System Type from the Specified EvalType
/// </summary>
/// <param name="t">The Eval Type</param>
/// <returns>System Type associated to the EvalType</returns>
internal static Type GetSystemType(EvalType t)
{
switch (t)
{
case EvalType.Boolean:
{
return(typeof(bool));
}
case EvalType.Date:
{
return(typeof(DateTime));
}
case EvalType.Number:
{
return(typeof(double));
}
case EvalType.String:
{
return(typeof(string));
}
default:
{
return(typeof(object));
}
}
}
public opCodeUnary(eTokenType tt, opCode param1)
{
mParam1 = param1;
mParam1.ValueChanged += mParam1_ValueChanged;
EvalType v1Type = mParam1.EvalType;
switch (tt)
{
case eTokenType.operator_not:
{
if (v1Type == EvalType.Boolean)
{
mValueDelegate = BOOLEAN_NOT;
mEvalType = EvalType.Boolean;
}
break;
}
case eTokenType.operator_minus:
{
if (v1Type == EvalType.Number)
{
mValueDelegate = NUM_CHGSIGN;
mEvalType = EvalType.Number;
}
break;
}
}
}
public Attribute(string name, Type type, Func <T, object> getValue)
{
this.Name = name;
this.Type = type;
this.ValueAccessor = getValue;
evalType = EntityDataReader <T> .Attribute.EvalType.ValueAccessor;
}
/// <summary>
/// Salva le modifiche alla commissione
/// </summary>
/// <param name="Name">Nome commissione</param>
/// <param name="Description">Descrizione Commissione</param>
/// <param name="Tags">Stringa con i tag, separati da ,</param>
/// <param name="IsMaster">Indica se la commissione è la commissione principale</param>
/// <param name="EvType">Tipo di aggregazione delle valutazioni dei commissari</param>
/// <param name="EvMinVal">Valore minimo della valutazione per il superamento della commissione</param>
/// <param name="EvLockBool">Indica se considerare i criteri booleani ai fini del superamento</param>
/// <param name="UpdateView">Se TRUE la pagina sarà aggiornata in automatico. A FALSE se sono necessarie altre operazioni prima del refresh.</param>
/// <param name="StepEvType">Tipo di aggregazione tra le commissioni</param>
/// <param name="MaxValue"></param>
/// <param name="TemplateId">Id Template per esportazione documento commissione</param>
/// <param name="TemplateVersionId">Id Versione Template (se -1, ultima versione)</param>
/// <param name="criterions">Elenco criteri di valutazione</param>
public void SaveCommitee(
string Name,
string Description,
string Tags,
bool IsMaster,
EvalType EvType,
int EvMinVal,
bool EvLockBool,
bool UpdateView,
EvalType StepEvType,
Double MaxValue,
Int64 TemplateId,
Int64 TemplateVersionId,
List <dtoCriterion> criterions = null)
{
bool success = CallService.CommissionUpdate(
View.IdComm,
Name,
Description,
Tags,
IsMaster,
EvType,
EvMinVal,
EvLockBool,
StepEvType,
MaxValue,
TemplateId,
TemplateVersionId,
criterions);
if (success && UpdateView)
{
InitView();
}
}
public Transposition(Hashcode qHash,
#if XPHash128
Hashcode qHashPawn,
#endif
#if XPMoveTypes
MoveTypeOrdering mtOrdering,
#endif
Ply wMovePly,
Depth wDepth,
Eval mValue = EvalUndefined,
EvalType et = EvalType.Undefined,
Move moveBest = Move.Undefined)
{
Hash = qHash;
Debug.Assert(Hash != 0, "Zero Hash [Transposition]");
#if XPHash128
HashPawn = qHashPawn;
#endif
#if XPMoveTypes
MoveTypeOrdering = mtOrdering;
#endif
MovePly = wMovePly;
Depth = wDepth;
ibv = IBV(mValue, et);
BestMove = moveBest & Move.StoreMask;
}
//
//[ToDo]Killer updates are not thread safe. See also the references, e.g., in sortMoves().
//
protected void storeKiller(Move uMaskedMove, Depth wDepth, Eval mValue, EvalType et)
{
var bWTM = WTM();
Trace.Assert(EvalUndefined < mValue, "storeKiller(EvalUndefined)");
traceVal("storeKiller", mValue, et); //[Conditional]
var mAdjusted = creditMate(mValue, SearchPly);
var store = new GoodMove(uMaskedMove, wDepth, mAdjusted, et);
UInt32 wPly = State.MovePly;
#if BottleGamePly
wPly = GamePly;
#else
wPly += wDepth; //[Note]wDepth value may not guarantee Ply/Color Parity
#endif
#if KillerCompositionHash
var uMemoHash = compositionHash(true);
wPly *= uMemoHash;
#endif
#if BottleBothSides
var nSide = bWTM ? 0 : 1;
#else
var nSide = 0;
#endif
State.Bottle.Save(store, uMaskedMove, wPly, nSide);
}
public OPCodeSystemTypeConvert(IEvalTypedValue param1, Type type)
{
Param1 = param1;
mValueDelegate = CType;
mSystemType = type;
mEvalType = Globals.GetEvalType(type);
}
/// <summary>
/// Public Constructor
/// </summary>
/// <param name="tt">The Token Type</param>
/// <param name="param1">The Parameter</param>
public OPCodeUnary(TokenType tt, OPCode param1)
{
Param1 = param1;
EvalType v1Type = Param1.EvalType;
switch (tt)
{
case TokenType.OperatorNot:
{
if (v1Type == EvalType.Boolean)
{
mValueDelegate = BOOLEAN_NOT;
mEvalType = EvalType.Boolean;
}
break;
}
case TokenType.OperatorMinus:
{
if (v1Type == EvalType.Number)
{
mValueDelegate = NUM_CHGSIGN;
mEvalType = EvalType.Number;
}
break;
}
}
}
private static Eval boundValue(Eval mValue, Eval mValueFound, EvalType etFound)
{
if (EvalUndefined < mValueFound)
{
//
// Apply Upper or Lower Bound to mValue
//
switch (etFound)
{
case EvalType.Upper: // LUB
if (mValueFound < mValue)
{
mValue = mValueFound;
}
break;
case EvalType.Lower: // GLB
if (mValue < mValueFound)
{
mValue = mValueFound;
}
break;
default:
break;
}
}
return(mValue);
}
protected Eval storeQXP(Eval mValue, EvalType et,
Move moveBest = Move.Undefined)
{
Trace.Assert(EvalUndefined < mValue, "storeQXP(EvalUndefined)");
traceVal("storeQXP", mValue, et); //[Conditional]
State.IncEvalType(et);
var mAdjusted = creditMate(mValue, SearchPly);
if (IsFinal())
{
Trace.Assert(!isDefined(moveBest), "moveBest defined in a Final position.");
moveBest = Move.EmptyMove;
}
#if DebugMoveColor
if (isDefinite(moveBest))
{
var bWTM = WTM();
var bWhiteMove = (moveBest & Move.WTM) != 0;
if (bWTM != bWhiteMove)
{
Debug.Assert(bWTM == bWhiteMove, "WTM != WhiteMove [storeQXP]");
DisplayCurrent("storeQXP()");
}
}
#endif
#if QXPHash128
var store = new QuietPosition(Hash, State.MovePly, HashPawn, mAdjusted, et, moveBest);
#else
var store = new QuietPosition(Hash, State.MovePly, mAdjusted, et, moveBest);
#endif
State.QXPTank.Save(store);
return(mValue);
}
protected Boolean probeXP(Depth wDepth, Eval mAlpha, Eval mBeta, Move moveExcluded, List <GoodMove> goodMoves,
out Move moveFound, out Eval mValue, out EvalType etFound)
{
var qDynamic = DynamicHash(moveExcluded);
#if XPHash128
#if XPMoveTypes
var match = new Transposition(qDynamic, HashPawn, MoveTypeOrdering, State.MovePly, wDepth);
#else
var match = new Transposition(qDynamic, HashPawn, State.MovePly, wDepth);
#endif
#else // XPHash128
#if XPMoveTypes
var match = new Transposition(qDynamic, MoveTypeOrdering, State.MovePly, wDepth);
#else
var match = new Transposition(qDynamic, State.MovePly, wDepth);
#endif
#endif
var bValid = State.XPTank.LoadFirst(ref match);
#if XPMoveTypes
if (bValid)
{
MoveTypeOrdering = match.MoveTypeOrdering;
}
#endif
moveFound = adjustEmptyMove(match.BestMove); //[out]3
etFound = match.Type; //[out]2
var mValueFound = match.Value;
traceVal("probeXP", mValueFound, etFound); //[Conditional]
mValue = addMove(moveFound, goodMoves, wDepth, mValueFound, mAlpha, mBeta, etFound); //[out]1
var bValueDefined = EvalUndefined < mValue;
return(bValid && bValueDefined);
}
//
// Copy Constructor:
//
public GoodMove(GoodMove gm)
{
// Value Type precludes use of gm.CopyTo(this) here:
Move = gm.Move;
Value = gm.Value;
Type = gm.Type;
Depth = gm.Depth;
}
/// <param name="msbuild">To evaluate data with MSBuild engine where it's allowed.</param>
/// <param name="type">Allowed types of evaluation with MSBuild.</param>
public PM(IMSBuild msbuild = null, EvalType type = EvalType.ArgStringD)
{
//if(msbuild == null) {
// throw new InvalidArgumentException("PM: The `msbuild` argument cannot be null");
//}
this.msbuild = msbuild;
teval = type;
}
public opCodeSystemTypeConvert(iEvalTypedValue param1, System.Type Type)
{
mParam1 = param1;
mParam1.ValueChanged += mParam1_ValueChanged;
mValueDelegate = CType;
mSystemType = Type;
mEvalType = Globals.GetEvalType(Type);
}
public EvalVariable(string name, object originalValue, string description, System.Type systemType)
{
mName = name;
mValue = originalValue;
mDescription = description;
mSystemType = systemType;
mEvalType = Globals.GetEvalType(systemType);
}
/// <param name="msbuild">To evaluate data with MSBuild engine where it's allowed.</param>
/// <param name="type">Allowed types of evaluation with MSBuild.</param>
public PM(IMSBuild msbuild = null, EvalType type = EvalType.ArgStringD)
{
//if(msbuild == null) {
// throw new InvalidArgumentException("PM: The `msbuild` argument cannot be null");
//}
this.msbuild = msbuild;
teval = type;
}
protected string eval(EvalType type, string raw)
{
if (type == EvalType.None || msbuild == null)
{
return(raw);
}
return(((teval & type) == type)? msbuild.parse(raw) : raw);
}
private NumberType NT(EvalType t)
{
if (t is NumberType)
return t as NumberType;
var nl = t as NumberListType;
if (nl.Length == 1)
return nl[0];
throw new Exception("Must be a number.");
}
public GoodMove(Move move,
Depth wDepth = 0,
Eval mValue = EvalUndefined,
EvalType et = EvalType.Undefined)
{
Move = move;
Value = mValue;
Type = et;
Depth = wDepth;
}
/// <summary>
/// Public Constructor
/// </summary>
/// <param name="array">Array to Index</param>
/// <param name="params">The Parameter of the Index Operation</param>
public OPCodeGetArrayEntry(OPCode array, IList @params)
{
IEvalTypedValue[] newParams = new IEvalTypedValue[@params.Count];
int[] newValues = new int[@params.Count];
@params.CopyTo(newParams, 0);
Array = array;
mParams = newParams;
mValues = newValues;
mResultSystemType = array.SystemType.GetElementType();
mResultEvalType = Globals.GetEvalType(mResultSystemType);
}
public opCodeGetArrayEntry(opCode array, IList <iEvalTypedValue> @params)
{
iEvalTypedValue[] newParams = new iEvalTypedValue[@params.Count - 1 + 1];
int[] newValues = new int[@params.Count - 1 + 1];
@params.CopyTo(newParams, 0);
mArray = array;
mArray.ValueChanged += mBaseVariable_ValueChanged;
mParams = newParams;
mValues = newValues;
mResultSystemType = array.SystemType.GetElementType();
mResultEvalType = Globals.GetEvalType(mResultSystemType);
}
public static Bval IBV(Eval mValue, EvalType et)
{
if (mValue == EvalUndefined)
{
return((Bval)EvalUndefined);
}
else
{
var nIBV = (mValue << nPerTwoBits) + twoBits((Int32)et);
return((Bval)nIBV);
}
}
/// <summary>
/// Converts the Specified OPCode to the Specified EvalType
/// </summary>
/// <param name="tokenizer">The Tokenizer Instance</param>
/// <param name="param1">The OPCode to Convert</param>
/// <param name="evalType">Target Type</param>
protected internal void Convert(Tokenizer tokenizer, ref OPCode param1, EvalType evalType)
{
if (param1.EvalType != evalType)
{
if (param1.CanReturn(evalType))
{
param1 = new OPCodeConvert(tokenizer, param1, evalType);
}
else
{
tokenizer.RaiseError("Cannot convert " + param1.Name + " into " + (int)evalType);
}
}
}
protected internal void Convert(tokenizer tokenizer, ref opCode param1, EvalType EvalType)
{
if (param1.EvalType != EvalType)
{
if (param1.CanReturn(EvalType))
{
param1 = new opCodeConvert(tokenizer, param1, EvalType);
}
else
{
tokenizer.RaiseError("Cannot convert " + param1.Name + " into " + EvalType);
}
}
}
protected Eval storeXP(Depth wDepth, Eval mValue, EvalType et,
Move moveBest = Move.Undefined,
Move moveExcluded = Move.Undefined) // 10 MHz
{
Trace.Assert(EvalUndefined < mValue, "storeXP(EvalUndefined)");
traceVal("storeXP", mValue, et); //[Conditional]
State.IncEvalType(et);
var qDynamic = DynamicHash(moveExcluded);
var mAdjusted = creditMate(mValue, SearchPly);
if (IsFinal())
{
Trace.Assert(!isDefined(moveBest), "moveBest defined in a Final position.");
moveBest = Move.EmptyMove;
}
#if DebugMoveColor
if (isDefinite(moveBest))
{
var bWTM = WTM();
var bWhiteMove = (moveBest & Move.WTM) != 0;
if (bWTM != bWhiteMove)
{
Debug.Assert(bWTM == bWhiteMove, "WTM != WhiteMove [storeXP]");
DisplayCurrent("storeXP()");
}
}
#endif
#if XPHash128
#if XPMoveTypes
var store = new Transposition(qDynamic, HashPawn, MoveTypeOrdering, State.MovePly, wDepth,
mAdjusted, et, moveBest);
#else
var store = new Transposition(qDynamic, HashPawn, State.MovePly, wDepth,
mAdjusted, et, moveBest);
#endif
#else // XPHash128
#if XPMoveTypes
var store = new Transposition(qDynamic, MoveTypeOrdering, State.MovePly, wDepth,
mAdjusted, et, moveBest);
#else
var store = new Transposition(qDynamic, State.MovePly, wDepth,
mAdjusted, et, moveBest);
#endif
#endif
State.XPTank.Save(store);
return(mValue);
}
protected Eval storeXPM(Depth wDepth, Eval mValue, EvalType et,
Move moveBest = Move.Undefined,
Move moveExcluded = Move.Undefined) // 10 MHz
{
Trace.Assert(EvalUndefined < mValue, "storeXPM(EvalUndefined)");
traceVal("storeXPM", mValue, et); //[Conditional]
State.IncEvalType(et);
#if XPMCompositionHash || DebugMoveColor
var bWTM = WTM();
#endif
#if XPMCompositionHash
UInt32 wPly = State.MovePly;
var nSide = bWTM ? 0 : 1;
var uMemoHash = compositionHash(bWTM);
var qDynamic = (Hashcode)(uMemoHash * wPly + nSide);
#else
var qDynamic = DynamicHash(moveExcluded);
#endif
var mAdjusted = creditMate(mValue, SearchPly);
if (IsFinal())
{
Trace.Assert(!isDefined(moveBest), "moveBest defined in a Final position.");
moveBest = Move.EmptyMove;
}
#if DebugMoveColor
if (isDefinite(moveBest))
{
var bWhiteMove = (moveBest & Move.WTM) != 0;
if (bWTM != bWhiteMove)
{
Debug.Assert(bWTM == bWhiteMove, "WTM != WhiteMove [storeXPM]");
DisplayCurrent("storeXPM()");
}
}
#endif
#if XPHash128
var store = new PositionMove(qDynamic, HashPawn, State.MovePly, wDepth,
mAdjusted, et, moveBest);
#else
var store = new PositionMove(qDynamic, State.MovePly, wDepth,
mAdjusted, et, moveBest);
#endif
State.XPMTank.Save(store);
return(mValue);
}
/// <summary>
/// Public Constructor
/// </summary>
/// <param name="tokenizer">Tokenizer Instance</param>
/// <param name="param1">The First Parameter</param>
/// <param name="evalType">The Evaluator Type</param>
public OPCodeConvert(Tokenizer tokenizer, IEvalTypedValue param1, EvalType evalType)
{
Param1 = param1;
switch (evalType)
{
case EvalType.Boolean:
{
mValueDelegate = TBool;
mEvalType = EvalType.Boolean;
break;
}
case EvalType.Date:
{
mValueDelegate = TDate;
mEvalType = EvalType.Date;
break;
}
case EvalType.Number:
{
mValueDelegate = TNum;
mEvalType = EvalType.Number;
break;
}
case EvalType.String:
{
mValueDelegate = TStr;
mEvalType = EvalType.String;
break;
}
default:
{
tokenizer.RaiseError(
"Cannot convert " +
param1.SystemType.Name +
" to " +
(int)evalType
);
break;
}
}
}
public QuietPosition(Hashcode qHash,
#if QXPHash128
Hashcode qHashPawn,
#endif
Ply wMovePly,
Eval mValue = EvalUndefined,
EvalType et = EvalType.Undefined,
Move moveBest = Move.Undefined)
{
Hash = qHash;
Debug.Assert(Hash != 0, "Zero Hash [QuietPosition]");
#if QXPHash128
HashPawn = qHashPawn;
#endif
MovePly = wMovePly;
ibv = IBV(mValue, et);
BestMove = moveBest & Move.StoreMask;
}
protected Boolean probeQXP(Eval mAlpha, Eval mBeta,
out Move moveFound, out Eval mValue, out EvalType etFound)
{
#if QXPHash128
var match = new QuietPosition(Hash, State.MovePly, HashPawn);
#else
var match = new QuietPosition(Hash, State.MovePly);
#endif
var bValid = State.QXPTank.LoadFirst(ref match);
var moveBest = adjustEmptyMove(match.BestMove);
moveFound = isDefined(moveBest) ? moveBest | Move.Qxnt : moveBest; //[out]3
etFound = match.Type; //[out]2
//[Note]Mate values are suspect because quiet moves were not considered
var mValueFound = match.Value;
mValue = adjustValue(mAlpha, mBeta, mValueFound, etFound, SearchPly); //[out]1
traceVal("probeQXP", mValue, etFound); //[Conditional]
var bValueDefined = EvalUndefined < mValue;
return(bValid && bValueDefined);
}
public PositionMove(Hashcode qHash,
#if XPMHash128
Hashcode qHashPawn,
#endif
Ply wMovePly,
Depth wDepth,
Eval mValue = EvalUndefined,
EvalType et = EvalType.Undefined,
Move moveBest = Move.Undefined)
{
Hash = qHash;
Debug.Assert(Hash != 0, "Zero Hash [PositionMove]");
#if XPMHash128
HashPawn = qHashPawn;
#endif
MovePly = wMovePly;
Depth = wDepth;
ibv = IBV(mValue, et);
BestMove = moveBest & Move.StoreMask;
}
public void IncEvalType(EvalType et)
{
switch (et)
{
case EvalType.Upper:
AtomicIncrement(ref UpperCount);
break;
case EvalType.Exact:
AtomicIncrement(ref ExactCount);
break;
case EvalType.Lower:
AtomicIncrement(ref LowerCount);
break;
default:
throw new PositionException("Unexpected EvalType");
}
}
public opCodeConvert(tokenizer tokenizer, iEvalTypedValue param1, EvalType EvalType)
{
mParam1 = param1;
mParam1.ValueChanged += mParam1_ValueChanged;
switch (EvalType)
{
case EvalType.Boolean:
{
mValueDelegate = TBool;
mEvalType = EvalType.Boolean;
break;
}
case EvalType.Date:
{
mValueDelegate = TDate;
mEvalType = EvalType.Date;
break;
}
case EvalType.Number:
{
mValueDelegate = TNum;
mEvalType = EvalType.Number;
break;
}
case EvalType.String:
{
mValueDelegate = TStr;
mEvalType = EvalType.String;
break;
}
default:
{
tokenizer.RaiseError("Cannot convert " + param1.SystemType.Name + " to " + EvalType);
break;
}
}
}
public EvalType Pow(EvalType right)
{
if (right is NumberType)
return this ^ (right as NumberType);
return new NumberListType(this).Pow(right);
}
public EvalType Add(EvalType right)
{
if (right is StringType)
return new StringType(ToString()).Add(right);
return this + (NumberListType)right;
}
public opCodeGetArrayEntry(opCode array, IList @params)
{
iEvalTypedValue[] newParams = new iEvalTypedValue[@params.Count];
int[] newValues = new int[@params.Count];
@params.CopyTo(newParams, 0);
mArray = array;
mParams = newParams;
mValues = newValues;
mResultSystemType = array.SystemType.GetElementType;
mResultEvalType = Globals.GetEvalType(mResultSystemType);
}
public opCodeSystemTypeConvert(iEvalTypedValue param1, Type Type)
{
mParam1 = param1;
mValueDelegate = CType;
mSystemType = Type;
mEvalType = Globals.GetEvalType(Type);
}
public opCodeUnary(eTokenType tt, opCode param1)
{
mParam1 = param1;
EvalType v1Type = mParam1.EvalType;
switch (tt)
{
case eTokenType.operator_not:
if (v1Type == EvalType.Boolean)
{
mValueDelegate = BOOLEAN_NOT;
mEvalType = EvalType.Boolean;
}
break;
case eTokenType.operator_minus:
if (v1Type == EvalType.Number)
{
mValueDelegate = NUM_CHGSIGN;
mEvalType = EvalType.Number;
}
break;
}
}
protected internal void Convert(tokenizer tokenizer, ref opCode param1, EvalType EvalType)
{
if (param1.EvalType != EvalType)
{
if (param1.CanReturn(EvalType))
{
param1 = new opCodeConvert(tokenizer, param1, EvalType);
}
else
{
tokenizer.RaiseError("Cannot convert " + param1.Name + " into " + EvalType);
}
}
}
internal Type GetSystemType(EvalType t)
{
switch (t)
{
case EvalType.Boolean:
return typeof(bool);
case EvalType.Date:
return typeof(DateTime);
case EvalType.Number:
return typeof(double);
case EvalType.String:
return typeof(string);
default:
return typeof(object);
}
}
public EvalType Add(EvalType right)
{
if (right is NumberType)
return this + (right as NumberType);
else if (right is StringType)
return new StringType(ToString()).Add(right);
else if (right is NumberListType)
return new NumberListType(this) + (NumberListType)right;
throw new Exception("Right side must be a number, string, or list.");
}
public EvalType Sub(EvalType right)
{
if (right is NumberType)
return this - (right as NumberType);
else if (right is NumberListType)
return new NumberListType(this) - (NumberListType)right;
throw new Exception("Right side must be a number.");
}
public bool GreaterEql(EvalType right)
{
if (right is NumberType)
return this >= (right as NumberType);
return new NumberListType(this).GreaterEql(right);
}
public bool LessEql(EvalType right)
{
if (right is NumberType)
return this <= (right as NumberType);
return new NumberListType(this).LessEql(right);
}
public bool Equals(EvalType right)
{
if (right is NumberType)
return this == (right as NumberType);
else if (right is NumberListType)
return new NumberListType(this) == (NumberListType)right;
return new NumberListType(this).Equals(right);
}
public EvalType Mul(EvalType right)
{
return this * (NumberListType)right;
}
protected string eval(EvalType type, string raw)
{
if(type == EvalType.None || msbuild == null) {
return raw;
}
return ((teval & type) == type)? msbuild.parse(raw) : raw;
}
public EvalVariable(string name, object originalValue, string description, Type systemType)
{
mName = name;
mValue = originalValue;
mDescription = description;
mSystemType = systemType;
mEvalType = Globals.GetEvalType(systemType);
}
/// <param name="raw">Initial raw data.</param>
/// <param name="msbuild">To evaluate data with MSBuild engine where it's allowed.</param>
/// <param name="type">Allowed types of evaluation with MSBuild.</param>
public PM(string raw, IMSBuild msbuild = null, EvalType type = EvalType.ArgStringD /*| EvalType.RightOperandStd*/)
: this(msbuild, type)
{
detect(raw);
}
public bool CanReturn(EvalType type)
{
return true;
}
public EvalType Pow(EvalType right)
{
throw new NotImplementedException();//return this ^ (NumberListType)right;
}
public opCodeImmediate(EvalType EvalType, object value)
{
mEvalType = EvalType;
mValue = value;
}
public bool LessEql(EvalType right)
{
throw new NotImplementedException();//return this <= (NumberListType)right;
}
public opCodeConvert(tokenizer tokenizer, iEvalTypedValue param1, EvalType EvalType)
{
mParam1 = param1;
switch (EvalType)
{
case EvalType.Boolean:
mValueDelegate = TBool;
mEvalType = EvalType.Boolean;
break;
case EvalType.Date:
mValueDelegate = TDate;
mEvalType = EvalType.Date;
break;
case EvalType.Number:
mValueDelegate = TNum;
mEvalType = EvalType.Number;
break;
case EvalType.String:
mValueDelegate = TStr;
mEvalType = EvalType.String;
break;
default:
tokenizer.RaiseError("Cannot convert " + param1.SystemType.Name + " to " + EvalType);
break;
}
}
public bool Greater(EvalType right)
{
throw new NotImplementedException();// return this > (NumberListType)right;
}
public opCodeBinary(tokenizer tokenizer, opCode param1, eTokenType tt, opCode param2)
{
mParam1 = param1;
mParam2 = param2;
EvalType v1Type = mParam1.EvalType;
EvalType v2Type = mParam2.EvalType;
switch (tt)
{
case eTokenType.operator_plus:
if (v1Type == EvalType.Number & v2Type == EvalType.Number)
{
mValueDelegate = NUM_PLUS_NUM;
mEvalType = EvalType.Number;
}
else if (v1Type == EvalType.Number & v2Type == EvalType.Date)
{
SwapParams(ref mParam1, mParam2);
mValueDelegate = DATE_PLUS_NUM;
mEvalType = EvalType.Date;
}
else if (v1Type == EvalType.Date & v2Type == EvalType.Number)
{
mValueDelegate = DATE_PLUS_NUM;
mEvalType = EvalType.Date;
}
else if (mParam1.CanReturn(EvalType.String) & mParam2.CanReturn(EvalType.String))
{
Convert(tokenizer, param1, ref EvalType.String);
mValueDelegate = STR_CONCAT_STR;
mEvalType = EvalType.String;
}
break;
case eTokenType.operator_minus:
if (v1Type == EvalType.Number & v2Type == EvalType.Number)
{
mValueDelegate = NUM_MINUS_NUM;
mEvalType = EvalType.Number;
}
else if (v1Type == EvalType.Date & v2Type == EvalType.Number)
{
mValueDelegate = DATE_MINUS_NUM;
mEvalType = EvalType.Date;
}
else if (v1Type == EvalType.Date & v2Type == EvalType.Date)
{
mValueDelegate = DATE_MINUS_DATE;
mEvalType = EvalType.Number;
}
break;
case eTokenType.operator_mul:
if (v1Type == EvalType.Number & v2Type == EvalType.Number)
{
mValueDelegate = NUM_MUL_NUM;
mEvalType = EvalType.Number;
}
break;
case eTokenType.operator_div:
if (v1Type == EvalType.Number & v2Type == EvalType.Number)
{
mValueDelegate = NUM_DIV_NUM;
mEvalType = EvalType.Number;
}
break;
case eTokenType.operator_percent:
if (v1Type == EvalType.Number & v2Type == EvalType.Number)
{
mValueDelegate = NUM_PERCENT_NUM;
mEvalType = EvalType.Number;
}
break;
case eTokenType.operator_and:
case eTokenType.operator_or:
Convert(tokenizer, mParam1, ref EvalType.Boolean);
Convert(tokenizer, mParam2, ref EvalType.Boolean);
switch (tt)
{
case eTokenType.operator_or:
mValueDelegate = BOOL_OR_BOOL;
mEvalType = EvalType.Boolean;
break;
case eTokenType.operator_and:
mValueDelegate = BOOL_AND_BOOL;
mEvalType = EvalType.Boolean;
break;
}
break;
}
if (mValueDelegate == null)
{
tokenizer.RaiseError("Cannot apply the operator " + tt.ToString().Replace("operator_", "") + " on " + v1Type.ToString() + " and " + v2Type.ToString());
}
}
public bool Equals(EvalType right)
{
return this == (NumberListType)right;
}
public EvalType Sub(EvalType right)
{
return this - (NumberListType)right;
}
public EvalType Div(EvalType right)
{
return this / (NumberListType)right;
}
public EvalType Div(EvalType right)
{
if (right is NumberType)
return this / (right as NumberType);
else if (right is NumberListType)
return new NumberListType(this) / (NumberListType)right;
return new NumberListType(this).Mul(right);
}
public EvalType Mod(EvalType right)
{
if (right is NumberType)
return this % (right as NumberType);
return new NumberListType(this).Mod(right);
}
