public TrainList Sort() { switch (fieldForCompare) { case "Ost": { cmp = ostCmp; break; } case "Number": { cmp = numberCmp; break; } case "Time": { cmp = timeCmp; break; } default: throw new ArgumentException(); } return(QuickSort(trains, 0, trains.Count - 1)); }
/// <summary>Populate the combo of BT radios</summary> private void PopulateRadios() { // Get the available radios var radios = Bluetooth.Radios().ToList(); if (radios.Count != 0) { radios.Insert(0, new Bluetooth.Radio(new SafeFileHandle(IntPtr.Zero, false))); } // Update the combo of radios if (radios.Count == 0) { m_cb_radio.DataSource = new[] { "Bluetooth Disabled" }; Radio = null; } else { // Compare to the existing list so the combo isn't changed unnecessarily var curr = m_cb_radio.DataSource as List <Bluetooth.Radio>; if (curr == null || !curr.SequenceEqual(radios, Cmp <Bluetooth.Radio> .From((l, r) => l.Name.CompareTo(r.Name)))) { m_cb_radio.DataSource = radios; // Select the same radio again var name = Radio?.Name; Radio = radios.FirstOrDefault(x => x.Name == name) ?? radios[0]; } } }
public void Post() { //--------post //Prueba de creación de extintor vía HTTP POST string postdata = "{\"TxDescripcion\":\"Olenka Escobar\",\"TxDoc_Identidad\":\"00000000\"}";//JSON byte[] data = Encoding.UTF8.GetBytes(postdata); HttpWebRequest req = (HttpWebRequest)WebRequest .Create("http://localhost:1921/CMPs.svc/CMPs"); req.Method = "POST"; req.ContentLength = data.Length; req.ContentType = "application/json"; var reqStream = req.GetRequestStream(); reqStream.Write(data, 0, data.Length); var res = (HttpWebResponse)req.GetResponse(); StreamReader reader = new StreamReader(res.GetResponseStream()); string cmpJson = reader.ReadToEnd(); JavaScriptSerializer js = new JavaScriptSerializer(); Cmp cmpCreado = js.Deserialize <Cmp>(cmpJson); Assert.AreEqual("Olenka Escobar", cmpCreado.TxDescripcion); Assert.AreEqual("00000000", cmpCreado.TxDoc_Identidad); }
void FixedUpdate() { foreach (var Cmp in Components) { Cmp.OnFixedUpdate(); } }
public static void *QuickSelect(void **arr, int len, int k, Cmp cmp) { void **temp = stackalloc void *[len]; Mem.Memcpy(temp, arr, len * sizeof(void *)); return(QuickSelect(temp, 0, len - 1, k, cmp)); }
static void QuickSort(void **arr, int low, int high, Cmp cmp) { if (low >= high) { return; } void *pivot = arr[low]; void *swap; int mid = low; for (int j = low + 1; j <= high; j += 1) { if (cmp(swap = arr[j], pivot) < 0) { mid += 1; arr[j] = arr[mid]; arr[mid] = swap; } } if (mid != low) { swap = arr[mid]; arr[mid] = arr[low]; arr[low] = swap; } QuickSort(arr, low, mid - 1, cmp); QuickSort(arr, mid + 1, high, cmp); }
public override void Register(SystemRenderer renderer) { sysr = renderer; sysr.Objects.Add(this); if (!inited) { if (Dfm != null) { Dfm.Initialize(sysr.Game.ResourceManager); } if (Model != null && Model.Levels.Length > 0) { Model.Initialize(sysr.Game.ResourceManager); } else if (Cmp != null) { Cmp.Initialize(sysr.Game.ResourceManager); } else if (Sph != null) { Sph.Initialize(sysr.Game.ResourceManager); if (Sph.SideMaterials.Length > 6) { radiusAtmosphere = Sph.Radius * Sph.SideMaterials[6].Scale; } else { radiusAtmosphere = Sph.Radius; } } inited = true; } }
public Cmp ComparisonFromOpName(Operation op) { Cmp toret = null; switch (op) { case Operation.EQ: toret = this.CmpEQ; break; case Operation.NEQ: toret = this.CmpNEQ; break; case Operation.GT: toret = this.CmpGT; break; case Operation.LT: toret = this.CmpLT; break; case Operation.GTE: toret = this.CmpGTE; break; case Operation.LTE: toret = this.CmpLTE; break; } return(toret); }
public void TryParse_AllowCustomQualifiedComparison_ForDomainSpecificSorting() { string languages = "text/*, text/plain"; Predicate <Qualified> isSubtype = q => q.Value.EndsWith("*"); Comparison <Qualified> subtypesComeLater = (q1, q2) => { var quality = q1.Quality.CompareTo(q2.Quality); if (quality == 0) { if (isSubtype(q1) && !isSubtype(q2)) { return(-1); } if (!isSubtype(q1) && isSubtype(q2)) { return(1); } return(StringComparer.Ordinal.Compare(q1.Value, q2.Value)); } return(quality); }; var subject = QualifiedCollection.TryParse(languages, Cmp <Qualified> .By(subtypesComeLater)); Assert.That(subject, Is.EqualTo(new[] { new Qualified("text/plain", Quality.Default), new Qualified("text/*", Quality.Default) }).Using(_equalizer)); }
public static int BinarySearchWithTimeRange(this IList <IIndexedDict> items, int[] keysNdxs, object[] keysValues, ITimedObject timeRange) { int n = items.Count; int ia = 0, ib = n - 1; while (ia <= ib) { int i = (ia + ib) / 2; int r = Cmp.CompareKeysWithTimeRange(items[i].ValuesList, keysNdxs, keysValues, timeRange); if (r > 0) { ib = i - 1; if (ib < ia) { return(~i); } } else if (r < 0) { ia = i + 1; if (ib < ia) { return(~ia); } } else { return(i); } } return(~0); }
void Init() { if (!inited) { if (Dfm != null) { Dfm.Initialize(sysr.ResourceManager); } if (Model != null && Model.Levels.Length > 0) { Model.Initialize(sysr.ResourceManager); } else if (Cmp != null) { Cmp.Initialize(sysr.ResourceManager); } else if (Sph != null) { Sph.Initialize(sysr.ResourceManager); if (Sph.SideMaterials.Length > 6) { radiusAtmosphere = Sph.Radius * Math.Max(Sph.SideMaterials[6].Scale, 1f); } else { radiusAtmosphere = Sph.Radius; } } inited = true; } }
public void LargestOf3Alt() { int[] numbers = new int[3]; numbers[0] = 8; numbers[1] = 9; numbers[2] = 7; Assert.That(Cmp.Largest(numbers), Is.EqualTo(9)); }
public Cmp consultarCmp(int intIdCMP) { Cmp cmp = null; cmp = CmpDAO.Obtener(intIdCMP); return(cmp); }
public LocalityNode(string name, AdminDistrictNode parent) { this.Children = new Dictionary <String, LocationNode>(Cmp); this.Parent = parent; this.Key = name; this.Formatted = Helpers.FormatAddress(null, null, CityName, StateNode?.Abbreviation ?? StateNode?.Key, null, CountryName); unchecked { _hashcode = (typeof(LocalityNode).GetHashCode() * 397) ^ Cmp.GetHashCode(Formatted); } }
public void Clients_DoNotHaveToCareAboutNulls() { var subject = Cmp <OperatorsOnly> .FromOperators(); Assert.That(subject.Compare(null, null), Is.EqualTo(0)); Assert.That(subject.Compare(new OperatorsOnly(1), null), Is.GreaterThan(0)); Assert.That(subject.Compare(null, new OperatorsOnly(1)), Is.LessThan(0)); }
public static int BinarySearch(void **arr, int len, void *val, Cmp cmp) { #if FDB Should.NotNull("arr", arr); Should.GreaterThanZero("len", len); Should.NotNull("cmp", cmp); #endif return(BinarySearch(arr, 0, len - 1, val, cmp)); }
internal void If(Cmp cmpOp) { IfState ifState = new IfState(); ifState.EndIf = DefineLabel(); ifState.ElseBegin = DefineLabel(); _ilGen.Emit(GetBranchCode(cmpOp), ifState.ElseBegin); _blockStack.Push(ifState); }
public static void QuickSort(void **arr, int len, Cmp cmp) { #if FDB Should.NotNull("arr", arr); Should.GreaterThanZero("len", len); Should.NotNull("cmp", cmp); #endif QuickSort(arr, 0, len - 1, cmp); }
public static IEnumerable <int> BinarySearchAllWithTimeRange(this IList <IIndexedDict> items, int[] keysNdxs, object[] keysValues, ITimedObject timeRange) { if (items == null) { yield break; } int n = items.Count; if (n == 0) { yield break; } int i = BinarySearchWithTimeRange(items, keysNdxs, keysValues, timeRange); if (i < 0) { i = 0; yield break; } var Imax = i; while (i > 0 && Cmp.CompareKeysWithTimeRange(items[i - 1].ValuesList, keysNdxs, keysValues, timeRange) == 0) { i--; } var prevEndTime = DateTime.MinValue; while (i <= Imax) { #if CHECK_DATA_DUPS if (i < Imax && Cmp.CompareTimed(items[i].ValuesList, items[i + 1].ValuesList) == 0) { DupDataError(items[i]); i++; continue; } #endif yield return(i++); } while (i < n) { if (Cmp.CompareKeysWithTimeRange(items[i].ValuesList, keysNdxs, keysValues, timeRange) == 0) { #if CHECK_DATA_DUPS if (Cmp.CompareTimed(items[i - 1].ValuesList, items[i].ValuesList) == 0) { DupDataError(items[i]); i++; continue; } #endif yield return(i++); } else { yield break; } } }
public static void MergeSort(void **arr, int len, Cmp cmp) { #if FDB Should.NotNull("arr", arr); Should.GreaterThanZero("len", len); Should.NotNull("cmp", cmp); #endif void **temp = stackalloc void *[len]; MergeSort(arr, temp, 0, len - 1, cmp); }
public void MinBy_AlternativeComparer_MinimumValueAccordingToSelectorAndComparer() { var twoOne = new OrderSubject(2, 1); var collection = new[] { new OrderSubject(2, -2), twoOne }; IComparer <int> absComparer = Cmp <int> .By((one, other) => Math.Abs(one).CompareTo(Math.Abs(other))); Assert.That(collection.MinBy(s => s.I2, absComparer), Is.SameAs(twoOne)); }
public void ChainableComparer_By3Then2_FactoredWithSelectors() { _subjects.Sort(Cmp <ComparisonSubject> .By(c => c.Property3) .Then(c => c.Property2, Direction.Ascending)); Assert.That(_subjects, Must.Be.RepresentableAs("B, D, E, C, A")); _subjects.Sort(Cmp <ComparisonSubject> .By(c => c.Property3) .Then(c => c.Property2, Direction.Descending)); Assert.That(_subjects, Must.Be.RepresentableAs("B, D, E, C, A")); }
public void MaxBy_AlternativeComparer_MinimumValueAccordingToSelectorAndComparer() { var twoMinusTwo = new OrderSubject(2, -2); var collection = new[] { new OrderSubject(2, -1), twoMinusTwo }; IComparer <int> absComparer = Cmp <int> .By((one, other) => Math.Abs(one).CompareTo(Math.Abs(other))); Assert.That(collection.MaxBy(s => s.I2, absComparer), Is.EqualTo(twoMinusTwo)); }
public Cmp actualizarCmp(int intIdCMP, string strtxDescripcion, string strtxDoc_Identidad) { Cmp asesorAModificar = new Cmp() { IdCmp = intIdCMP, TxDescripcion = strtxDescripcion, TxDoc_Identidad = strtxDoc_Identidad }; return(CmpDAO.Modificar(asesorAModificar)); }
public void ChaineableComparer_CanBeUsedWithLinq() { Assert.That(_subjects.OrderBy(s => s, Cmp <ComparisonSubject> .By(s => s.Property3) .Then(s => s.Property2)), Must.Be.RepresentableAs("B, D, E, C, A")); Assert.That(_subjects.OrderBy(s => s, Cmp <ComparisonSubject> .By(s => s.Property3) .Then(s => s.Property2, Direction.Descending)), Must.Be.RepresentableAs("B, D, E, C, A")); }
/// <summary>Populate the directory tree</summary> private void SetupTree() { // Sort directories alphabetically m_tree.TreeViewNodeSorter = Cmp <TreeNode> .From((l, r) => string.Compare(l.Name, r.Name)); // Dynamically add sub directory nodes as needed m_tree.NodesNeeded += (s, a) => { if (a.Node.Nodes.Count != 0) { return; } PopulateChildNodes(a.Node); }; // Populate the tree with the drives foreach (var dv in DriveInfo.GetDrives()) { if (!dv.IsReady) { continue; } var drive = dv.Name.TrimEnd('\\'); var node = new TreeNode(drive, TreeNode.ETriState.Unchecked); m_tree.Nodes.Add(node); PopulateChildNodes(node); } // Checking a node adds or removes that path from the list m_tree.AfterCheck += (s, a) => { if (m_updating_check_marks != null) { return; } // Add or remove the path var path = new Path(a.Node.FullPath); if (a.Node.Checked) { Paths.AddOrdered(path, Path.Compare); } else { // If 'path' is in the list, then the ListChanging handler will call HandlePathRemoved // If not in the list, then we need to call it explicitly if (!Paths.Remove(path)) { HandlePathRemoved(path); } } }; }
public void Explore() { IComparer <ComparisonSubject> subject = new SelectorComparer <ComparisonSubject, int>(s => s.Property2, Direction.Descending); Assert.That(subject.Compare(ComparisonSubject.One, ComparisonSubject.Two), Is.GreaterThan(0)); IComparer <ComparisonSubject> by3Then2Desc = new SelectorComparer <ComparisonSubject, decimal>(s => s.Property3) .Then(s => s.Property2, Direction.Descending); by3Then2Desc = Cmp <ComparisonSubject> .By(s => s.Property3) .Then(s => s.Property2, Direction.Descending); }
public Cmp crearCmp(string strtxDescripcion, string strtxDoc_Identidad) { Cmp nuevoCmp = null; Cmp CmpACrear = new Cmp() { TxDescripcion = strtxDescripcion, TxDoc_Identidad = strtxDoc_Identidad }; nuevoCmp = CmpDAO.Crear(CmpACrear); return(nuevoCmp); }
static void MergeSort(void **arr, void **temp, int low, int high, Cmp cmp) { if (low >= high) { return; } void *swap; if (low == high - 1) { if (cmp(swap = arr[low], arr[high]) > 0) { arr[low] = arr[high]; arr[high] = swap; } return; } int mid = (low + high) >> 1; MergeSort(arr, temp, low, mid, cmp); MergeSort(arr, temp, mid + 1, high, cmp); int i = low, j = mid + 1, k = low; while (i <= mid && j <= high) { if (cmp(arr[i], arr[j]) < 0) { temp[k++] = arr[i++]; } else { temp[k++] = arr[j++]; } } while (i <= mid) { temp[k++] = arr[i++]; } while (j <= high) { temp[k++] = arr[j++]; } for (k = low; k <= high; k += 1) { arr[k] = temp[k]; } }
public void get() { HttpWebRequest req = (HttpWebRequest)WebRequest.Create("http://localhost:1921/CMPs.svc/CMPs/1"); req.Method = "GET"; req.ContentType = "application/json"; var res = (HttpWebResponse)req.GetResponse(); StreamReader reader = new StreamReader(res.GetResponseStream()); string CmpJson = reader.ReadToEnd(); JavaScriptSerializer js = new JavaScriptSerializer(); Cmp CmpCreado = js.Deserialize <Cmp>(CmpJson); Assert.AreEqual(1, CmpCreado.IdCmp); }
private OpCode GetBranchCode(Cmp cmp) { switch (cmp) { case Cmp.LessThan: return OpCodes.Bge; case Cmp.EqualTo: return OpCodes.Bne_Un; case Cmp.LessThanOrEqualTo: return OpCodes.Bgt; case Cmp.GreaterThan: return OpCodes.Ble; case Cmp.NotEqualTo: return OpCodes.Beq; default: DiagnosticUtility.DebugAssert(cmp == Cmp.GreaterThanOrEqualTo, "Unexpected cmp"); return OpCodes.Blt; } }
internal void AndIf(Cmp cmpOp) { if (initIfStack == blockStack.Count) { initIfStack = -1; If(cmpOp); return; } if (initElseIfStack == blockStack.Count) { initElseIfStack = -1; elseIfState.ElseBegin = DefineLabel(); ilGen.Emit(GetBranchCode(cmpOp), elseIfState.ElseBegin); blockStack.Push(elseIfState); return; } Debug.Assert(initIfStack == -1 && initElseIfStack == -1); IfState ifState = (IfState)blockStack.Peek(); ilGen.Emit(GetBranchCode(cmpOp), ifState.ElseBegin); }
internal void AndIf(Cmp cmpOp) { if (_initIfStack == _blockStack.Count) { _initIfStack = -1; If(cmpOp); return; } if (_initElseIfStack == _blockStack.Count) { _initElseIfStack = -1; _elseIfState.ElseBegin = DefineLabel(); _ilGen.Emit(GetBranchCode(cmpOp), _elseIfState.ElseBegin); _blockStack.Push(_elseIfState); return; } Debug.Assert(_initIfStack == -1 && _initElseIfStack == -1); IfState ifState = (IfState)_blockStack.Peek(); _ilGen.Emit(GetBranchCode(cmpOp), ifState.ElseBegin); }
private OpCode GetBranchCode(Cmp cmp) { return s_branchCodes[(int)cmp]; }
/// <summary> /// ElseIf /// </summary> /// <param name="value1"></param> /// <param name="cmpOp"></param> /// <param name="value2"></param> public void ElseIf(object value1, Cmp cmpOp, object value2) { IfState state = (IfState)this.blockStack.Pop(); this.Br(state.EndIf); this.MarkLabel(state.ElseBegin); this.Load(value1); this.Load(value2); state.ElseBegin = this.DefineLabel(); this.ilGen.Emit(this.GetBranchCode(cmpOp), state.ElseBegin); this.blockStack.Push(state); }
internal void ElseIf(object value1, Cmp cmpOp, object value2) { IfState state = (IfState) this.blockStack.Pop(); this.Br(state.EndIf); this.MarkLabel(state.ElseBegin); this.Load(value1); this.Load(value2); state.ElseBegin = this.DefineLabel(); if (this.codeGenTrace != CodeGenTrace.None) { this.EmitSourceInstruction("Branch if " + this.GetCmpInverse(cmpOp).ToString() + " to " + state.ElseBegin.GetHashCode().ToString(NumberFormatInfo.InvariantInfo)); } this.ilGen.Emit(this.GetBranchCode(cmpOp), state.ElseBegin); this.blockStack.Push(state); }
internal void BeginWhileBody(Cmp cmpOp) { Label startWhile = (Label) blockStack.Pop(); If(cmpOp); blockStack.Push(startWhile); }
internal void If(Cmp cmpOp) { IfState ifState = new IfState(); ifState.EndIf = DefineLabel(); ifState.ElseBegin = DefineLabel(); if (codeGenTrace != CodeGenTrace.None) EmitSourceInstruction("Branch if " + GetCmpInverse(cmpOp).ToString() + " to " + ifState.ElseBegin.GetHashCode().ToString(NumberFormatInfo.InvariantInfo)); ilGen.Emit(GetBranchCode(cmpOp), ifState.ElseBegin); blockStack.Push(ifState); }
internal void If(object value1, Cmp cmpOp, object value2) { Load(value1); Load(value2); If(cmpOp); }
internal void While(object value1, Cmp cmpOp, object value2) { IfState ifState = new IfState(); ifState.EndIf = DefineLabel(); ifState.ElseBegin = DefineLabel(); ilGen.MarkLabel(ifState.ElseBegin); Load(value1); Load(value2); if (codeGenTrace != CodeGenTrace.None) EmitSourceInstruction("Branch if " + CmpInverse[(int) cmpOp].ToString() + " to " + ifState.ElseBegin.GetHashCode().ToString()); ilGen.Emit(BranchCode[(int)cmpOp], ifState.EndIf); blockStack.Push(ifState); }
Cmp GetCmpInverse(Cmp cmp) { switch (cmp) { case Cmp.LessThan: return Cmp.GreaterThanOrEqualTo; case Cmp.EqualTo: return Cmp.NotEqualTo; case Cmp.LessThanOrEqualTo: return Cmp.GreaterThan; case Cmp.GreaterThan: return Cmp.LessThanOrEqualTo; case Cmp.NotEqualTo: return Cmp.EqualTo; default: Debug.Assert(cmp == Cmp.GreaterThanOrEqualTo, "Unexpected cmp"); return Cmp.LessThan; } }
internal void AndIf(Cmp cmpOp) { IfState ifState = (IfState) blockStack.Peek(); if (codeGenTrace != CodeGenTrace.None) EmitSourceInstruction("Branch if " + CmpInverse[(int) cmpOp].ToString() + " to " + ifState.ElseBegin.GetHashCode().ToString()); ilGen.Emit(BranchCode[(int)cmpOp], ifState.ElseBegin); }
internal void If(Cmp cmpOp) { IfState state = new IfState { EndIf = this.DefineLabel(), ElseBegin = this.DefineLabel() }; if (this.codeGenTrace != CodeGenTrace.None) { this.EmitSourceInstruction("Branch if " + this.GetCmpInverse(cmpOp).ToString() + " to " + state.ElseBegin.GetHashCode().ToString(NumberFormatInfo.InvariantInfo)); } this.ilGen.Emit(this.GetBranchCode(cmpOp), state.ElseBegin); this.blockStack.Push(state); }
internal void IfString(object s1, Cmp cmpOp, object s2) { Load(s1); Load(s2); Call(stringCompare); Load(0); If(cmpOp); }
public static IEnumerable<Rectangle> Sort(List<Rectangle> list, Cmp compare) { var sortList = list .OrderBy(x => compare(x)); return sortList; }
internal void ElseIfString(object s1, Cmp cmpOp, object s2) { IfState ifState = (IfState)blockStack.Pop(); Br(ifState.EndIf); MarkLabel(ifState.ElseBegin); Load(s1); Load(s2); Call(stringCompare); Load(0); ifState.ElseBegin = DefineLabel(); if (codeGenTrace != CodeGenTrace.None) EmitSourceInstruction("Branch if " + CmpInverse[(int) cmpOp].ToString() + " to " + ifState.ElseBegin.GetHashCode().ToString(NumberFormatInfo.InvariantInfo)); ilGen.Emit(BranchCode[(int)cmpOp], ifState.ElseBegin); blockStack.Push(ifState); }
internal void ElseIf(object value1, Cmp cmpOp, object value2) { IfState ifState = (IfState)blockStack.Pop(); Br(ifState.EndIf); MarkLabel(ifState.ElseBegin); Load(value1); Load(value2); ifState.ElseBegin = DefineLabel(); if (codeGenTrace != CodeGenTrace.None) EmitSourceInstruction("Branch if " + GetCmpInverse(cmpOp).ToString() + " to " + ifState.ElseBegin.GetHashCode().ToString(NumberFormatInfo.InvariantInfo)); ilGen.Emit(GetBranchCode(cmpOp), ifState.ElseBegin); blockStack.Push(ifState); }
internal void AndWhile(Cmp cmpOp) { object startWhile = blockStack.Pop(); AndIf(cmpOp); blockStack.Push(startWhile); }
private OpCode GetBranchCode(Cmp cmp) { switch (cmp) { case Cmp.LessThan: return OpCodes.Bge; case Cmp.EqualTo: return OpCodes.Bne_Un; case Cmp.LessThanOrEqualTo: return OpCodes.Bgt; case Cmp.GreaterThan: return OpCodes.Ble; case Cmp.NotEqualTo: return OpCodes.Beq; } return OpCodes.Blt; }
OpCode GetBranchCode(Cmp cmp) { return BranchCodes[(int)cmp]; }
private Cmp GetCmpInverse(Cmp cmp) { switch (cmp) { case Cmp.LessThan: return Cmp.GreaterThanOrEqualTo; case Cmp.EqualTo: return Cmp.NotEqualTo; case Cmp.LessThanOrEqualTo: return Cmp.GreaterThan; case Cmp.GreaterThan: return Cmp.LessThanOrEqualTo; case Cmp.NotEqualTo: return Cmp.EqualTo; } return Cmp.LessThan; }
internal void If(Cmp cmpOp) { IfState ifState = new IfState(); ifState.EndIf = DefineLabel(); ifState.ElseBegin = DefineLabel(); ilGen.Emit(GetBranchCode(cmpOp), ifState.ElseBegin); blockStack.Push(ifState); }
/// <summary> /// If /// </summary> /// <param name="cmpOp"></param> public void If(Cmp cmpOp) { IfState state = new IfState(); state.EndIf = this.DefineLabel(); state.ElseBegin = this.DefineLabel(); this.ilGen.Emit(this.GetBranchCode(cmpOp), state.ElseBegin); this.blockStack.Push(state); }
internal void ElseIf(object value1, Cmp cmpOp, object value2) { IfState ifState = (IfState)blockStack.Pop(); Br(ifState.EndIf); MarkLabel(ifState.ElseBegin); Load(value1); Load(value2); ifState.ElseBegin = DefineLabel(); ilGen.Emit(GetBranchCode(cmpOp), ifState.ElseBegin); blockStack.Push(ifState); }
/// <summary> /// If /// </summary> /// <param name="value1"></param> /// <param name="cmpOp"></param> /// <param name="value2"></param> public void If(object value1, Cmp cmpOp, object value2) { this.Load(value1); this.Load(value2); this.If(cmpOp); }