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"); }