public static All Convert(this LogicalOp op)
{
switch (op)
{
case LogicalOp.Clear:
return(All.Clear);
case LogicalOp.And:
return(All.And);
case LogicalOp.AndReverse:
return(All.AndReverse);
case LogicalOp.Copy:
return(All.Copy);
case LogicalOp.AndInverted:
return(All.AndInverted);
case LogicalOp.Noop:
return(All.Noop);
case LogicalOp.Xor:
return(All.Xor);
case LogicalOp.Or:
return(All.Or);
case LogicalOp.Nor:
return(All.Nor);
case LogicalOp.Equiv:
return(All.Equiv);
case LogicalOp.Invert:
return(All.Invert);
case LogicalOp.OrReverse:
return(All.OrReverse);
case LogicalOp.CopyInverted:
return(All.CopyInverted);
case LogicalOp.OrInverted:
return(All.OrInverted);
case LogicalOp.Nand:
return(All.Nand);
case LogicalOp.Set:
return(All.Set);
}
Logger.PrintDebug(LogClass.Gpu, $"Invalid {nameof(LogicalOp)} enum value: {op}.");
return(All.Never);
}
public void FalseLt()
{
var firstop = new IntegerLiteral("2", 0);
var secondop = new IntegerLiteral("1", 0);
var lt = new LogicalOp("<", firstop, secondop, 0);
var assert = new ExpressionStatement("assert", lt, 0);
program.Add(assert);
Assert.Throws<MiniPLAssertionFailed>(() => interpreter.Run(new Program(program)));
}
internal TriggerCondition(BindingBase binding, LogicalOp logicalOp, object value, string sourceName)
{
this.Property = null;
this.Binding = binding;
this.LogicalOp = logicalOp;
this.Value = value;
this.SourceName = sourceName;
this.SourceChildIndex = 0;
this.BindingValueCache = new BindingValueCache(null, null);
}
// Token: 0x0600095F RID: 2399 RVA: 0x00020DCE File Offset: 0x0001EFCE
internal TriggerCondition(BindingBase binding, LogicalOp logicalOp, object value, string sourceName)
{
this.Property = null;
this.Binding = binding;
this.LogicalOp = logicalOp;
this.Value = value;
this.SourceName = sourceName;
this.SourceChildIndex = 0;
this.BindingValueCache = new BindingValueCache(null, null);
}
public void BoolEquals()
{
var boolean = new LogicalOp("=", new IntegerLiteral("4", 0), new IntegerLiteral("5", 0), 0);
var equals = new LogicalOp("=", boolean, boolean, 0);
var assignment = new Assignment(result, equals, 0);
program.Add(assignment);
interpreter.Run(new Program(program));
Assert.That(interpreter.Valuetable[symboltable.resolve("result")], Is.EqualTo(true));
}
private static Word LogicalOperation(
LogicalOp op, Word word1, Word word2, out Boolean overflow)
{
UInt16 ui16Val1 = word1.GetAsUnsigned();
UInt16 ui16Val2 = word2.GetAsUnsigned();
Int32 i32Val = op(ui16Val1, ui16Val2);
UInt16 ui16Result = NumberUtils.ToUInt16(i32Val);
overflow = NumberUtils.CheckUInt16Overflow(i32Val);
return(new Word(ui16Result));
}
public void SetLogicOpState(bool enable, LogicalOp op)
{
if (enable)
{
GL.Enable(EnableCap.ColorLogicOp);
GL.LogicOp((LogicOp)op.Convert());
}
else
{
GL.Disable(EnableCap.ColorLogicOp);
}
}
// ReSharper restore DoNotCallOverridableMethodsInConstructor
/// <summary>
///
/// </summary>
/// <param name="logicalOp"></param>
/// <param name="criteria"></param>
public Criteria(LogicalOp logicalOp, Criteria criteria)
{
if (logicalOp == LogicalOp.And)
{
throw new ArgumentException("And is not a valid Logical Operator for a Unary Criteria");
}
if (logicalOp == LogicalOp.Or)
{
throw new ArgumentException("Or is not a valid Logical Operator for a Unary Criteria");
}
LogicalOperator = logicalOp;
RightCriteria = criteria;
}
public void FalseAnd()
{
var falseboolean = new LogicalOp("=", new IntegerLiteral("4", 0), new IntegerLiteral("5", 0), 0);
var trueboolean = new LogicalOp("=", new IntegerLiteral("4", 0), new IntegerLiteral("5", 0), 0);
var and1 = new LogicalOp("&", falseboolean, trueboolean, 0);
var and2 = new LogicalOp("&", falseboolean, falseboolean, 0);
var assignment1 = new Assignment(result, and1, 0);
program.Add(assignment1);
var result2 = new VariableDeclaration("result2", "bool", 0);
symboltable.define(new Symbol("result2", "bool"));
var assignment2 = new Assignment(result2, and2, 0);
program.Add(assignment2);
interpreter.Run(new Program(program));
Assert.That(interpreter.Valuetable[symboltable.resolve("result")], Is.EqualTo(false));
Assert.That(interpreter.Valuetable[symboltable.resolve("result2")], Is.EqualTo(false));
}
private void Emit(LogicalOp value)
{
code.Append('(');
Emit(ThrowIfNull(value.Left));
switch (value.Op)
{
case LogicalOp.Types.Op.And: code.Append("&&"); break;
case LogicalOp.Types.Op.Or: code.Append("||"); break;
default: code.Append("&&"); break;
}
Emit(ThrowIfNull(value.Right));
code.Append(')');
}
public override void Visit(LogicalOp node)
{
ulong left = thread.Pop().Read().GetAsInt().Value;
ulong right = 0;
if (node.Operator != LogicalOp.Op.Not)
{
right = thread.Pop().Read().GetAsInt().Value;
}
switch (node.Operator)
{
case LogicalOp.Op.Less:
PushInteger(left < right ? 1u : 0u);
break;
case LogicalOp.Op.LessEq:
PushInteger(left <= right ? 1u : 0u);
break;
case LogicalOp.Op.Equal:
PushInteger(left == right ? 1u : 0u);
break;
case LogicalOp.Op.Greater:
PushInteger(left > right ? 1u : 0u);
break;
case LogicalOp.Op.GreaterEq:
PushInteger(left >= right ? 1u : 0u);
break;
case LogicalOp.Op.And:
PushInteger(left != 0 && right != 0 ? 1u : 0u);
break;
case LogicalOp.Op.Or:
PushInteger(left != 0 || right != 0 ? 1u : 0u);
break;
case LogicalOp.Op.Not:
PushInteger(left == 0 ? 1u : 0u);
break;
}
}
public static IEnumerable <byte> ExecuteLogicalOp(LogicalOp op, IEnumerable <byte> rs1, int immediate, Architecture architecture)
{
byte[] buffer;
if (architecture == Architecture.Rv32I)
{
buffer = new byte[4];
}
else
{
buffer = new byte[8];
}
var immediateBytes = BitConverter.GetBytes(immediate);
var immediateBuffer = new byte[buffer.Length];
Array.Copy(immediateBytes, 0, immediateBuffer, 0, immediateBytes.Length);
//for (int )
for (int index = 0; index < buffer.Length; index++)
{
switch (op)
{
case LogicalOp.Add:
buffer[index] = Convert.ToByte(rs1.ElementAt(index) & immediateBuffer.ElementAt(index));
break;
case LogicalOp.Or:
buffer[index] = Convert.ToByte(rs1.ElementAt(index) | immediateBuffer.ElementAt(index));
break;
case LogicalOp.Xor:
buffer[index] = Convert.ToByte(rs1.ElementAt(index) ^ immediateBuffer.ElementAt(index));
break;
case LogicalOp.BitwiseInversion:
var value = rs1.ElementAt(index);
var complement = ~value;
buffer[index] = Convert.ToByte(complement & 0xFF);
break;
}
}
return(buffer);
}
private void button1_Click(object sender, EventArgs e)
{
string s = textBox2.Text;
switch (s)
{
case "&&":
Exp = new LogicalOp(Exp1.GetExp(), Exp2.GetExp(), 1);
break;
case "||":
Exp = new LogicalOp(Exp1.GetExp(), Exp2.GetExp(), 2);
break;
default: //any other case will be => !(exp1)
Exp = new LogicalOp(Exp1.GetExp(), Exp2.GetExp(), 3);
break;
}
}
public BuildQueryDTO(string searchBase, LdapScope searchScope, LogicalOp op, List <FilterDTO> condList,
string[] attrToReturn, int attrOnly, IntPtr timeOut, int sizeLimit)
{
this.SearchBase = searchBase;
this.SearchScope = searchScope;
this.AttrToReturn = attrToReturn;
this.AttrOnly = attrOnly;
this.TimeOut = timeOut;
this.SizeLimit = sizeLimit;
this.Operator = op;
this.CondList = condList;
}
public void FailedAssert()
{
var boolean = new LogicalOp("=", new IntegerLiteral("4", 0), new IntegerLiteral("5", 0), 0);
var assertion = new ExpressionStatement("assert", boolean, 0);
program.Add(assertion);
Assert.Throws<MiniPLAssertionFailed>(() => interpreter.Run(new Program(program)));
}
public SearchQueryBuilder(LogicalOp op = LogicalOp.None)
: base(null, op)
{
}
public void TrueAnd()
{
var trueboolean = new LogicalOp("=", new IntegerLiteral("4", 0), new IntegerLiteral("4", 0), 0);
var and = new LogicalOp("&", trueboolean, trueboolean, 0);
var assignment = new Assignment(result, and, 0);
program.Add(assignment);
interpreter.Run(new Program(program));
Assert.That(interpreter.Valuetable[symboltable.resolve("result")], Is.EqualTo(true));
}
public static BasicFilterBase ToBasicFilter(this IList <FilterLine> lines)
{
if (lines == null)
{
throw new ArgumentNullException("lines");
}
if (lines.Count == 0)
{
return(null);
}
bool inParens = false;
// http://en.wikipedia.org/wiki/Shunting_yard_algorithm
// http://en.wikipedia.org/wiki/Reverse_Polish_Notation
List <BasicFilter> filters = new List <BasicFilter>(lines.Count);
List <int> rpnOutput = new List <int>(lines.Count * 2); // will contain negative or indexes of items
Stack <int> rpnStack = new Stack <int>(lines.Count * 2);
int intLeftParen = -1;
int intAnd = -2;
int intOr = -3;
int index = 0;
foreach (FilterLine line in lines)
{
if (inParens &&
(line.RightParen || line.LeftParen))
{
while (true)
{
var token = rpnStack.Pop();
if (token == intLeftParen)
{
break;
}
rpnOutput.Add(token);
}
inParens = false;
}
if (index > 0)
{
var token = line.OR ? intOr : intAnd;
while (true)
{
if (rpnStack.Count == 0)
{
break;
}
var topToken = rpnStack.Peek();
if (topToken < intLeftParen &&
token <= topToken)
{
rpnOutput.Add(rpnStack.Pop());
}
else
{
break;
}
}
rpnStack.Push(token);
}
if (line.LeftParen)
{
rpnStack.Push(intLeftParen);
}
rpnOutput.Add(index);
index++;
}
if (inParens)
{
while (true)
{
var token = rpnStack.Pop();
if (token == intLeftParen)
{
break;
}
rpnOutput.Add(token);
}
}
while (rpnStack.Count > 0)
{
var token = rpnStack.Pop();
if (token == intLeftParen)
{
throw new InvalidOperationException("mismatched leftParen in RPN stack!");
}
rpnOutput.Add(token);
}
var evaluationStack = new Stack <BasicFilterBase>();
foreach (var input in rpnOutput)
{
if (input >= 0)
{
BasicFilter item = new BasicFilter();
var line = lines[input];
item.Field = line.Field;
item.Operator = line.Op;
item.Value = line.Value;
item.Values = line.Values;
evaluationStack.Push(item);
}
else
{
if (evaluationStack.Count < 2)
{
throw new InvalidOperationException("RPN evaluation stack has less than two items!");
}
LogicalOp op = input == intAnd ? LogicalOp.And : LogicalOp.Or;
var right = evaluationStack.Pop();
var left = evaluationStack.Pop();
BasicFilterBase result = left.Merge(op, right);
evaluationStack.Push(result);
}
}
if (evaluationStack.Count > 1)
{
throw new InvalidOperationException("RPN evaluation stack has more than one item!");
}
return(evaluationStack.Pop());
}
public LogExpr(LogicalOp oper, ILogicalFormula f) : base(oper.ToString(), f) => op = oper;
public void LogicalOpLt()
{
var integer = new IntegerLiteral("1", 0);
var lt = new LogicalOp("<", integer, integer, 0);
var assert = new ExpressionStatement("assert", lt, 0);
statementlist.Add(assert);
var parsetree = new Program(statementlist);
Assert.DoesNotThrow(() => symbolTableBuilder.BuildSymbolTableAndTypeCheck(parsetree));
}
public void PrintBool()
{
var integer1 = new IntegerLiteral("1", 0);
var integer2 = new IntegerLiteral("2", 0);
var equal = new LogicalOp("=", integer1, integer2, 0);
var print = new ExpressionStatement("print", equal, 0);
statementlist.Add(print);
var parsetree = new Program(statementlist);
Assert.Throws<SemanticError>(() => symbolTableBuilder.BuildSymbolTableAndTypeCheck(parsetree));
}
// Token: 0x0600095E RID: 2398 RVA: 0x00020DBE File Offset: 0x0001EFBE
internal TriggerCondition(BindingBase binding, LogicalOp logicalOp, object value)
{
this = new TriggerCondition(binding, logicalOp, value, "~Self");
}
public void Set(bool enable, LogicalOp op)
{
_enable = enable;
_op = op;
}
public void SetLogicOpState(bool enable, LogicalOp op)
{
_renderer.New <SetLogicOpStateCommand>().Set(enable, op);
_renderer.QueueCommand();
}
public void StringArgumentToLt()
{
var somestring = new StringLiteral("foo", 0);
var lt = new LogicalOp("<", somestring, somestring, 0);
var assert = new ExpressionStatement("assert", lt, 0);
statementlist.Add(assert);
var parsetree = new Program(statementlist);
Assert.Throws<SemanticError>(() => symbolTableBuilder.BuildSymbolTableAndTypeCheck(parsetree));
}
public void NonBooleanArgumentsToAnd()
{
var integer = new IntegerLiteral("5", 0);
var equal = new LogicalOp("=", integer, integer, 0);
var and = new LogicalOp("&", equal, integer, 0);
var assert = new ExpressionStatement("assert", and, 0);
statementlist.Add(assert);
var parsetree = new Program(statementlist);
Assert.Throws<SemanticError>(() => symbolTableBuilder.BuildSymbolTableAndTypeCheck(parsetree));
}
public void UnaryNot()
{
var integer = new IntegerLiteral("42", 0);
var and = new LogicalOp("=", integer, integer, 0);
var not = new UnaryNot(and, 0);
var assert = new ExpressionStatement("assert", and, 0);
statementlist.Add(assert);
var parsetree = new Program(statementlist);
Assert.DoesNotThrow(() => symbolTableBuilder.BuildSymbolTableAndTypeCheck(parsetree));
}
public static BasicFilterBase Merge(this BasicFilterBase left, LogicalOp op, BasicFilterBase right)
{
var leftCriteria = left as BasicFilter;
var rightCriteria = right as BasicFilter;
var leftGroup = left as BasicFilterGroup;
var rightGroup = right as BasicFilterGroup;
if (left == null ||
right == null)
{
return(left ?? right);
}
else if (leftCriteria != null &&
rightCriteria != null)
{
return(new BasicFilterGroup(op, leftCriteria, rightCriteria));
}
else if (leftCriteria != null)
{
if (op == rightGroup.Operator)
{
rightGroup.Nodes.Insert(0, leftCriteria);
return(rightGroup);
}
else
{
return(new BasicFilterGroup(op, leftCriteria, rightGroup));
}
}
else if (rightCriteria != null)
{
if (leftGroup.Operator == op)
{
leftGroup.Nodes.Add(rightCriteria);
return(leftGroup);
}
else
{
return(new BasicFilterGroup(op, leftGroup, rightCriteria));
}
}
else
{
if (leftGroup.Operator == rightGroup.Operator &&
op == leftGroup.Operator)
{
leftGroup.Nodes.AddRange(rightGroup.Nodes);
return(leftGroup);
}
else if (leftGroup.Operator == op)
{
leftGroup.Nodes.Add(rightGroup);
return(leftGroup);
}
else if (rightGroup.Operator == op)
{
rightGroup.Nodes.Insert(0, leftGroup);
return(rightGroup);
}
else
{
return(new BasicFilterGroup(op, leftGroup, rightGroup));
}
}
}
public void SetLogicOpState(bool enable, LogicalOp op)
{
LogicOp = op;
LogicOpEnable = enable;
}
public LogExpr(ILogicalFormula f1, LogicalOp oper, ILogicalFormula f2) : base(f1, oper.ToString(), f2)
{
op = oper;
}
public void TrueLt()
{
var firstop = new IntegerLiteral("1", 0);
var secondop = new IntegerLiteral("2", 0);
var lt = new LogicalOp("<", firstop, secondop, 0);
var assert = new ExpressionStatement("assert", lt, 0);
program.Add(assert);
Assert.DoesNotThrow(() => interpreter.Run(new Program(program)));
}
/// <summary>
/// Creates a composite criteria by logically joining two other criteria.
/// </summary>
/// <param name="leftCriteria">The left criteria (can be a whole tree structure)</param>
/// <param name="logicalOp">The logical operator to use to join the left criteria tree with the right</param>
/// <param name="rightCriteria">The right criteria (can be a whole tree structure)</param>
public Criteria(Criteria leftCriteria, LogicalOp logicalOp, Criteria rightCriteria)
{
LeftCriteria = leftCriteria;
LogicalOperator = logicalOp;
RightCriteria = rightCriteria;
}
public void LogicalOpEquals()
{
var integer = new IntegerLiteral("1", 0);
var stringlit = new StringLiteral("\"foobar\"", 0);
var equal = new LogicalOp("=", integer, stringlit, 0);
var assert = new ExpressionStatement("assert", equal, 0);
statementlist.Add(assert);
var parsetree = new Program(statementlist);
Assert.Throws<SemanticError>(() => symbolTableBuilder.BuildSymbolTableAndTypeCheck(parsetree));
}
internal TriggerCondition(DependencyProperty dp, LogicalOp logicalOp, object value, string sourceName)
{
Property = dp;
Binding = null;
LogicalOp = logicalOp;
Value = value;
SourceName = sourceName;
SourceChildIndex = 0;
BindingValueCache = new BindingValueCache(null, null);
}
internal TriggerCondition(BindingBase binding, LogicalOp logicalOp, object value) :
this(binding, logicalOp, value, StyleHelper.SelfName)
{
// Call Forwarded
}
public void StringEquals()
{
var equals = new LogicalOp("=", new StringLiteral("foo", 0), new StringLiteral("foo", 0), 0);
var assignment = new Assignment(result, equals, 0);
program.Add(assignment);
interpreter.Run(new Program(program));
Assert.That(interpreter.Valuetable[symboltable.resolve("result")], Is.EqualTo(true));
}
internal TriggerCondition(BindingBase binding, LogicalOp logicalOp, object value)
: this(binding, logicalOp, value, "~Self")
{
}
public BasicFilterGroup(LogicalOp op)
{
Operator = op;
Nodes = new List <BasicFilterBase>();
}
public void SuccessfulAssert()
{
var boolean = new LogicalOp("=", new IntegerLiteral("5", 0), new IntegerLiteral("5", 0), 0);
var assertion = new ExpressionStatement("assert", boolean, 0);
program.Add(assertion);
Assert.DoesNotThrow(() => interpreter.Run(new Program(program)));
}
public BasicFilterGroup(LogicalOp op, params BasicFilterBase[] nodes)
{
Operator = op;
Nodes = new List <BasicFilterBase>();
Nodes.AddRange(nodes);
}
public void visit(LogicalOp node)
{
string optype1 = operandtypes.Pop();
string optype2 = operandtypes.Pop();
switch (node.OpSymbol)
{
case "&":
if (optype1 != "bool" || optype2 != "bool")
throw new SemanticError("Non-boolean arguments to logical and operator \"&\"" +
" on row " + node.Row + ".");
break;
case "=":
if (optype1 != optype2)
throw new SemanticError("Logical operator \"=\" cannot be applied to types \"" +
optype1 + "\" and \"" + optype2 + "\" on row " + node.Row + ".");
break;
case "<":
if (optype1 != "int" || optype2 != "int")
throw new SemanticError("Non-integer arguments to lt operator \"<\" on row " +
node.Row + ".");
break;
}
operandtypes.Push("bool");
}
