ArithmeticOperations.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=".codegen.cs" #>
<#
var ops = new []
{
new Operation("Add", "Add", "To", true, true, "adds them together", "add the evaluation stack value to"),
new Operation("Divide", "Div", "By", false, true, "divides the first by the second", "divide the evaluation stack value by"),
new Operation("Multiply", "Mul", "By", true, true, "multiples them together", "multiply with the evaluation stack value"),
new Operation("Remainder", "Rem", "From", false, true, "finds the remainder when the first is divided by the second", "divide the evaluation stack value by"),
new Operation("Subtract", "Sub", "", true, true, "subtracts the second from the first", "subtract from the evaluation stack value")
};

var numericTypes = new [] { 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 ArithmeticOperations
	{
<# foreach (var op in ops) { #>
		#region <#= op.Name #>

		/// <summary>
        /// Pops two values from the top of the evaluation stack and <#= op.Description #>
        /// </summary>
        /// <param name="generator">The <see cref="T:System.Reflection.Emit.ILGenerator" /> to emit instructions from</param>
		[PublicAPI]
		public static ILGenerator <#= op.Name #>(this ILGenerator generator) => generator.FluentEmit(OpCodes.<#= op.Op #>);

<# if (op.Overflow) { #>
		/// <summary>
        /// Pops two values from the top of the evaluation stack and <#= op.Description #> with a check for overflow
        /// </summary>
        /// <param name="generator">The <see cref="T:System.Reflection.Emit.ILGenerator" /> to emit instructions from</param>
		[PublicAPI]
		public static ILGenerator <#= op.Name #>WithOverflowCheck(this ILGenerator generator) => generator.FluentEmit(OpCodes.<#= op.Op #>_Ovf);

<# } #>
<# if (op.Signed && !op.Overflow) { #>
		/// <summary>
        /// Pops two values from the top of the evaluation stack and <#= op.Description #> 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 <#= op.Name #>Unsigned(this ILGenerator generator) => generator.FluentEmit(OpCodes.<#= op.Op #>_Un);

<# } #>
<# if (op.Signed && op.Overflow) { #>
		/// <summary>
        /// Pops two values from the top of the evaluation stack and <#= op.Description #> without regard for sign, and a check for overflow
        /// </summary>
        /// <param name="generator">The <see cref="T:System.Reflection.Emit.ILGenerator" /> to emit instructions from</param>
		[PublicAPI]
		public static ILGenerator <#= op.Name #>UnsignedWithOverflowCheck(this ILGenerator generator) => generator.FluentEmit(OpCodes.<#= op.Op #>_Ovf_Un);

<# } #>
<# foreach (var type in numericTypes) { #>
		/// <summary>
        /// Pops a value from the top of the evaluation stack, and with the given value <#= op.Description #>
        /// </summary>
        /// <param name="generator">The <see cref="T:System.Reflection.Emit.ILGenerator" /> to emit instructions from</param>
		/// <param name="value">The value to <#= op.ValueDescription #></param>
		[PublicAPI]
		public static ILGenerator <#= op.Name #><#= op.Suffix #>(this ILGenerator generator, <#= type.Name #> value)
		{
			return generator.LoadConstant(value)
							.<#= op.Name #>();
		}

<# if (op.Overflow) { #>
		/// <summary>
        /// Pops a value from the top of the evaluation stack, and with the given value <#= op.Description #> with a check for overflow
        /// </summary>
        /// <param name="generator">The <see cref="T:System.Reflection.Emit.ILGenerator" /> to emit instructions from</param>
		/// <param name="value">The value to <#= op.ValueDescription #></param>
		[PublicAPI]
		public static ILGenerator <#= op.Name #><#= op.Suffix #>WithOverflowCheck(this ILGenerator generator, <#= type.Name #> value)
		{
			return generator.LoadConstant(value)
							.<#= op.Name #>WithOverflowCheck();
		}

<# } #>
<# if (op.Signed && !op.Overflow) { #>
		/// <summary>
        /// Pops a value from the top of the evaluation stack, and with the given value <#= op.Description #> 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 <#= op.ValueDescription #></param>
		[PublicAPI]
		public static ILGenerator <#= op.Name #><#= op.Suffix #>Unsigned(this ILGenerator generator, <#= type.Name #> value)
		{
			return generator.LoadConstant(value)
							.<#= op.Name #>Unsigned();
		}

<# } #>
<# if (op.Signed && op.Overflow) { #>
		/// <summary>
        /// Pop a value from the top of the evaluation stack, and with the given value <#= op.Description #> without regard for sign, and a check for overflow
        /// </summary>
        /// <param name="generator">The <see cref="T:System.Reflection.Emit.ILGenerator" /> to emit instructions from</param>
		/// <param name="value">The value to <#= op.ValueDescription #></param>
		[PublicAPI]
		public static ILGenerator <#= op.Name #><#= op.Suffix #>UnsignedWithOverflowCheck(this ILGenerator generator, <#= type.Name #> value)
		{
			return generator.LoadConstant(value)
							.<#= op.Name #>UnsignedWithOverflowCheck();
		}

<# } #>
<# } // foreach #>

		#endregion

<# } //foreach #>
	}
}
<#+
public class Operation
{
	public string Name;
	public string Op;
	public string Suffix;
	public bool Overflow;
	public bool Signed;
	public string Description;
	public string ValueDescription;

	public Operation(string name, string op, string suffix, bool overflow, bool signed, string description, string valueDescription)
	{
		Name = name;
		Op = op;
		Suffix = suffix;
		Overflow = overflow;
		Signed = signed;
		Description = description;
		ValueDescription = valueDescription;
	}
}
#>