public void PopulateFilterIndex(Type type, IDictionary <string, IList <QueryFilterCondition> > index) { if (Operator != and) { return; } if (Argument1 != null) { Argument1.PopulateFilterIndex(type, index); } else if (Child1 != null) { Child1.PopulateFilterIndex(type, index); } if (Argument2 != null) { Argument2.PopulateFilterIndex(type, index); } else if (Child2 != null) { Child2.PopulateFilterIndex(type, index); } }
public int CompareTo(object obj) { if (obj == null) { return(1); } var second = obj as AvailableExpression; if (second != null) { var arg1Res = Argument1.CompareTo(second.Argument1); if (arg1Res == 0) { var arg2Res = Argument2.CompareTo(second.Argument2); if (arg2Res == 0) { return(Operation.CompareTo(second.Operation)); } else { return(arg2Res); } } else { return(arg1Res); } } else { return(1); } }
public static SCode Make(Primitive2 rator, Argument1 rand0, SCode rand1) { return ((rand1 is LexicalVariable) ? Unimplemented() //PrimitiveGeneralCarCdrA0L.Make (rator, rand0, (LexicalVariable) rand1) : (rand1 is Quotation) ? PrimitiveGeneralCarCdrA1Q.Make(rator, rand0, (Quotation)rand1) : new PrimitiveGeneralCarCdrA1(rator, rand0, rand1)); }
/// <summary> /// Accept method for the input data visitor. /// </summary> /// <param name="visitor">Visitor.</param> public override void Accept(IVisitor visitor) { visitor.Visit(this); Argument1.Accept(visitor); Argument2.Accept(visitor); visitor.PostVisit(this); }
protected override INotifyExpression <TResult> ApplyParametersCore(IDictionary <string, object> parameters, IDictionary <INotifiable, INotifiable> trace) { var newArgument1 = Argument1.ApplyParameters(parameters, trace); if (newArgument1 == Argument1) { return(this); } return(new ObservableStaticLensMethodCall <T1, TResult>(Function, LensPut.ApplyNewTarget(newArgument1 as INotifyReversableValue <T1>), newArgument1)); }
public override int GetHashCode() { int hash = 0; hash += Operation.GetHashCode(); hash += Argument1.GetHashCode(); hash += Argument2.GetHashCode(); hash += Result.GetHashCode(); hash += Label.GetHashCode(); return(hash); }
public override void Execute ( PftContext context ) { Argument1.Execute(context); int mfn = (int)Argument1.Value; if (mfn > 0) { string format = context.Evaluate(Argument2); string text = context.Client.FormatRecord(format, mfn); context.Write(text); } }
/// <summary> /// Translates the instruction and sets the Code property. /// If an error is detected, Error property is set instead. /// </summary> /// <returns>A value indicating if the translation was successful</returns> public override bool Translate() { Error = null; if (!CheckArgument1()) { return(false); } Code = new ushort[2]; Code[0] = 0xD << 12; // The first word is always the same (only an OPCode). int value; Argument1.LookUpValue(Assembler, out value); Code[1] = (ushort)value; // The second word is the address of the subroutine. return(true); }
public override bool Equals(object obj) { if (obj == null) { return(false); } var second = obj as AvailableExpression; if (second == null) { return(false); } return(Argument1.Equals(second.Argument1) && Argument2.Equals(second.Argument2) && Operation.Equals(second.Operation)); }
public void WriteXML(XElement ele, ElderScrollsPlugin master) { XElement subEle; ele.TryPathTo("Type", true, out subEle); subEle.Value = Type.ToString(); ele.TryPathTo(Arg1Label, true, out subEle); if (Arg1Type == null) { subEle.Value = ((byte[])Argument1).ToHex(); } else if (Arg1Type == typeof(FormID)) { Argument1.WriteXML(subEle, master); } else if (Arg1Type.IsEnum) { subEle.Value = Argument1.ToString(); } else { throw new ArgumentException(Arg1Type.ToString() + " is not handled."); } ele.TryPathTo(Arg2Label, true, out subEle); if (Arg2Type == null) { subEle.Value = ((byte[])Argument2).ToHex(); } else if (Arg2Type == typeof(FormID)) { Argument2.WriteXML(subEle, master); } else if (Arg2Type.IsEnum) { subEle.Value = Argument2.ToString(); } else if (Arg2Type == typeof(uint)) { subEle.Value = Argument2.ToString(); } else { throw new ArgumentException(Arg2Type.ToString() + " is not handled."); } }
public override void Execute ( PftContext context ) { Argument1.Execute(context); int minLength = 1; if (Argument2 == null) { if (Argument3 == null) { minLength = 16; } } else { Argument2.Execute(context); minLength = (int)Argument2.Value; } bool useE = true; int decimalPoints = 0; if (Argument3 != null) { useE = false; Argument3.Execute(context); decimalPoints = (int)Argument3.Value; } string format = useE ? string.Format("E{0}", minLength) : string.Format("F{0}", decimalPoints); context.Write ( Argument1.Value.ToString ( format, CultureInfo.InvariantCulture ) ); }
/// <summary> /// Translates the first argument to the machine code. /// The resulting value contains the argument encoding in the right /// position within the word, and zeroes in locations intended for the /// OPCode (mnemonic) and the other argument. /// </summary> /// <returns>A value containing the translation of the argument</returns> protected ushort TranslateArgument1() { int value; Argument1.LookUpValue(Assembler, out value); // Write address to the lowest 3 bits ushort result = (ushort)value; if (Argument1.Type == ArgumentType.Indirect) { // Indirect addressing is indicated by setting the 4th lowest bit. result |= 0x8; } // Move the argument to the right position : 0000aaaa00000000 result <<= 8; return(result); }
/// <summary> /// Formats the instruction as string. /// <example> /// ADD (x), x, 2 /// </example> /// </summary> /// <returns>A string representing the instruction</returns> public override string ToString() { StringBuilder sb = new StringBuilder(); sb.Append(Mnemonic); sb.Append(' '); sb.Append(Argument1.ToString()); if (Argument2.Type != ArgumentType.None) { sb.Append(", "); sb.Append(Argument2.ToString()); } if (Argument3.Type != ArgumentType.None) { sb.Append(", "); sb.Append(Argument3.ToString()); } return(sb.ToString()); }
public void WriteBinary(ESPWriter writer) { writer.Write((uint)Type); if (Arg1Type == null) { writer.Write(Argument1); } else if (Arg1Type == typeof(FormID)) { Argument1.WriteBinary(writer); } else if (Arg1Type.IsEnum) { writer.Write((int)Argument1); } else { throw new ArgumentException(Arg1Type.ToString() + " is not handled."); } if (Arg2Type == null) { writer.Write(Argument2); } else if (Arg2Type == typeof(FormID)) { writer.Write((FormID)Argument2); } else if (Arg2Type.IsEnum) { writer.Write((int)Argument2); } else if (Arg2Type == typeof(uint)) { writer.Write(Argument2); } else { throw new ArgumentException(Arg2Type.ToString() + " is not handled."); } }
/// <summary> /// Checks if the first argument is valid. /// </summary> /// <remarks> /// The first argument of an I/O instruction must be a symbol /// present in the symbol table and its value must be between [0..7]. /// </remarks> /// <returns>A value indicating if Argument1 is valid</returns> protected bool CheckArgument1() { int value; if (!Argument1.LookUpValue(Assembler, out value)) { return(false); } if (value < 0 || value > 7) { Error = new Error(); Error.ID = 3; Error.Description = string.Format(Messages.E0003, Argument1.Text, 0, 7); Error.Line = Line; Error.Column = Argument1.Column; return(false); } return(true); }
PrimitivePlusFixnumA1A0(Primitive2 rator, Argument1 rand0, Argument0 rand1) : base(rator, rand0, rand1) { }
public static SCode Make(Primitive2 rator, Argument1 rand0, LexicalVariable rand1) { return (rand1 is Argument) ? PrimitivePlusFixnumA1A.Make (rator, rand0, (Argument) rand1) : (rand1 is LexicalVariable1) ? Unimplemented () : new PrimitivePlusFixnumA1L (rator, rand0, rand1); }
public static SCode Make(Primitive2 rator, LexicalVariable rand0, Argument1 rand1) { return new PrimitivePlusFixnumLA1 (rator, rand0, rand1); }
public static SCode Make(Primitive2 rator, Argument1 rand0, SCode rand1) { return (rand1 is LexicalVariable) ? PrimitivePlusFixnumA1L.Make (rator, rand0, (LexicalVariable) rand1) : (rand1 is Quotation) ? PrimitivePlusFixnumA1Q.Make (rator, rand0, (Quotation) rand1) : new PrimitivePlusFixnumA1 (rator, rand0, rand1); }
PCond2A0A0A1Q(PrimitiveCombination2A0A0 predicate, Argument1 consequent, Quotation alternative) : base(predicate, consequent, alternative) { this.alternativeValue = alternative.Quoted; }
public static SCode Make(Primitive2 rator, Argument1 rand0, Quotation rand1) { return new PrimitiveIsCharEqA1Q (rator, rand0, rand1); }
PrimitiveIsObjectEqQA1(Primitive2 rator, Quotation rand0, Argument1 rand1) : base(rator, rand0, rand1) { }
public static SCode Make(PrimitiveIsObjectEqQA1 predicate, SCode consequent, Argument1 alternative) { return new PCondIsObjectEqQA1SA1 (predicate, consequent, alternative); }
public static SCode Make(Primitive2 rator, Quotation rand0, Argument1 rand1) { return (new PrimitiveIsObjectEqQA1(rator, rand0, rand1)); }
public bool UseVariable(string variable) { return(Argument1.Equals(variable) || Argument2.Equals(variable)); }
public static SCode Make(PrimitiveCombination2A0L1 predicate, LexicalVariable1 consequent, Argument1 alternative) { return new PCond2A0L1L1A1 (predicate, consequent, alternative); }
// (a0 l1 l1 a1) PCond2A0L1L1A1(PrimitiveCombination2A0L1 predicate, LexicalVariable1 consequent, Argument1 alternative) : base(predicate, consequent, alternative) { }
public static SCode Make(PrimitiveCombination2A0A0 predicate, Argument1 consequent, Quotation alternative) { return new PCond2A0A0A1Q (predicate, consequent, alternative); }
public static SCode Make(Primitive2 rator, Argument1 rand0, Quotation rand1) { return new PrimitivePlusFixnumA1Q (rator, rand0, (Quotation) rand1); }
protected PrimitiveIsObjectEqA1Q(Primitive2 rator, Argument1 rand0, Quotation rand1) : base(rator, rand0, rand1) { this.rand1Value = rand1.Quoted; }
public static SCode Make(Primitive2 rator, Argument rand0, Argument1 rand1) { return new PrimitivePlusFixnumAA1 (rator, rand0, rand1); }
public static SCode Make(Primitive2 rator, Quotation rand0, Argument1 rand1) { return new PrimitiveIsFixnumEqualQA1 (rator, rand0, rand1); }
public void ReadXML(XElement ele, ElderScrollsPlugin master) { XElement subEle; if (ele.TryPathTo("Type", false, out subEle)) { Type = subEle.ToEnum <FunctionType>(); } TypeStringArgData data; if (Metadata.TryGetValue(Type, out data)) { Arg1Label = data.Arg1Label; Arg2Label = data.Arg2Label; Arg1Type = data.Arg1Type; Arg2Type = data.Arg2Type; if (ele.TryPathTo(Arg1Label, false, out subEle)) { if (Arg1Type == null) { Argument1 = subEle.ToBytes(); } else if (Arg1Type == typeof(FormID)) { Argument1 = new FormID(); Argument1.ReadXML(subEle, master); } else if (Arg1Type == typeof(VATSValue)) { Argument1 = subEle.ToEnum <VATSValue>(); TypeStringArgData tempData; if (VATSMetadata.TryGetValue(Argument1, out tempData)) { Arg2Type = tempData.Arg1Type; Arg2Label = tempData.Arg1Label; } else { throw new ArgumentException("VATSValue " + Argument1.ToString() + " is not handled."); } } else if (Arg1Type.IsEnum) { Argument1 = Enum.Parse(Arg1Type, subEle.Value); } else { throw new ArgumentException(Arg1Type.ToString() + " is not handled."); } } if (ele.TryPathTo(Arg2Label, false, out subEle)) { if (Arg2Type == null) { Argument2 = subEle.ToBytes(); } else if (Arg2Type == typeof(FormID)) { Argument2 = new FormID(); Argument2.ReadXML(subEle, master); } else if (Arg2Type.IsEnum) { Argument2 = Enum.Parse(Arg2Type, subEle.Value); } else if (Arg2Type == typeof(uint)) { Argument2 = subEle.ToUInt32(); } else { throw new ArgumentException(Arg2Type.ToString() + " is not handled."); } } } else { throw new Exception(Type.ToString() + " was not in the dictionary."); } }
public static SCode Make(Primitive2 rator, Argument1 rand0, Argument0 rand1) { return new PrimitiveIsFixnumEqualA1A0 (rator, rand0, rand1); }
protected PrimitiveIsCharEqA1Q(Primitive2 rator, Argument1 rand0, Quotation rand1) : base(rator, rand0, rand1) { this.rand1Value = (char) rand1.Quoted; }
public static SCode Make(Primitive2 rator, Argument0 rand0, Argument1 rand1) { throw new NotImplementedException (); //new PrimitiveIsFixnumEqualA1A1 (rator, rand0, rand1); }
protected PrimitivePlusFixnumLA1(Primitive2 rator, LexicalVariable rand0, Argument1 rand1) : base(rator, rand0, rand1) { }
PrimitiveGeneralCarCdrA0A1(Primitive2 rator, Argument0 rand0, Argument1 rand1) : base(rator, rand0, rand1) { }
protected PrimitivePlusFixnumQA1(Primitive2 rator, Quotation rand0, Argument1 rand1) : base(rator, rand0, rand1) { }
protected PrimitiveGeneralCarCdrA1(Primitive2 rator, Argument1 rand0, SCode rand1) : base(rator, rand0, rand1) { }
public static SCode Make(Primitive2 rator, Argument1 rand0, Argument rand1) { return (rand1 is Argument0) ? PrimitivePlusFixnumA1A0.Make (rator, rand0, (Argument0) rand1) : (rand1 is Argument1) ? Unimplemented() : new PrimitivePlusFixnumA1A (rator, rand0, rand1); }
protected PrimitiveGeneralCarCdrA1Q(Primitive2 rator, Argument1 rand0, Quotation rand1) : base(rator, rand0, rand1) { this.rand1Value = (int)rand1.Quoted; }
protected PrimitivePlusFixnumA1L(Primitive2 rator, Argument1 rand0, LexicalVariable rand1) : base(rator, rand0, rand1) { this.rand1Name = rand1.Name; this.rand1Depth = rand1.Depth; this.rand1Offset = rand1.Offset; }
public static SCode Make(Primitive2 rator, Argument1 rand0, SCode rand1) { return ((rand1 is Quotation) ? PrimitiveIsObjectEqA1Q.Make(rator, rand0, (Quotation)rand1) : Unimplemented()); }
protected PrimitivePlusFixnumA1Q(Primitive2 rator, Argument1 rand0, Quotation rand1) : base(rator, rand0, rand1) { this.rand1Value = (int) rand1.Quoted; }
internal static SCode Make(PrimitiveIsComplexA1 predicate, SCode consequent, Argument1 alternative) { return new PCondIsComplexA1SA1 (predicate, consequent, alternative); }
protected PrimitivePlusFixnumAA1(Primitive2 rator, Argument rand0, Argument1 rand1) : base(rator, rand0, rand1) { }
protected PrimitiveIsObjectEqA1(Primitive2 rator, Argument1 rand0, SCode rand1) : base(rator, rand0, rand1) { }
PCondIsObjectEqQA1SA1(PrimitiveIsObjectEqQA1 predicate, SCode consequent, Argument1 alternative) : base(predicate, consequent, alternative) { }
protected PrimitiveIsCharEqA1(Primitive2 rator, Argument1 rand0, SCode rand1) : base(rator, rand0, rand1) { }
public override double Compute(IReadOnlyDictionary <string, double> variableValues) => Argument1.Compute(variableValues) / Argument2.Compute(variableValues);
public static SCode Make(Primitive2 rator, Argument1 rand0, SCode rand1) { return (rand1 is Quotation) ? PrimitiveIsCharEqA1Q.Make (rator, rand0, (Quotation) rand1) : Unimplemented (); }
protected PrimitiveIsFixnumEqualA1L1(Primitive2 rator, Argument1 rand0, LexicalVariable1 rand1) : base(rator, rand0, rand1) { }
public override INotifyExpression <TResult> ApplyParameters(IDictionary <string, object> parameters) { var newArgument1 = Argument1.ApplyParameters(parameters); return(new ObservableStaticLensProxyCall <T1, TResult>(ProxyFunction, newArgument1, LensPut.ApplyNewTarget(newArgument1 as INotifyReversableValue <T1>))); }
public static SCode Make(Primitive2 rator, Argument0 rand0, Argument1 rand1) { return (new PrimitiveGeneralCarCdrA0A1(rator, rand0, rand1)); }
public static SCode Make(Primitive2 rator, Argument1 rand0, LexicalVariable1 rand1) { return new PrimitiveIsFixnumEqualA1L1 (rator, rand0, rand1); }
protected PrimitiveIsFixnumEqualAA1(Primitive2 rator, Argument rand0, Argument1 rand1) : base(rator, rand0, rand1) { }
PCondIsComplexA1SA1(PrimitiveIsComplexA1 predicate, SCode consequent, Argument1 alternative) : base(predicate, consequent, alternative) { }
public static SCode Make(Primitive2 rator, Argument1 rand0, Quotation rand1) { return (new PrimitiveGeneralCarCdrA1Q(rator, rand0, (Quotation)rand1)); }
public static SCode Make(Primitive2 rator, Argument1 rand0, Quotation rand1) { return (new PrimitiveIsIntEqA1Q(rator, rand0, rand1)); }