CompareAndBranch.tt

<#@ template debug="false" hostspecific="true" language="C#" #>
<#@ assembly name="System.Core" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Collections.Generic" #>
<#@ output extension=".autogen.cs" #>
<#
var ops = new [] {
new Operation("Equal", "To", "Beq", false, "Ceq", "equal to"),
new Operation("NotEqual", "To", "Bne", true, null, "not equal to", true),
new Operation("GreaterThanOrEqual", "To", "Bge", true, null, "greater than or equal to"),
new Operation("Greater", "Than", "Bgt", true, "Cgt", "greater than"),
new Operation("LessThanOrEqual", "To", "Ble", true, null, "less than or equal to"),
new Operation("Less", "Than", "Blt", true, "Clt", "less than")
};

var numericTypes = new [] { typeof(char), typeof(int), typeof(uint), typeof(long), typeof(ulong), typeof(float), typeof(double)};
#>
using System;
using System.Reflection.Emit;
using JetBrains.Annotations;

namespace ILGeneratorExtensions
{
	[PublicAPI]
	public static partial class CompareAndBranch
	{

<# foreach (var op in ops) { #>
		#region <#= op.Name #>
<# if (!op.OnlyUnsigned) { #>

		/// <summary>
        /// Pops two integer values from the evaluation stack and branches to the given label if the first is <#= op.Description #> the second
        /// </summary>
        /// <param name="generator">The <see cref="T:System.Reflection.Emit.ILGenerator" /> to emit instructions from</param>
        /// <param name="label">The label to branch to</param>
		[PublicAPI]
		public static ILGenerator BranchIf<#= op.Name #>(this ILGenerator generator, Label label) => generator.FluentEmit(OpCodes.<#= op.Branch #>, label);

		/// <summary>
        /// Pops two integer values from the evaluation stack and branches to the given label if the first is <#= op.Description #> the second
        /// </summary>
        /// <param name="generator">The <see cref="T:System.Reflection.Emit.ILGenerator" /> to emit instructions from</param>
        /// <param name="labelName">The name of the fluently-specified label</param>
		[PublicAPI]
		public static ILGenerator BranchIf<#= op.Name #>(this ILGenerator generator, string labelName)
			=> generator.BranchIf<#= op.Name #>(generator.GetOrCreateLabel(labelName));
		
		/// <summary>
        /// Pops two integer values from the evaluation stack and branches to the given label if the first is <#= op.Description #> the second
        /// </summary>
        /// <param name="generator">The <see cref="T:System.Reflection.Emit.ILGenerator" /> to emit instructions from</param>
        /// <param name="label">The label to branch to</param>
		[PublicAPI]
		public static ILGenerator BranchIf<#= op.Name #>ShortForm(this ILGenerator generator, Label label) => generator.FluentEmit(OpCodes.<#= op.Branch #>_S, label);
		
		/// <summary>
        /// Pops two integer values from the evaluation stack and branches to the given label if the first is <#= op.Description #> the second
        /// </summary>
        /// <param name="generator">The <see cref="T:System.Reflection.Emit.ILGenerator" /> to emit instructions from</param>
        /// <param name="labelName">The name of the fluently-specified label</param>
		[PublicAPI]
		public static ILGenerator BranchIf<#= op.Name #>ShortForm(this ILGenerator generator, string labelName)
			=> generator.BranchIf<#= op.Name #>ShortForm(generator.GetOrCreateLabel(labelName));

<# foreach (var type in numericTypes) { #>
		/// <summary>
        /// Pops an integer value from the evaluation stack and branches to the given label if it is <#= op.Description #> the given value
        /// </summary>
        /// <param name="generator">The <see cref="T:System.Reflection.Emit.ILGenerator" /> to emit instructions from</param>
		/// <param name="value">The value to compare to the evaluation stack value</param>
        /// <param name="label">The label to branch to</param>
		[PublicAPI]
		public static ILGenerator BranchIf<#= op.Name #><#= op.Suffix #>(this ILGenerator generator, <#= type.Name #> value, Label label)
		{
			return generator.LoadConstant(value)
							.BranchIf<#= op.Name #>(label);
		}

		/// <summary>
        /// Pops an integer value from the evaluation stack and branches to the given label if it is <#= op.Description #> the given value
        /// </summary>
        /// <param name="generator">The <see cref="T:System.Reflection.Emit.ILGenerator" /> to emit instructions from</param>
		/// <param name="value">The value to compare to the evaluation stack value</param>
        /// <param name="labelName">The name of the fluently-specified label</param>
		[PublicAPI]
		public static ILGenerator BranchIf<#= op.Name #><#= op.Suffix #>(this ILGenerator generator, <#= type.Name #> value, string labelName)
			=> generator.BranchIf<#= op.Name #><#= op.Suffix #>(value, generator.GetOrCreateLabel(labelName));

