public BitwiseExprNode(OPERATOR _op, ExprNode _lhs, ExprNode _rhs)
{
type = OILType.BitwiseExpr;
op = _op;
lhs = _lhs;
rhs = _rhs;
}
public LogicalExprNode(OPERATOR _op, ExprNode _lhs, ExprNode _rhs)
{
type = OILType.LogicalExpr;
op = _op;
lhs = _lhs;
rhs = _rhs;
}
public ArithmeticExprNode(OPERATOR _op, ExprNode _lhs, ExprNode _rhs)
{
type = OILType.ArithmeticExpr;
op = _op;
lhs = _lhs;
rhs = _rhs;
}
public ComparisonExprNode(OPERATOR _op, ExprNode _lhs, ExprNode _rhs)
{
type = OILType.CompareExpr;
op = _op;
lhs = _lhs;
rhs = _rhs;
}
public virtual bool Write2buffer_Instructions(ref List <byte> bf)
{
try
{
StructFile sf_operator;
OPERAND _operand;
for (int j = 0; j < instructionlist.Count; j++)
{
sf_operator = new StructFile(typeof(OPERATOR));
OPERATOR _operator = instructionlist[j].Operator;
//_operator.ReturnType = Common.ntohi(_operator.ReturnType);
//_operator.OpCode = Common.ntohi(_operator.OpCode);
_operator.Res2 = 2;
_operator.Res3 = 3;
sf_operator.WriteStructure(ref bf, (object)_operator);
for (int k = 0; k < instructionlist[j].OperandList.Count; k++)
{
sf_operator = new StructFile(typeof(OPERAND));
_operand = instructionlist[j].OperandList[k];
//_operand.Index = Common.ntohl(_operand.Index);
instructionlist[j].OperandList[k] = _operand;
sf_operator.WriteStructure(ref bf, (object)instructionlist[j].OperandList[k]);
}
}
return(true);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
return(false);
}
}
/// <summary>
/// Inverses the operator provided
/// </summary>
/// <param name="Operator"></param>
/// <returns></returns>
public static OPERATOR Inverse(OPERATOR Operator)
{
OPERATOR retVal = Operator;
switch (Operator)
{
case OPERATOR.GREATER:
retVal = OPERATOR.LESS_OR_EQUAL;
break;
case OPERATOR.GREATER_OR_EQUAL:
retVal = OPERATOR.LESS;
break;
case OPERATOR.LESS:
retVal = OPERATOR.GREATER_OR_EQUAL;
break;
case OPERATOR.LESS_OR_EQUAL:
retVal = OPERATOR.GREATER;
break;
default:
throw new Exception("Cannot inverse operator " + Operator);
}
return(retVal);
}
/// <summary>
/// Test if an int parameter fulfils a condition
/// </summary>
/// <param name="_key"></param>
/// <param name="_condition"></param>
/// <param name="_marker"></param>
/// <returns></returns>
public bool TestInt(string _key, OPERATOR _condition, int _marker)
{
if (intValues.dictionary.ContainsKey(_key) == false)
{
Debug.LogError("Int key not found");
return(false);
}
int value = intValues.dictionary[_key];
switch (_condition)
{
case OPERATOR.less:
return(value < _marker);
case OPERATOR.greater:
return(value > _marker);
case OPERATOR.equals:
return(value == _marker);
default:
Debug.LogError("The current condition cannot be tested on an integer value");
return(false);
}
}
public AssignExprNode(OPERATOR _op, ExprNode _lhs, ExprNode _rhs)
{
type = OILType.AssignExpr;
op = _op;
lhs = _lhs;
rhs = _rhs;
}
private ITEM_LIST MakeListItem(OPERATOR op)
{
ITEM_LIST temp = new ITEM_LIST();
temp.SetOperator(op);
return(temp);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="left"></param>
/// <param name="op"></param>
/// <param name="right"></param>
public BinaryExpression(ModelElement root, Expression left, OPERATOR op, Expression right)
: base(root)
{
Left = left;
Left.Enclosing = this;
Operation = op;
Right = right;
Right.Enclosing = this;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="left"></param>
/// <param name="op"></param>
/// <param name="right"></param>
public BinaryExpression(ModelElement root, Expression left, OPERATOR op, Expression right)
: base(root)
{
Left = left;
Left.Enclosing = this;
Operation = op;
Right = right;
Right.Enclosing = this;
}
/// <summary>
/// Test if a bool parameter fulfils a condition
/// </summary>
/// <param name="_key"></param>
/// <param name="_condition"></param>
/// <param name="_marker"></param>
/// <returns></returns>
public bool TestBool(string _key, OPERATOR _condition, bool _marker)
{
if (boolValues.dictionary.ContainsKey(_key) == false)
{
Debug.LogError("Bool key not found");
return(false);
}
bool value = boolValues.dictionary[_key];
return(value == _marker);
}
/// <summary>
/// Provides the image of a given operator
/// </summary>
/// <param name="op"></param>
/// <returns></returns>
public static string Image(OPERATOR op)
{
string retVal = null;
for (int i = 0; i < Operators.Length; i++)
{
if (op == Operators[i])
{
retVal = OperatorsImages[i];
break;
}
}
return(retVal);
}
/// <summary>
/// Provides the operator, based on its image
/// </summary>
/// <param name="op"></param>
/// <returns></returns>
public static OPERATOR FindOperatorByName(string op)
{
OPERATOR retVal = OPERATOR.UNDEF;
for (int i = 0; i < Operators.Length; i++)
{
if (OperatorsImages[i].CompareTo(op) == 0)
{
retVal = Operators[i];
break;
}
}
return(retVal);
}
private void oPERATORBindingSource_CurrentChanged(object sender, EventArgs e)
{
OPERATOR rec = (OPERATOR)OperatorBindingSource.Current;
if (OperatorBindingSource.Current != null)
{
GridControlAdditionalContacts.DataSource = (from contRec in context.CONTACT
where contRec.LINK_TABLE == "OPERATOR" && contRec.LINK_VALUE == rec.CODE && contRec.RECTYPE == "OPRCONTACT"
select contRec).Distinct();
enableNavigator(true);
}
else
{
enableNavigator(false);
}
}
internal TOKINFO(
string text,
TOKFLAGS flags,
int len,
CParser.PARSERTYPE parser,
PREDEFTYPE predef,
OPERATOR binary,
OPERATOR unary,
OPERATOR self
)
{
this.Text = text;
this.Flags = flags;
this.Length = len;
this.StatementParser = parser;
this.PredefinedType = predef;
this.BinaryOperator = binary;
this.UnaryOperator = unary;
this.SelfOperator = self;
}
//______CONDITION TESTERS______//
/// <summary>
/// Test if a float parameter fulfils a condition
/// </summary>
/// <param name="_key"></param>
/// <param name="_condition"></param>
/// <param name="_marker"></param>
/// <returns></returns>
public bool TestFloat(string _key, OPERATOR _condition, float _marker)
{
if (floatValues.dictionary.ContainsKey(_key) == false)
{
Debug.LogError("Float key not found");
return(false);
}
float value = floatValues.dictionary[_key];
switch (_condition)
{
case OPERATOR.less:
return(value < _marker);
case OPERATOR.greater:
return(value > _marker);
default:
Debug.LogError("The current condition cannot be tested on a float value");
return(false);
}
}
/// <summary>
/// Constructor for an Expression
/// </summary>
/// <param name="truthValues">Strings representing the paramaters for evaluation</param>
/// <param name="op">Logical Operater for the Expression.</param>
public Expression(List <String> truthValues, OPERATOR op)
{
_truthValues = truthValues;
_op = op;
}
public bool SetOperator(OPERATOR op)
{
this.op = op;
this.knd = ExprKind.OPERATOR;
return(true);
}
public UnaryExpr(Expr r, OPERATOR op)
{
Right = r; OP = op;
}
public BinaryExpr(Expr l, Expr r, OPERATOR op)
{
Left = l; Right = r; OP = op;
}
public UnaryExpr(Expr r, OPERATOR op)
{
Right = new BinaryExpr(new Number(0),
r, op);
}
static string DoParse(string str, int val)
{
int i = 0;
bool inParse = false;
bool formattingResNum = false;
bool lookingForOperator = false;
bool escapingChar = false;
OPERATOR op = OPERATOR.NOOP;
string operand = "";
string stringOut = "";
int res = 0;
string numFmt = "{0,0:D0}";
string zeroString = "";
string operators = "#+-/*";
string strIn = str + '\0'; // ensures that last character is parsed
for (i = 0; i < strIn.Length; i++)
{
if (formattingResNum)
{
if (strIn[i] == '#')
{
zeroString += '0';
}
else
{
numFmt = string.Format("{{0:{0}}}", zeroString);
zeroString = "";
formattingResNum = false;
lookingForOperator = true;
}
}
if (inParse)
{
if ((strIn[i] >= '0') && (strIn[i] <= '9'))
{
operand += strIn[i];
}
else
{
switch (op)
{
case OPERATOR.NOOP:
res = val;
break;
case OPERATOR.ADD:
res = val + int.Parse(operand);
break;
case OPERATOR.SUB:
res = val - int.Parse(operand);
break;
case OPERATOR.DIV:
res = val / int.Parse(operand);
break;
case OPERATOR.MULT:
res = val * int.Parse(operand);
break;
}
stringOut += string.Format(numFmt, res);
operand = "";
inParse = false;
}
}
else if (lookingForOperator)
{
if (operators.IndexOf(strIn[i]) > -1)
{
if (strIn[i] == '#')
{
formattingResNum = true;
zeroString = "00";
lookingForOperator = false;
}
else
{
if (strIn[i] == '+')
{
op = OPERATOR.ADD;
}
else if (strIn[i] == '-')
{
op = OPERATOR.SUB;
}
else if (strIn[i] == '*')
{
op = OPERATOR.MULT;
}
else if (strIn[i] == '/')
{
op = OPERATOR.DIV;
}
inParse = true;
lookingForOperator = false;
}
}
else
{
stringOut += string.Format(numFmt, val);
lookingForOperator = false;
}
}
if (escapingChar || (strIn[i] != '\\'))
{
if (strIn[i] == '#')
{
if (!formattingResNum)
{
lookingForOperator = true;
}
}
else if ((!formattingResNum) &&
(!inParse) &&
(!lookingForOperator) &&
(strIn[i] != '\0'))
{
stringOut += strIn[i];
}
escapingChar = false;
}
else
{
escapingChar = true;
}
}
return(stringOut);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="left"></param>
/// <param name="op"></param>
/// <param name="right"></param>
/// <param name="start">The start character for this expression in the original string</param>
/// <param name="end">The end character for this expression in the original string</param>
public BinaryExpression(ModelElement root, ModelElement log, Expression left, OPERATOR op, Expression right,
int start, int end)
: base(root, log, start, end)
{
Left = left;
Left.Enclosing = this;
Operation = op;
Right = right;
Right.Enclosing = this;
}
/// <summary>
/// Inverses the operator provided
/// </summary>
/// <param name="Operator"></param>
/// <returns></returns>
public static OPERATOR Inverse(OPERATOR Operator)
{
OPERATOR retVal = Operator;
switch (Operator)
{
case OPERATOR.GREATER:
retVal = OPERATOR.LESS_OR_EQUAL;
break;
case OPERATOR.GREATER_OR_EQUAL:
retVal = OPERATOR.LESS;
break;
case OPERATOR.LESS:
retVal = OPERATOR.GREATER_OR_EQUAL;
break;
case OPERATOR.LESS_OR_EQUAL:
retVal = OPERATOR.GREATER;
break;
default:
throw new Exception("Cannot inverse operator " + Operator);
}
return retVal;
}
//------------------------------------------------------------
// FUNCBREC.OperatorToExpressionType
//
/// <summary></summary>
/// <param name="op"></param>
/// <returns></returns>
//------------------------------------------------------------
internal ExpressionType OperatorToExpressionType(OPERATOR op)
{
switch (op)
{
case OPERATOR.NONE:
//return ExpressionType;
break;
case OPERATOR.ASSIGN:
return(ExpressionType.Assign);
case OPERATOR.ADDEQ:
return(ExpressionType.AddAssign);
case OPERATOR.SUBEQ:
return(ExpressionType.SubtractAssign);
case OPERATOR.MULEQ:
return(ExpressionType.MultiplyAssign);
case OPERATOR.DIVEQ:
return(ExpressionType.DivideAssign);
case OPERATOR.MODEQ:
return(ExpressionType.ModuloAssign);
case OPERATOR.ANDEQ:
return(ExpressionType.AndAssign);
case OPERATOR.XOREQ:
return(ExpressionType.ExclusiveOrAssign);
case OPERATOR.OREQ:
return(ExpressionType.OrAssign);
case OPERATOR.LSHIFTEQ:
return(ExpressionType.LeftShiftAssign);
case OPERATOR.RSHIFTEQ:
return(ExpressionType.RightShiftAssign);
case OPERATOR.QUESTION:
//return ExpressionType;
break;
case OPERATOR.VALORDEF:
//return ExpressionType;
break;
case OPERATOR.LOGOR:
return(ExpressionType.Or);
case OPERATOR.LOGAND:
return(ExpressionType.And);
case OPERATOR.BITOR:
//return ExpressionType;
case OPERATOR.BITXOR:
//return ExpressionType;
case OPERATOR.BITAND:
//return ExpressionType;
break;
case OPERATOR.EQ:
return(ExpressionType.Equal);
case OPERATOR.NEQ:
return(ExpressionType.NotEqual);
case OPERATOR.LT:
return(ExpressionType.LessThan);
case OPERATOR.LE:
return(ExpressionType.LessThanOrEqual);
case OPERATOR.GT:
return(ExpressionType.GreaterThan);
case OPERATOR.GE:
return(ExpressionType.GreaterThanOrEqual);
case OPERATOR.IS:
return(ExpressionType.TypeIs);
case OPERATOR.AS:
return(ExpressionType.TypeAs);
case OPERATOR.LSHIFT:
return(ExpressionType.LeftShift);
case OPERATOR.RSHIFT:
return(ExpressionType.RightShift);
case OPERATOR.ADD:
return(ExpressionType.Add);
case OPERATOR.SUB:
return(ExpressionType.Subtract);
case OPERATOR.MUL:
return(ExpressionType.Multiply);
case OPERATOR.DIV:
return(ExpressionType.Divide);
case OPERATOR.MOD:
return(ExpressionType.Modulo);
case OPERATOR.NOP:
//return ExpressionType;
break;
case OPERATOR.UPLUS:
return(ExpressionType.UnaryPlus);
case OPERATOR.NEG:
return(ExpressionType.Negate);
case OPERATOR.BITNOT:
return(ExpressionType.OnesComplement);
case OPERATOR.LOGNOT:
return(ExpressionType.Not);
case OPERATOR.PREINC:
return(ExpressionType.PreIncrementAssign);
case OPERATOR.PREDEC:
return(ExpressionType.PreDecrementAssign);
case OPERATOR.TYPEOF:
//return ExpressionType;
case OPERATOR.SIZEOF:
//return ExpressionType;
case OPERATOR.CHECKED:
//return ExpressionType;
case OPERATOR.UNCHECKED:
//return ExpressionType;
case OPERATOR.MAKEREFANY:
//return ExpressionType;
case OPERATOR.REFVALUE:
//return ExpressionType;
case OPERATOR.REFTYPE:
//return ExpressionType;
case OPERATOR.ARGS:
//return ExpressionType;
case OPERATOR.CAST:
//return ExpressionType;
case OPERATOR.INDIR:
//return ExpressionType;
case OPERATOR.ADDR:
//return ExpressionType;
case OPERATOR.COLON:
//return ExpressionType;
case OPERATOR.THIS:
//return ExpressionType;
case OPERATOR.BASE:
//return ExpressionType;
case OPERATOR.NULL:
//return ExpressionType;
case OPERATOR.TRUE:
//return ExpressionType;
case OPERATOR.FALSE:
//return ExpressionType;
case OPERATOR.CALL:
//return ExpressionType;
case OPERATOR.DEREF:
//return ExpressionType;
case OPERATOR.PAREN:
//return ExpressionType;
break;
case OPERATOR.POSTINC:
return(ExpressionType.PostIncrementAssign);
case OPERATOR.POSTDEC:
return(ExpressionType.PostDecrementAssign);
case OPERATOR.DOT:
//return ExpressionType;
case OPERATOR.IMPLICIT:
//return ExpressionType;
case OPERATOR.EXPLICIT:
//return ExpressionType;
case OPERATOR.EQUALS:
//return ExpressionType;
case OPERATOR.COMPARE:
//return ExpressionType;
case OPERATOR.DEFAULT:
//return ExpressionType;
break;
// CS3
case OPERATOR.LAMBDA:
return(ExpressionType.Lambda);
default:
break;
}
DebugUtil.Assert(false);
return((ExpressionType)(-1));
}
/// <summary>
/// Provides the image of a given operator
/// </summary>
/// <param name="op"></param>
/// <returns></returns>
public static string[] Images(OPERATOR[] ops)
{
string[] retVal = new string[ops.Length];
for (int i = 0; i < ops.Length; i++)
{
retVal[i] = Image(ops[i]);
}
return retVal;
}
/// <summary>
/// Provides the image of a given operator
/// </summary>
/// <param name="op"></param>
/// <returns></returns>
public static string Image(OPERATOR op)
{
string retVal = null;
for (int i = 0; i < Operators.Length; i++)
{
if (op == Operators[i])
{
retVal = OperatorsImages[i];
break;
}
}
return retVal;
}
public UnaryExp(Exp a, OPERATOR op)
{
_ex1 = new BinaryExp(new NumericConstant(0), a, _op);
}
/// <summary>
///
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <param name="op"></param>
public BinaryExp(Exp a, Exp b, OPERATOR op)
{
_ex1 = a;
_ex2 = b;
_op = op;
}
public void InsertOp(OPERATOR op)
{
}
/// <summary>
///
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <param name="op"></param>
public UnaryExp(Exp a, OPERATOR op)
{
_ex1 = a;
_op = op;
}
public JsonResult CrudOperator(OPERATOR opr, string type)
{
return(Json(ppicdb.CrudOperator(opr, type), JsonRequestBehavior.AllowGet));
}
