public GreaterThanExpression(Expression left, Expression right) { Operands.Add(left); Operands.Add(right); //TODO validate ParamType ReturnType = typeof(bool); }
public JoinExpression(Expression src, Expression dest, Expression onCriteria) { Operands.Add(src); Operands.Add(dest); Operands.Add(onCriteria); //No Return Type ,Can't Excute! }
public DummyInstructionPattern(DummyOpCode opCode, params Pattern <object>[] operands) { OpCode = new LiteralPattern <DummyOpCode>(opCode); foreach (var operand in operands) { Operands.Add(operand); } }
public DummyInstructionPattern(Pattern <DummyOpCode> opCode, params Pattern <object>[] operands) { OpCode = opCode; foreach (var operand in operands) { Operands.Add(operand); } }
public MetaTableExpression(NewExpression newExpression, IList <SqlExpression> values) : base(SqlExpressionType.MetaTable, newExpression.Type) { SourceExpression = newExpression; Values = values; foreach (var v in Values) { Operands.Add(v); } }
private void Operation(string operation) { if (Number != "0") { Operands.Add(Number); Operands.Add(operation); Number = "0"; AllOperands = string.Join(" ", Operands); } }
//-------------------------------------------------------------------------------------------------- #endregion #region Operands public bool AddOperand(IShapeOperand operandShape) { Operands.Add(operandShape); operandShape.AddDependent(this); RaisePropertyChanged("ChildCount"); Invalidate(); return(true); }
public AndExpression(Expression expression , IList <Expression> rightExpressions) { if (rightExpressions == null || !rightExpressions.Any()) { throw new ArgumentException("And Expression Create Arg Error!", "rightExpressions"); } Operands.Add(expression); Operands.AddRange(rightExpressions); ReturnType = typeof(bool); }
public void ParseEquationAdv(string equation) { string eq = equation.Replace("(", "( "); eq = eq.Replace(")", " )"); var parts = eq.Split(' ', StringSplitOptions.RemoveEmptyEntries); foreach (var part in parts) { if (int.TryParse(part, out int ival)) { // number push Operands.Add(part); } else { if (part == "+" || part == "*") { if (Operators.Count > 0 && Operators.Peek() != "(") { if (part == "*" && Operators.Peek() == "+") { Operands.Add(Operators.Pop()); } else if (part == Operators.Peek()) { Operands.Add(Operators.Pop()); } } Operators.Push(part); } else if (part == "(") { Operators.Push(part); } else if (part == ")") { // find the match string op; while (Operators.Count > 0 && (op = Operators.Pop()) != "(") { Operands.Add(op); } } } } while (Operators.Count > 0) { Operands.Add(Operators.Pop()); } }
public SearchOperator(Operator op, List <ISearch> operands) { if (op == Operator.Invalid) { op = Operator.And; // set to be the default search type. } Op = op; foreach (var item in operands) { Operands.Add(item); } }
private bool ReadTwoOperands(byte[] buffer) { int op1 = GetByte(buffer, PC++); int op2 = GetByte(buffer, PC++); Operands.Add((Opcode & 0x040) == 0 ? new Operand(OperandType.SmallConst, op1) : new Operand(OperandType.Variable, op1)); Operands.Add((Opcode & 0x020) == 0 ? new Operand(OperandType.SmallConst, op2) : new Operand(OperandType.Variable, op2)); return(false); }
public void AddOperand(Node operand) { if (Type == ConnectorType.IMPLY && Operands.Count > 0) { throw new Exception("An imply connection must only have one operand"); } Operands.Add(operand); if (IsRoot || Type == ConnectorType.IMPLY || operand.OperandParents.Contains(this)) { return; } operand.OperandParents.Add(this); }
public MemberExpress(Expression parameter, string memberName, Type ofType = null) { if (ofType != null) { ReturnType = ofType; } else { ReturnType = typeof(object); } Operands.Add(parameter); MemberName = memberName; }
// SortEquation Method - Sorts each subequation's character's into its respective list public void SortEquation() { foreach (var c in subEquation.Split(' ')) { if (HasNumber(c) || IsX(c)) { Operands.Add(c); } else if (IsOperator(c)) { Operators.Add(c); } } }
internal override unsafe void ParseDetails(CsDetailBase *detail) { var ad = (CsArm64Detail *)&detail->ArchSpecificPlaceholder; Condition = (ConditionCode)ad->CC; var ops = (CsArm64Op *)&ad->OpsPlaceholder; for (var i = 0; i < ad->OpCount; ++i) { var op = ops[i]; switch (op.OpType) { case 1: Operands.Add(new RegOperand(*(Reg *)&op.Placeholder0)); break; case 2: Operands.Add(new ImmOperand(*(ulong *)&op.Placeholder0)); break; case 3: Operands.Add(new MemOperand( *(Reg *)&op.Placeholder0, *(Reg *)&op.Placeholder1, *(int *)&op.Placeholder2 )); break; case 4: Operands.Add(new FpOperand(*(double *)&op.Placeholder0)); break; case 65: case 66: case 67: case 68: case 69: Operands.Add(null); break; case 70: Operands.Add(new BarrierOperand(*(Barrier *)&op.Placeholder0)); break; default: throw new NotImplementedException($"Operand type {op.OpType} not supported"); } } }
private void ParseOperands() { if (Instruction.Operands.Count == 0) { return; } // Word 0 describes this instruction so we can ignore it int currentWord = 1; int currentOperand = 0; var varyingOperandValues = new List <object> (); var varyingWordStart = 0; Operand varyingOperand = null; for (; currentWord < Words.Count;) { var operand = Instruction.Operands [currentOperand]; operand.Type.ReadValue(Words.Skip(currentWord).ToList(), out object value, out int wordsUsed); if (operand.Quantifier == OperandQuantifier.Varying) { varyingOperandValues.Add(value); varyingWordStart = currentWord; varyingOperand = operand; } else { Operands.Add(new ParsedOperand(Words.Skip(currentWord).Take(wordsUsed).ToList(), value, operand)); } currentWord += wordsUsed; if (operand.Quantifier != OperandQuantifier.Varying) { ++currentOperand; } } if (varyingOperand != null) { Operands.Add(new ParsedOperand(Words.Skip(currentWord).ToList(), new VaryingOperandValue(varyingOperandValues), varyingOperand)); } }
private void ParseOperands() { if (Instruction.Operands.Count == 0) { return; } // Word 0 describes this instruction so we can ignore it int currentWord = 1; int currentOperand = 0; List <object> varyingOperandValues = new List <object>(); int varyingWordStart = 0; Operand varyingOperand = null; while (currentWord < Words.Count) { Operand operand = Instruction.Operands[currentOperand]; operand.Type.ReadValue(Words, currentWord, out object value, out int wordsUsed); if (operand.Quantifier == OperandQuantifier.Varying) { varyingOperandValues.Add(value); varyingWordStart = currentWord; varyingOperand = operand; } else { int wordCount = Math.Min(Words.Count - currentWord, wordsUsed); ParsedOperand parsedOperand = new ParsedOperand(Words, currentWord, wordCount, value, operand); Operands.Add(parsedOperand); } currentWord += wordsUsed; if (operand.Quantifier != OperandQuantifier.Varying) { ++currentOperand; } } if (varyingOperand != null) { VaryingOperandValue varOperantValue = new VaryingOperandValue(varyingOperandValues); ParsedOperand parsedOperand = new ParsedOperand(Words, currentWord, Words.Count - currentWord, varOperantValue, varyingOperand); Operands.Add(parsedOperand); } }
public ContainsFunction(string propertyName, OperandValue operandValue) { OperatorType = FunctionOperatorType.Custom; Operands.Clear(); Operands.Add(new OperandValue(ContainsFunctionName)); Operands.Add(new OperandProperty(propertyName)); // string[] strings = operandValue.Value.ToString().Split(' '); // string value = ""; // for (int i = 0; i < strings.Length; i++) // { // strings[i] = strings[i].Trim() + " NEAR "; // value += strings[i]; // } // value = value.Substring(0, value.LastIndexOf(" NEAR ")); // operandValue.Value=value; operandValue.Value = "\"" + operandValue.Value + "\""; Operands.Add(operandValue); }
private bool ReadVariableOperands(byte[] buffer) { int types = GetByte(buffer, PC++); var value = 0; for (var j = 6; j >= 0; j -= 2) { var t = (OperandType)(((uint)types >> j) & (uint)OperandType.Omitted); if (t == OperandType.Omitted) { continue; } switch (t) { case OperandType.LargeConst: value = GetWord(buffer, PC); PC += 2; break; case OperandType.SmallConst: case OperandType.Variable: value = GetByte(buffer, PC++); break; case OperandType.Omitted: break; default: throw new ArgumentOutOfRangeException(); } Operands.Add(new Operand(t, value)); } return(false); }
public Instruction([NotNull] string name, [NotNull] AsmExpr operand1, [NotNull] AsmExpr operand2, [NotNull] AsmExpr operand3, [NotNull] AsmExpr operand4) : this(name, operand1, operand2, operand3) { Operands.Add(operand4); }
public OrderByExpression(bool descending, Expression columnExpression) : base(SqlExpressionType.OrderBy, columnExpression.Type) { Descending = descending; ColumnExpression = columnExpression; Operands.Add(ColumnExpression); }
public bool Read(int pc, byte[] buffer) { PC = pc; if (Opcode == 0xBE) { Type = InstructionType.Ext; // Error: Unsupported Logger.Error("Opcode 0xBE unsupported"); } else if (Opcode >= 0xC0) { // Form: Variable if ((Opcode & 0x20) == 0x20) { Type = InstructionType.Var; // VAR count // Logger.Debug($"{Opcode:X2} Variable : VAR count"); } else { Type = InstructionType.TwoOp; // 2OP count // Logger.Debug($"{Opcode:X2} Variable : 2OP count"); } ReadVariableOperands(buffer); Opcode = Opcode & 0x1f; } else if (Opcode >= 0x80) { // Form: Short var operandType = (OperandType)((uint)(Opcode & 0x30) >> 4); if (operandType == OperandType.Omitted) { Type = InstructionType.ZeroOp; // 0OP count // Logger.Debug($"{Opcode:X2} Short : 0OP count"); } else { Type = InstructionType.OneOp; // 1OP count // Logger.Debug($"{Opcode:X2} Short : 1OP count"); if (operandType == OperandType.LargeConst) { Operands.Add(new Operand(operandType, GetWord(buffer, PC))); PC += 2; } else { Operands.Add(new Operand(operandType, GetByte(buffer, PC++))); } } Opcode = Opcode & 0xf; } else { Type = InstructionType.TwoOp; // Form: Long // 2OP Count // Logger.Debug($"{Opcode:X2} Long : 2OP count"); var b = ReadTwoOperands(buffer); Opcode = Opcode & 0x1f; } return(true); }
public YearFunction() { OperatorType = FunctionOperatorType.Custom; Operands.Clear(); Operands.Add(new OperandValue(YearFunctionName)); }
public YearFunction(string propertyName, int year) : this(propertyName) { Operands.Add(new OperandValue(year)); }
public YearFunction(string propertyName) : this() { Operands.Add(new OperandProperty(propertyName)); }
public LineInfo(string RawLine, int SourceFileLine, Dictionary <string, LineInfo> SymbolTable) { string text = this.RawLine = RemoveSpaces(RawLine); this.SourceFileLine = SourceFileLine; this.SymbolTable = SymbolTable; Label = String.Empty; Mnemonic = String.Empty; if (text.Contains(";")) { Comment = text.Substring(text.IndexOf(';') + 1); text = text.Substring(0, text.IndexOf(';')).TrimEnd(); } else { Comment = String.Empty; } string[] cols = text.Split('\t').Select(c => c.Trim()).ToArray(); if (cols.Length == 0) { return; } // LABEL string label = cols[0]; if (label.Length == 0) { // Nothing to do } else if (ValidateLabel(ref label)) { Label = label; } else { SetError("Invalid Label: " + label); return; } // MNEMONIC if (cols.Length > 1) { string mnemonic = cols[1]; if (mnemonic.Length == 0) { } else if (ValidateMnemonic(ref mnemonic)) { Mnemonic = mnemonic; } else { SetError("Invalid Mnemonic: " + mnemonic); return; } } // OPERANDS if (cols.Length > 2) { string[] ops = GetCSV(cols[2], 1000); foreach (var o in ops) { Operands.Add(new Operand(this, o.Trim())); } } if (IsMultiline) { switch (Mnemonic) { case "DEFB": case "DEFW": case "DEFM": break; default: SetError("Unexpected number of operands"); break; } } else { switch (Mnemonic) { case "ADD": case "ADC": case "SUB": case "SBC": case "AND": case "OR": case "XOR": case "CP": // Change lines like "ADD A, B" to "ADD B" TrimAccumlatorOperand(0); break; } } }
public StartIndexOffsetExpression(bool startsAtOne, Expression startExpression) : base(SqlExpressionType.StartIndexOffset, typeof(int)) { this.InnerExpression = startExpression; this.StartsAtOne = startsAtOne; Operands.Add(InnerExpression); }
public Instruction([NotNull] string name, [NotNull] AsmExpr operand1) : this(name) { Operands.Add(operand1); }