		/// <summary>
        /// Pops an integer value from the evaluation stack and branches to the given label if it is <#= op.Description #> the given value
        /// </summary>
        /// <param name="generator">The <see cref="T:System.Reflection.Emit.ILGenerator" /> to emit instructions from</param>
		/// <param name="value">The value to compare to the evaluation stack value</param>
        /// <param name="label">The label to branch to</param>
		[PublicAPI]
		public static ILGenerator BranchIf<#= op.Name #><#= op.Suffix #>ShortForm(this ILGenerator generator, <#= type.Name #> value, Label label)
		{
			return generator.LoadConstant(value)
							.BranchIf<#= op.Name #>ShortForm(label);
		}

		/// <summary>
        /// Pops an integer value from the evaluation stack and branches to the given label if it is <#= op.Description #> the given value
        /// </summary>
        /// <param name="generator">The <see cref="T:System.Reflection.Emit.ILGenerator" /> to emit instructions from</param>
		/// <param name="value">The value to compare to the evaluation stack value</param>
        /// <param name="labelName">The name of the fluently-specified label</param>
		[PublicAPI]
		public static ILGenerator BranchIf<#= op.Name #><#= op.Suffix #>ShortForm(this ILGenerator generator, <#= type.Name #> value, string labelName)
			=> generator.BranchIf<#= op.Name #><#= op.Suffix #>ShortForm(value, generator.GetOrCreateLabel(labelName));
<# } #>
<# } #>
<# if (op.Signed) { #>
		/// <summary>
        /// Pops two integer values from the evaluation stack and branches to the given label if the first is <#= op.Description #> the second, without regard for sign
        /// </summary>
        /// <param name="generator">The <see cref="T:System.Reflection.Emit.ILGenerator" /> to emit instructions from</param>
        /// <param name="label">The label to branch to</param>
		[PublicAPI]
		public static ILGenerator BranchIf<#= op.Name #>Unsigned(this ILGenerator generator, Label label) => generator.FluentEmit(OpCodes.<#= op.Branch #>_Un, label);
		
		/// <summary>
        /// Pops two integer values from the evaluation stack and branches to the given label if the first is <#= op.Description #> the second, without regard for sign
        /// </summary>
        /// <param name="generator">The <see cref="T:System.Reflection.Emit.ILGenerator" /> to emit instructions from</param>
        /// <param name="labelName">The name of the fluently-specified label</param>
		[PublicAPI]
		public static ILGenerator BranchIf<#= op.Name #>Unsigned(this ILGenerator generator, string labelName)
			=> generator.BranchIf<#= op.Name #>Unsigned(generator.GetOrCreateLabel(labelName));

		/// <summary>
        /// Pops two integer values from the evaluation stack and branches to the given label if the first is <#= op.Description #> the second, without regard for sign
        /// </summary>
        /// <param name="generator">The <see cref="T:System.Reflection.Emit.ILGenerator" /> to emit instructions from</param>
        /// <param name="label">The label to branch to</param>
		[PublicAPI]
		public static ILGenerator BranchIf<#= op.Name #>UnsignedShortForm(this ILGenerator generator, Label label) => generator.FluentEmit(OpCodes.<#= op.Branch #>_Un_S, label);

		/// <summary>
        /// Pops two integer values from the evaluation stack and branches to the given label if the first is <#= op.Description #> the second, without regard for sign
        /// </summary>
        /// <param name="generator">The <see cref="T:System.Reflection.Emit.ILGenerator" /> to emit instructions from</param>
        /// <param name="labelName">The name of the fluently-specified label</param>
		[PublicAPI]
		public static ILGenerator BranchIf<#= op.Name #>UnsignedShortForm(this ILGenerator generator, string labelName)
			=> generator.BranchIf<#= op.Name #>UnsignedShortForm(generator.GetOrCreateLabel(labelName));

<# foreach (var type in numericTypes) { #>
		/// <summary>
        /// Pops an integer value from the evaluation stack and branches to the given label if it is <#= op.Description #> the given value, without regard for sign
        /// </summary>
        /// <param name="generator">The <see cref="T:System.Reflection.Emit.ILGenerator" /> to emit instructions from</param>
		/// <param name="value">The value to compare to the evaluation stack value</param>
        /// <param name="label">The label to branch to</param>
		[PublicAPI]
		public static ILGenerator BranchIf<#= op.Name #><#= op.Suffix #>Unsigned(this ILGenerator generator, <#= type.Name #> value, Label label)
		{
			return generator.LoadConstant(value)
							.BranchIf<#= op.Name #>Unsigned(label);
		}

