RunSharp - Reflection.Emit Has Never Been Easier

/*
 *  RunSharp - Runtime Code Generation Library
 *  http://www.sourceforge.net/projects/runsharp
 *  Copyright (C) 2007 Stefan Simek
 *
 *  This file is part of RunSharp.
 * 
 *  RunSharp is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  RunSharp is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with RunSharp.  If not, see <http://www.gnu.org/licenses/>.
 */

using System;
using System.Collections.Generic;
using System.Text;

namespace TriAxis.RunSharp.Examples
{
	static class Conversions
	{
		// example based on the MSDN User-Defined Conversions Sample (conversion.cs)
		public static void GenConversion(AssemblyGen ag)
		{
			TypeGen RomanNumeral = ag.Struct("RomanNumeral");
			{
				FieldGen value = RomanNumeral.Private.Field(typeof(int), "value");

				CodeGen g = RomanNumeral.Public.Constructor(typeof(int));
				{
					g.Assign(value, g.Arg(0, "value"));
				}

				// Declare a conversion from an int to a RomanNumeral. Note the
				// the use of the operator keyword. This is a conversion 
				// operator named RomanNumeral:
				g = RomanNumeral.Public.ImplicitConversionFrom(typeof(int));
				{
					// Note that because RomanNumeral is declared as a struct, 
					// calling new on the struct merely calls the constructor 
					// rather than allocating an object on the heap:
					g.Return(Exp.New(RomanNumeral, g.Arg(0, "value")));
				}

				// Declare an explicit conversion from a RomanNumeral to an int:
				g = RomanNumeral.Public.ExplicitConversionTo(typeof(int));
				{
					g.Return(g.Arg(0, "roman").Field("value"));
				}

				// Declare an implicit conversion from a RomanNumeral to 
				// a string:
				g = RomanNumeral.Public.ImplicitConversionTo(typeof(string));
				{
					g.Return("Conversion not yet implemented");
				}
			}

			TypeGen Test = ag.Class("Test");
			{
				CodeGen g = Test.Public.Static.Method(typeof(void), "Main");
				{
					Operand numeral = g.Local(RomanNumeral);

					g.Assign(numeral, 10);

					// Call the explicit conversion from numeral to int. Because it is
					// an explicit conversion, a cast must be used:
					g.WriteLine(numeral.Cast(typeof(int)));

					// Call the implicit conversion to string. Because there is no
					// cast, the implicit conversion to string is the only
					// conversion that is considered:
					g.WriteLine(numeral);

					// Call the explicit conversion from numeral to int and 
					// then the explicit conversion from int to short:
					Operand s = g.Local(numeral.Cast(typeof(short)));

					g.WriteLine(s);
				}
			}
		}

		// example based on the MSDN User-Defined Conversions Sample (structconversion.cs)
		public static void GenStructConversion(AssemblyGen ag)
		{
			TypeGen BinaryNumeral = ag.Struct("BinaryNumeral");
			{
				FieldGen value = BinaryNumeral.Private.Field(typeof(int), "value");

				CodeGen g = BinaryNumeral.Public.Constructor(typeof(int));
				{
					g.Assign(value, g.Arg(0, "value"));
				}

				g = BinaryNumeral.Public.ImplicitConversionFrom(typeof(int));
				{
					g.Return(Exp.New(BinaryNumeral, g.Arg(0, "value")));
				}

				g = BinaryNumeral.Public.ImplicitConversionTo(typeof(string));
				{
					g.Return("Conversion not yet implemented");
				}

				g = BinaryNumeral.Public.ExplicitConversionTo(typeof(int));
				{
					g.Return(g.Arg(0, "binary").Field("value"));
				}
			}

			TypeGen RomanNumeral = ag.Struct("RomanNumeral");
			{
				FieldGen value = RomanNumeral.Private.Field(typeof(int), "value");

				CodeGen g = RomanNumeral.Public.Constructor(typeof(int));
				{
					g.Assign(value, g.Arg(0, "value"));
				}

				g = RomanNumeral.Public.ImplicitConversionFrom(typeof(int));
				{
					g.Return(Exp.New(RomanNumeral, g.Arg(0, "value")));
				}

				g = RomanNumeral.Public.ImplicitConversionFrom(BinaryNumeral);
				{
					g.Return(Exp.New(RomanNumeral, g.Arg(0, "binary").Cast(typeof(int))));
				}

				g = RomanNumeral.Public.ExplicitConversionTo(typeof(int));
				{
					g.Return(g.Arg(0, "roman").Field("value"));
				}

				g = RomanNumeral.Public.ImplicitConversionTo(typeof(string));
				{
					g.Return("Conversion not yet implemented");
				}
			}

			TypeGen Test = ag.Class("Test");
			{
				CodeGen g = Test.Public.Static.Method(typeof(void), "Main");
				{
					Operand roman = g.Local(RomanNumeral);
					g.Assign(roman, 10);
					Operand binary = g.Local(BinaryNumeral);
					// Perform a conversion from a RomanNumeral to a
					// BinaryNumeral:
					g.Assign(binary, roman.Cast(typeof(int)).Cast(BinaryNumeral));
					// Performs a conversion from a BinaryNumeral to a RomanNumeral.
					// No cast is required:
					g.Assign(roman, binary);
					g.WriteLine(binary.Cast(typeof(int)));
					g.WriteLine(binary);
				}
			}
		}
	}
}