		/// <summary>
        /// Pops an integer value from the evaluation stack and branches to the given label if it is <#= op.Description #> the given value, without regard for sign
        /// </summary>
        /// <param name="generator">The <see cref="T:System.Reflection.Emit.ILGenerator" /> to emit instructions from</param>
		/// <param name="value">The value to compare to the evaluation stack value</param>
        /// <param name="labelName">The name of the fluently-specified label</param>
		[PublicAPI]
		public static ILGenerator BranchIf<#= op.Name #><#= op.Suffix #>Unsigned(this ILGenerator generator, <#= type.Name #> value, string labelName)
			=> generator.BranchIf<#= op.Name #><#= op.Suffix #>Unsigned(value, generator.GetOrCreateLabel(labelName));

		/// <summary>
        /// Pops an integer value from the evaluation stack and branches to the given label if it is <#= op.Description #> the given value, with regard for sign
        /// </summary>
        /// <param name="generator">The <see cref="T:System.Reflection.Emit.ILGenerator" /> to emit instructions from</param>
		/// <param name="value">The value to compare to the evaluation stack value</param>
        /// <param name="label">The label to branch to</param>
		[PublicAPI]
		public static ILGenerator BranchIf<#= op.Name #><#= op.Suffix #>UnsignedShortForm(this ILGenerator generator, <#= type.Name #> value, Label label)
		{
			return generator.LoadConstant(value)
							.BranchIf<#= op.Name #>UnsignedShortForm(label);
		}

		/// <summary>
        /// Pops an integer value from the evaluation stack and branches to the given label if it is <#= op.Description #> the given value, with regard for sign
        /// </summary>
        /// <param name="generator">The <see cref="T:System.Reflection.Emit.ILGenerator" /> to emit instructions from</param>
		/// <param name="value">The value to compare to the evaluation stack value</param>
        /// <param name="labelName">The name of the fluently-specified label</param>
		[PublicAPI]
		public static ILGenerator BranchIf<#= op.Name #><#= op.Suffix #>UnsignedShortForm(this ILGenerator generator, <#= type.Name #> value, string labelName)
			=> generator.BranchIf<#= op.Name #><#= op.Suffix #>UnsignedShortForm(value, generator.GetOrCreateLabel(labelName));
<# } #>

<# } #>
<# if (op.Compare != null) { #>
		/// <summary>
        /// Pops two integer values from the evaluation stack and pushes the result of comparing whether the first is <#= op.Description #> the second
        /// </summary>
        /// <param name="generator">The <see cref="T:System.Reflection.Emit.ILGenerator" /> to emit instructions from</param>
		[PublicAPI]
		public static ILGenerator Compare<#= op.Name #>(this ILGenerator generator) => generator.FluentEmit(OpCodes.<#= op.Compare #>);

<# foreach (var type in numericTypes) { #>
		/// <summary>
        /// Pops an integer value from the evaluation stack and pushes the result of comparing whether it is <#= op.Description #> the given value
        /// </summary>
        /// <param name="generator">The <see cref="T:System.Reflection.Emit.ILGenerator" /> to emit instructions from</param>
		/// <param name="value">The value to compare to the evaluation stack value</param>
		[PublicAPI]
		public static ILGenerator Compare<#= op.Name #><#= op.Suffix #>(this ILGenerator generator, <#= type.Name #> value)
		{
			return generator.LoadConstant(value)
							.Compare<#= op.Name #>();
		}
<# } #>

<# }#>
<# if (op.Compare != null && op.Signed) { #>
		/// <summary>
        /// Pops two integer values from the evaluation stack and pushes the result of comparing whether the first is <#= op.Description #> the second, without regard for sign
        /// </summary>
        /// <param name="generator">The <see cref="T:System.Reflection.Emit.ILGenerator" /> to emit instructions from</param>
		[PublicAPI]
		public static ILGenerator Compare<#= op.Name #>Unsigned(this ILGenerator generator) => generator.FluentEmit(OpCodes.<#= op.Compare #>_Un);

<# foreach (var type in numericTypes) { #>
		/// <summary>
        /// Pops an integer value from the evaluation stack and pushes the result of comparing whether it is <#= op.Description #> the given value, without regard for sign
        /// </summary>
        /// <param name="generator">The <see cref="T:System.Reflection.Emit.ILGenerator" /> to emit instructions from</param>
		/// <param name="value">The value to compare to the evaluation stack value</param>
		[PublicAPI]
		public static ILGenerator Compare<#= op.Name #><#= op.Suffix #>Unsigned(this ILGenerator generator, <#= type.Name #> value)
		{
			return generator.LoadConstant(value)
							.Compare<#= op.Name #>Unsigned();
		}
<# } #>

<# } #>
		#endregion

<# } #>
	}
}
<#+
public class Operation
{
	public string Name;
	public string Branch;
	public string Suffix;
	public bool Signed;
	public string Compare;
	public string Description;
	public bool OnlyUnsigned;
	
	public Operation(string name, string suffix, string branch, bool signed, string compare, string description, bool onlyUnsigned = false)
	{
		Name = name;
		Branch = branch;
		Suffix = suffix;
		Signed = signed;
		Compare = compare;
		Description = description;
		OnlyUnsigned = onlyUnsigned;
	}
}
#>