상속: ICodeGenBasicContext
        public static void ClassImpl(AssemblyGen ag, bool impl)
        {
            ITypeMapper m = ag.TypeMapper;
            TypeGen Test = ag.Class("Test");
            {
                CodeGen g = Test.Public.Static.Method(typeof(void), "Main");
                {
                    // test calling virtual member directly on a literal
                    // g.Local(Operand.FromObject(3).Invoke("GetHashCode"));

                    // test special case where the value type target doesn't implement the virtual function
                    var value = g.Local(Test);
                    g.Assign(value, ag.ExpressionFactory.New(Test));
                    g.WriteLine("Hash code of {0} is {1}", value, value.Invoke("GetHashCode"));
                }

                if (impl)
                {
                    g = Test.Public.Override.Method(typeof(int), "GetHashCode");
                    {
                        g.Return(-1);
                    }
                }
            }
        }
예제 #2
0
 public DelegateGen(AssemblyGen owner, string name, Type returnType, TypeAttributes attrs)
     : base(returnType)
 {
     this.owner = owner;
     this.name  = name;
     this.attrs = attrs;
 }
예제 #3
0
 public DelegateGen(AssemblyGen owner, string name, Type returnType, TypeAttributes attrs)
     : base(returnType, owner.TypeMapper)
 {
     _owner = owner;
     _name  = name;
     _attrs = attrs;
 }
 public static void GenOriginalTest(AssemblyGen ag)
 {
     ITypeMapper m = ag.TypeMapper;
     TypeGen Test = ag.Class("Test");
     {
         CodeGen g = Test.Public.Static.Method(typeof(void), "Main");
         {
             var value = g.Local(typeof(int), 3);
             g.WriteLine("Hash code of {0} is {1}", value, value.Invoke("GetHashCode"));
         }
     }
 }
        // example based on the MSDN Operator Overloading Sample (complex.cs)
        public static void GenComplex(AssemblyGen ag)
        {
            var st = ag.StaticFactory;
            var exp = ag.ExpressionFactory;

            ITypeMapper m = ag.TypeMapper;
			TypeGen Complex = ag.Public.Struct("Complex");
			{
				FieldGen real = Complex.Public.Field(typeof(int), "real");
				FieldGen imaginary = Complex.Public.Field(typeof(int), "imaginary");

				CodeGen g = Complex.Public.Constructor()
					.Parameter(typeof(int), "real")
					.Parameter(typeof(int), "imaginary")
					;
				{
					g.Assign(real, g.Arg("real"));
					g.Assign(imaginary, g.Arg("imaginary"));
				}

				// Declare which operator to overload (+), the types 
				// that can be added (two Complex objects), and the 
				// return type (Complex):
				g = Complex.Operator(Operator.Add, Complex, Complex, "c1", Complex, "c2");

			    {
			        var c1 = g.Arg("c1");
                    var c2 = g.Arg("c2");
					g.Return(exp.New(Complex, c1.Field("real") + c2.Field("real"), c1.Field("imaginary") + c2.Field("imaginary")));
				}

				// Override the ToString method to display an complex number in the suitable format:
				g = Complex.Public.Override.Method(typeof(string), "ToString");
				{
					g.Return(st.Invoke(typeof(string), "Format", "{0} + {1}i", real, imaginary));
				}

				g = Complex.Public.Static.Method(typeof(void), "Main");
				{
                    var num1 = g.Local(exp.New(Complex, 2, 3));
                    var num2 = g.Local(exp.New(Complex, 3, 4));

                    // Add two Complex objects (num1 and num2) through the
                    // overloaded plus operator:
                    var sum = g.Local(num1 + num2);

					// Print the numbers and the sum using the overriden ToString method:
					g.WriteLine("First complex number:  {0}", num1);
					g.WriteLine("Second complex number: {0}", num2);
					g.WriteLine("The sum of the two numbers: {0}", sum);
				}
			}
		}
예제 #6
0
파일: Program.cs 프로젝트: ectacoh/RunSharp
        static void Main(string[] args)
        {
            bool noexe = args.Length > 0 && args[0] == "/noexe";

            string exePath = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "out");

            Directory.CreateDirectory(exePath);

            foreach (Generator gen in examples)
            {
                string testName = GetTestName(gen);
                Console.WriteLine(">>> GEN {0}", testName);
                string      name = noexe ? testName : Path.Combine(exePath, testName + ".exe");
                AssemblyGen asm  = new AssemblyGen(name);
                gen(asm);
                if (!noexe)
                {
                    asm.Save();
                }
                Console.WriteLine("=== RUN {0}", testName);

                try
                {
                    if (noexe)
                    {
                        Type       entryType   = asm.GetAssembly().EntryPoint.DeclaringType;
                        MethodInfo entryMethod = entryType.GetMethod(asm.GetAssembly().EntryPoint.Name, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);
                        object[]   entryArgs   = null;
                        if (entryMethod.GetParameters().Length == 1)
                        {
                            entryArgs = new object[] { GetTestArguments(gen) };
                        }
                        entryMethod.Invoke(null, entryArgs);
                    }
                    else
                    {
                        AppDomain.CurrentDomain.ExecuteAssembly(name, null,
                                                                GetTestArguments(gen));
                    }
                }
                catch (Exception e)
                {
                    Console.WriteLine("!!! UNHANDLED EXCEPTION");
                    Console.WriteLine(e);
                }
                Console.WriteLine("<<< END {0}", testName);
                Console.WriteLine();
            }

            // dynamic method examples
            DynamicMethodExamples();
        }
예제 #7
0
        internal TypeGen(TypeGen owner, string name, TypeAttributes attrs, Type baseType, Type[] interfaces)
        {
            this.owner      = owner.owner;
            this.name       = name;
            this.baseType   = baseType;
            this.interfaces = interfaces;

            tb = owner.TypeBuilder.DefineNestedType(name, attrs, baseType, interfaces);
            owner.nestedTypes.Add(this);
            ScanMethodsToImplement(interfaces);

            TypeInfo.RegisterProvider(tb, this);
        }
예제 #8
0
        internal TypeGen(AssemblyGen owner, string name, TypeAttributes attrs, Type baseType, Type[] interfaces)
        {
            this.owner      = owner;
            this.name       = name;
            this.baseType   = baseType;
            this.interfaces = interfaces;

            tb = owner.ModuleBuilder.DefineType(name, attrs, baseType, interfaces);
            owner.AddType(this);
            ScanMethodsToImplement(interfaces);

            TypeInfo.RegisterProvider(tb, this);
            ResetAttrs();
        }
예제 #9
0
        public static void GenCmdLine2(AssemblyGen ag)
        {
            ITypeMapper m = ag.TypeMapper;
            var st = ag.StaticFactory;
            var exp = ag.ExpressionFactory;
            ContextualOperand x;
            TypeGen commandLine3 = ag.Public.Class("CommandLine3");
            {
                CodeGen g = commandLine3.Public.Method(typeof(void), "Main3").Parameter(typeof(string[]), "args");
                {
                    var args = g.Arg("args");
                    
                    g.WriteLine("Number of command line 3 parameters = {0}",
                        args.Property("Length"));
                    var s = g.ForEach(typeof(string), args);
                    {
                        g.WriteLine(s);
                    }
                    g.End();
                    g.WriteLine(g.This().Invoke("GetType").Property("BaseType").Property("Name"));

                    var inst = st.Field(typeof(CmdLineTestClass), "Default");
                    g.WriteLine(inst.Invoke("GetValue"));
                }


                commandLine3.Public.CommonConstructor();
            }

            TypeGen commandLine2 = ag.Public.Class("CommandLine2");
            {
                CodeGen g = commandLine2.Public.Static.Method(typeof(void), "Main").Parameter(typeof(string[]), "args");
                {
                    //g.Invoke(CommandLine3, "Main3", g.Arg("args"));
                    var cl = g.Local(exp.New(commandLine3));
                    g.WriteLine(0);
                    g.Invoke(cl, "Main3", g.Arg("args"));
                    var args = g.Arg("args");
                    g.WriteLine("Number of command line parameters = {0}",
                        args.Property("Length"));
                    var s = g.ForEach(typeof(string), args);
                    {
                        g.WriteLine(s);
                    }
                    g.End();


                }
            }
        }
예제 #10
0
        internal TypeGen(TypeGen owner, string name, TypeAttributes attrs, Type baseType, Type[] interfaces, ITypeMapper typeMapper)
            : base(typeMapper)
        {
            _owner      = owner._owner;
            Name        = name;
            BaseType    = baseType;
            _interfaces = interfaces;
            _typeMapper = typeMapper;

            TypeBuilder = owner.TypeBuilder.DefineNestedType(name, attrs, baseType, interfaces);
            owner._nestedTypes.Add(this);
            ScanMethodsToImplement(interfaces);

            typeMapper.TypeInfo.RegisterProvider(TypeBuilder, this);
        }
예제 #11
0
        // example based on the MSDN Versioning Sample (versioning.cs)
        public static void GenVersioning(AssemblyGen ag)
		{
            var st = ag.StaticFactory;
            var exp = ag.ExpressionFactory;

            ITypeMapper m = ag.TypeMapper;
            TypeGen MyBase = ag.Public.Class("MyBase");
			{
				MyBase.Public.Virtual.Method(typeof(string), "Meth1").GetCode()
					.Return("MyBase-Meth1");

				MyBase.Public.Virtual.Method(typeof(string), "Meth2").GetCode()
					.Return("MyBase-Meth2");

				MyBase.Public.Virtual.Method(typeof(string), "Meth3").GetCode()
					.Return("MyBase-Meth3");
			}

			TypeGen MyDerived = ag.Class("MyDerived", MyBase);
			{
				// Overrides the virtual method Meth1 using the override keyword:
				MyDerived.Public.Override.Method(typeof(string), "Meth1").GetCode()
					.Return("MyDerived-Meth1");

				// Explicitly hide the virtual method Meth2 using the new
				// keyword:
				// remark: new is not supported/required in RunSharp
				MyDerived.Public.Method(typeof(string), "Meth2").GetCode()
					 .Return("MyDerived-Meth2");

				// Because no keyword is specified in the following declaration
				// a warning will be issued to alert the programmer that 
				// the method hides the inherited member MyBase.Meth3():
				// remark: this warning is not supported in RunSharp
				MyDerived.Public.Method(typeof(string), "Meth3").GetCode()
					 .Return("MyDerived-Meth3");

				CodeGen g = MyDerived.Public.Static.Method(typeof(void), "Main");
				{
                    var mD = g.Local(exp.New(MyDerived));
                    var mB = g.Local(mD.Cast(MyBase));

					g.WriteLine(mB.Invoke("Meth1"));
					g.WriteLine(mB.Invoke("Meth2"));
					g.WriteLine(mB.Invoke("Meth3"));
				}
			}
		}
예제 #12
0
        public CodeGenerator() {
            varTable = new Stack<Dictionary<string, ZOperand>>();
            typeTable = new Dictionary<string, Type>();
            typeStack = new Stack<TypeGen>();
            funcStack = new Stack<CodeGen>();

            name = "ZodiacConsole";
            var exeDir = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
            if (exeDir == null) return;
            var exeFilePath = Path.Combine(exeDir, name + ".exe");
            Directory.CreateDirectory(exeDir);
            ag = new AssemblyGen(name, new CompilerOptions() { OutputPath = exeFilePath });
            st = ag.StaticFactory;
            exp = ag.ExpressionFactory;
            tm = ag.TypeMapper;
        }
예제 #13
0
		public void CreateComWrapper(string filePath, string dllPath, string p1, string p2)
		{
			AssemblyGen ag = new AssemblyGen(filePath);

			Assembly asm = Assembly.LoadFrom(dllPath);
			ag.Attribute(asm.GetType("WaveTech.Scutex.Model.LicenseAttribute"), p1, p2);

			ag.Attribute(typeof(System.Runtime.InteropServices.ComVisibleAttribute), true);
			ag.Attribute(typeof(System.Reflection.AssemblyVersionAttribute), "1.0.0.0");
			ag.Attribute(typeof(System.Reflection.AssemblyFileVersionAttribute), "1.0.0.0");
			ag.Attribute(typeof(System.Runtime.InteropServices.GuidAttribute), "DC7DE67E-EA7A-4D26-89FF-FECEF2937268");

			ag.Namespace("ScutexLicensingCCW");

			TypeGen ComWrapper = ag.Public.Class(_stringDataGeneratorProvider.GenerateRandomString(10, 50, false, false)).Attribute(typeof(System.Runtime.InteropServices.ClassInterfaceAttribute), System.Runtime.InteropServices.ClassInterfaceType.AutoDual);
			{
				CodeGen g1 = ComWrapper.Public.Constructor();

				CodeGen g2 = ComWrapper.Public.Method(typeof(int), "Validate").Parameter(typeof(int), "interactionMode");
				{
					Operand licensingManager = g2.Local(Exp.New(asm.GetType("WaveTech.Scutex.Licensing.LicensingManager"), g2.This()));
					Operand scutexLicensing = g2.Local(asm.GetType("WaveTech.Scutex.Model.ScutexLicense"));

					Operand value = g2.Local(asm.GetType("WaveTech.Scutex.Model.InteractionModes"));
					g2.Assign(value, g2.Arg("interactionMode").Cast(asm.GetType("WaveTech.Scutex.Model.InteractionModes")));

					g2.Assign(scutexLicensing, licensingManager.Invoke("Validate", value));

					g2.Return(0);
				}

				CodeGen g3 = ComWrapper.Public.Method(typeof(int), "Register").Parameter(typeof(string), "licenseKey");
				{
					Operand licensingManager = g3.Local(Exp.New(asm.GetType("WaveTech.Scutex.Licensing.LicensingManager"), g3.This()));
					Operand scutexLicensing = g3.Local(asm.GetType("WaveTech.Scutex.Model.ScutexLicense"));

					g3.Assign(scutexLicensing, licensingManager.Invoke("Register", g3.Arg("licenseKey")));

					g3.Return(0);
				}
			}

			ag.Save();
			asm = null;
		}
예제 #14
0
        // example based on the MSDN Properties Sample (person.cs)
        public static void GenPerson(AssemblyGen ag)
		{
            var st = ag.StaticFactory;
            var exp = ag.ExpressionFactory;

            TypeGen Person = ag.Class("Person");
			{
				FieldGen myName = Person.Private.Field(typeof(string), "myName", "N/A");
				FieldGen myAge = Person.Private.Field(typeof(int), "myAge", 0);

				// Declare a Name property of type string:
				PropertyGen Name = Person.Public.SimpleProperty(myName, "Name");

				// Declare an Age property of type int:
				PropertyGen Age = Person.Public.SimpleProperty(myAge, "Age");

				CodeGen g = Person.Public.Override.Method(typeof(string), "ToString");
				{
					g.Return("Name = " + Name + ", Age = " + Age);
				}

				g = Person.Public.Static.Method(typeof(void), "Main");
				{
					g.WriteLine("Simple Properties");

                    // Create a new Person object:
                    var person = g.Local(exp.New(Person));

					// Print out the name and the age associated with the person:
					g.WriteLine("Person details - {0}", person);

					// Set some values on the person object:
				    ITypeMapper typeMapper = ag.TypeMapper;
				    g.Assign(person.Property("Name"), "Joe");
				    ITypeMapper typeMapper1 = ag.TypeMapper;
				    g.Assign(person.Property("Age"), 99);
					g.WriteLine("Person details - {0}", person);

					// Increment the Age property:
				    ITypeMapper typeMapper2 = ag.TypeMapper;
				    g.AssignAdd(person.Property("Age"), 1);
					g.WriteLine("Person details - {0}", person);
				}
			}
		}
예제 #15
0
        // example based on the MSDN Structs Sample (struct1.cs)
        public static void GenStruct1(AssemblyGen ag)
		{
            var st = ag.StaticFactory;
            var exp = ag.ExpressionFactory;

            CodeGen g;

			TypeGen SimpleStruct = ag.Struct("SimpleStruct");
			{
				FieldGen xval = SimpleStruct.Field(typeof(int), "xval");

				PropertyGen X = SimpleStruct.Public.Property(typeof(int), "X");
				{
					X.Getter().GetCode().Return(xval);
					g = X.Setter();
					{
						g.If(g.PropertyValue() < 100);
						{
							g.Assign(xval, g.PropertyValue());
						}
						g.End();
					}
				}

				g = SimpleStruct.Public.Method(typeof(void), "DisplayX");
				{
					g.WriteLine("The stored value is: {0}", xval);
				}
			}

			TypeGen TestClass = ag.Class("TestClass");
			{
				g = TestClass.Public.Static.Method(typeof(void), "Main");
				{
                    var ss = g.Local(SimpleStruct);
					g.InitObj(ss);
				    ITypeMapper typeMapper = ag.TypeMapper;
				    g.Assign(ss.Property("X"), 5);
					g.Invoke(ss, "DisplayX");
				}
			}
		}
예제 #16
0
		public void CreateAssembly(string p1, string p2)
		{
			AssemblyGen ag = new AssemblyGen(_path + @"\DemoHost.exe");

			Assembly asm = Assembly.LoadFrom(_path + @"\WaveTech.Scutex.Licensing.dll");
			ag.Attribute(asm.GetType("WaveTech.Scutex.Model.LicenseAttribute"), p1, p2);

			TypeGen DemoHost = ag.Public.Class("DemoHost");
			{
				CodeGen g = DemoHost.Public.Static.Method(typeof(void), "Main");
				{
					g.WriteLine("====================================================");
					g.WriteLine("|                      SCUTEX                      |");
					g.WriteLine("|         DEMO HOST FOR TRIAL DIALOG TESTING       |");
					g.WriteLine("====================================================");
					g.WriteLine("");
					g.WriteLine("");
					g.WriteLine("Your trial dialog or form should display in a few seconds...");

					Operand licensingManager = g.Local(Exp.New(asm.GetType("WaveTech.Scutex.Licensing.LicensingManager")));

					Operand value = g.Local(asm.GetType("WaveTech.Scutex.Model.InteractionModes"));

					Operand value2 = g.Local(typeof(System.Int32));
					g.Assign(value2, 1);

					g.Assign(value, value2.Cast(asm.GetType("WaveTech.Scutex.Model.InteractionModes")));

					Operand scutexLicensing = g.Local(asm.GetType("WaveTech.Scutex.Model.ScutexLicense"));

					g.Assign(scutexLicensing, licensingManager.Invoke("Validate", value));

					g.Return();
				}
			}

			ag.Save();
			asm = null;
		}
 void GenClassNotImpl(AssemblyGen ag)
 {
     ClassImpl(ag, false);
 }
 void GenStructImpl(AssemblyGen ag)
 {
     StructImpl(ag, true);
 }
 void GenClassImpl(AssemblyGen ag)
 {
     ClassImpl(ag, true);
 }
		static void Main(string[] args)
		{
			bool noexe = args.Length > 0 && args[0] == "/noexe";

			string exePath = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "out");
			Directory.CreateDirectory(exePath);

			foreach (Generator gen in examples)
			{
				string testName = GetTestName(gen);
				Console.WriteLine(">>> GEN {0}", testName);
				string name = noexe ? testName : Path.Combine(exePath, testName + ".exe");
				AssemblyGen asm = new AssemblyGen(name);
				gen(asm);
				if (!noexe)	asm.Save();
				Console.WriteLine("=== RUN {0}", testName);
                try
                {
					if (noexe)
					{
						Type entryType = asm.GetAssembly().EntryPoint.DeclaringType;
						MethodInfo entryMethod = entryType.GetMethod(asm.GetAssembly().EntryPoint.Name, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);
						object[] entryArgs = null;
						if (entryMethod.GetParameters().Length == 1)
						{
							entryArgs = new object[] { GetTestArguments(gen) };
						}
						entryMethod.Invoke(null, entryArgs);
					}
					else
					{
						AppDomain.CurrentDomain.ExecuteAssembly(name, null,
							GetTestArguments(gen));
					}
				}
                catch (Exception e)
                {
                    Console.WriteLine("!!! UNHANDLED EXCEPTION");
                    Console.WriteLine(e);
                }
				Console.WriteLine("<<< END {0}", testName);
				Console.WriteLine();
			}

			// dynamic method examples
			DynamicMethodExamples();
		}
예제 #21
0
        // example based on the MSDN Delegates Sample (bookstore.cs)
        public static void GenBookstore(AssemblyGen ag)
        {
            var st = ag.StaticFactory;
            var exp = ag.ExpressionFactory;

            ITypeMapper m = ag.TypeMapper;
		    TypeGen book, processBookDelegate, BookDBLocal;

		    // A set of classes for handling a bookstore:
		    using (ag.Namespace("Bookstore"))
			{
				// Describes a book in the book list:
				book = ag.Public.Struct("Book");
				{
					FieldGen title = book.Public.Field(typeof(string), "Title");	   // Title of the book.
					FieldGen author = book.Public.Field(typeof(string), "Author");     // Author of the book.
					FieldGen price = book.Public.Field(typeof(decimal), "Price");      // Price of the book.
					FieldGen paperback = book.Public.Field(typeof(bool), "Paperback"); // Is it paperback?

					CodeGen g = book.Public.Constructor()
						.Parameter(typeof(string), "title")
						.Parameter(typeof(string), "author")
						.Parameter(typeof(decimal), "price")
						.Parameter(typeof(bool), "paperBack");
					{
						g.Assign(title, g.Arg("title"));
						g.Assign(author, g.Arg("author"));
						g.Assign(price, g.Arg("price"));
						g.Assign(paperback, g.Arg("paperBack"));
					}
				}

				// Declare a delegate type for processing a book:
				processBookDelegate = ag.Public.Delegate(typeof(void), "ProcessBookDelegate").Parameter(book, "book");

				// Maintains a book database.
				BookDBLocal = ag.Public.Class("BookDB");
				{
					// List of all books in the database:
					FieldGen list = BookDBLocal.Field(typeof(ArrayList), "list", exp.New(typeof(ArrayList)));

					// Add a book to the database:
					CodeGen g = BookDBLocal.Public.Method(typeof(void), "AddBook")
						.Parameter(typeof(string), "title")
						.Parameter(typeof(string), "author")
						.Parameter(typeof(decimal), "price")
						.Parameter(typeof(bool), "paperBack")
						;
					{
						g.Invoke(list, "Add", exp.New(book, g.Arg("title"), g.Arg("author"), g.Arg("price"), g.Arg("paperBack")));
					}

					// Call a passed-in delegate on each paperback book to process it: 
					g = BookDBLocal.Public.Method(typeof(void), "ProcessPaperbackBooks").Parameter(processBookDelegate, "processBook");
					{
                        var b = g.ForEach(book, list);
						{
							g.If(b.Field("Paperback"));
							{
								g.InvokeDelegate(g.Arg("processBook"), b);
							}
							g.End();
						}
						g.End();
					}
				}
			}

			// Using the Bookstore classes:
			using (ag.Namespace("BookTestClient"))
			{
				// Class to total and average prices of books:
				TypeGen priceTotaller = ag.Class("PriceTotaller");
				{
					FieldGen countBooks = priceTotaller.Field(typeof(int), "countBooks", 0);
					FieldGen priceBooks = priceTotaller.Field(typeof(decimal), "priceBooks", 0.0m);

					CodeGen g = priceTotaller.Internal.Method(typeof(void), "AddBookToTotal").Parameter(book, "book");
					{
						g.AssignAdd(countBooks, 1);
						g.AssignAdd(priceBooks, g.Arg("book").Field("Price"));
					}

					g = priceTotaller.Internal.Method(typeof(decimal), "AveragePrice");
					{
						g.Return(priceBooks / countBooks);
					}
				}

				// Class to test the book database:
				TypeGen test = ag.Class("Test");
				{
					// Print the title of the book.
					CodeGen g = test.Static.Method(typeof(void), "PrintTitle").Parameter(book, "book");
					{
						g.WriteLine("   {0}", g.Arg("book").Field("Title"));
					}

					// Initialize the book database with some test books:
					g = test.Static.Method(typeof(void), "AddBooks").Parameter(BookDBLocal, "bookDB");
					{
                        var bookDb = g.Arg("bookDB");

						g.Invoke(bookDb, "AddBook", "The C Programming Language",
						  "Brian W. Kernighan and Dennis M. Ritchie", 19.95m, true);
						g.Invoke(bookDb, "AddBook", "The Unicode Standard 2.0",
						   "The Unicode Consortium", 39.95m, true);
						g.Invoke(bookDb, "AddBook", "The MS-DOS Encyclopedia",
						   "Ray Duncan", 129.95m, false);
						g.Invoke(bookDb, "AddBook", "Dogbert's Clues for the Clueless",
						   "Scott Adams", 12.00m, true);
					}

					// Execution starts here.
					g = test.Public.Static.Method(typeof(void), "Main");
					{
                        var bookDb = g.Local(exp.New(BookDBLocal));

						// Initialize the database with some books:
						g.Invoke(test, "AddBooks", bookDb);

						// Print all the titles of paperbacks:
						g.WriteLine("Paperback Book Titles:");
						// Create a new delegate object associated with the static 
						// method Test.PrintTitle:
						g.Invoke(bookDb, "ProcessPaperbackBooks", (Operand)exp.NewDelegate(processBookDelegate, test, "PrintTitle"));

                        // Get the average price of a paperback by using
                        // a PriceTotaller object:
                        var totaller = g.Local(exp.New(priceTotaller));
						// Create a new delegate object associated with the nonstatic 
						// method AddBookToTotal on the object totaller:
						g.Invoke(bookDb, "ProcessPaperbackBooks", (Operand)exp.NewDelegate(processBookDelegate, totaller, "AddBookToTotal"));
						g.WriteLine("Average Paperback Book Price: ${0:#.##}",
						   totaller.Invoke("AveragePrice"));
					}
				}
			}
		}
예제 #22
0
        // example based on the MSDN Properties Sample (abstractshape.cs, shapes.cs, shapetest.cs)
        public static void GenShapeTest(AssemblyGen ag)
		{
            var st = ag.StaticFactory;
            var exp = ag.ExpressionFactory;

            ITypeMapper m = ag.TypeMapper;
		    // abstractshape.cs
		    TypeGen Shape = ag.Public.Abstract.Class("Shape");
		    {
				FieldGen myId = Shape.Private.Field(typeof(string), "myId");

				PropertyGen Id = Shape.Public.SimpleProperty(myId, "Id");

				CodeGen g = Shape.Public.Constructor().Parameter(typeof(string), "s");
				{
					g.Assign(Id, g.Arg("s"));	// calling the set accessor of the Id property
				}

				// Area is a read-only property - only a get accessor is needed:
				PropertyGen Area = Shape.Public.Abstract.Property(typeof(double), "Area");
				Area.Getter();

				g = Shape.Public.Override.Method(typeof(string), "ToString");
				{
					g.Return(Id + " Area = " + st.Invoke(typeof(string), "Format", "{0:F2}", Area));
				}
			}

			// shapes.cs
			TypeGen Square = ag.Public.Class("Square", Shape);
			{
				FieldGen mySide = Square.Private.Field(typeof(int), "mySide");

				CodeGen g = Square.Public.Constructor().Parameter(typeof(int), "side").Parameter(typeof(string), "id");
				{
					g.InvokeBase(g.Arg("id"));
					g.Assign(mySide, g.Arg("side"));
				}

				PropertyGen Area = Square.Public.Override.Property(typeof(double), "Area");
				g = Area.Getter();
				{
					// Given the side, return the area of a square:
					g.Return(mySide * mySide);
				}
			}

			TypeGen Circle = ag.Public.Class("Circle", Shape);
			{
				FieldGen myRadius = Circle.Private.Field(typeof(int), "myRadius");

				CodeGen g = Circle.Public.Constructor().Parameter(typeof(int), "radius").Parameter(typeof(string), "id");
				{
					g.InvokeBase(g.Arg("id"));
					g.Assign(myRadius, g.Arg("radius"));
				}

				PropertyGen Area = Circle.Public.Override.Property(typeof(double), "Area");
				g = Area.Getter();
				{
					// Given the radius, return the area of a circle:
					g.Return(myRadius * myRadius * Math.PI);
				}
			}

			TypeGen Rectangle = ag.Public.Class("Rectangle", Shape);
			{
				FieldGen myWidth = Rectangle.Private.Field(typeof(int), "myWidth");
				FieldGen myHeight = Rectangle.Private.Field(typeof(int), "myHeight");

				CodeGen g = Rectangle.Public.Constructor()
					.Parameter(typeof(int), "width")
					.Parameter(typeof(int), "height")
					.Parameter(typeof(string), "id")
					;
				{
					g.InvokeBase(g.Arg("id"));
					g.Assign(myWidth, g.Arg("width"));
					g.Assign(myHeight, g.Arg("height"));
				}

				PropertyGen Area = Rectangle.Public.Override.Property(typeof(double), "Area");
				g = Area.Getter();
				{
					// Given the width and height, return the area of a rectangle:
					g.Return(myWidth * myHeight);
				}
			}

			// shapetest.cs
			TypeGen TestClass = ag.Public.Class("TestClass");
			{
				CodeGen g = TestClass.Public.Static.Method(typeof(void), "Main");
				{
                    var shapes = g.Local(exp.NewInitializedArray(Shape,
						exp.New(Square, 5, "Square #1"),
						exp.New(Circle, 3, "Circle #1"),
						exp.New(Rectangle, 4, 5, "Rectangle #1")));

					g.WriteLine("Shapes Collection");
					Operand s = g.ForEach(Shape, shapes);
					{
						g.WriteLine(s);
					}
					g.End();
				}
			}
		}
예제 #23
0
			public NamespaceContext(AssemblyGen ag)
			{
				_ag = ag;
				_oldNs = ag._ns;
			}
예제 #24
0
		// example based on the MSDN Structs Sample (struct2.cs)
		public static void GenStruct2(AssemblyGen ag)
        {
            var st = ag.StaticFactory;
            var exp = ag.ExpressionFactory;

            TypeGen TheClass = ag.Class("TheClass");
			{
				TheClass.Public.Field(typeof(int), "x");
			}

			TypeGen TheStruct = ag.Struct("TheStruct");
			{
				TheStruct.Public.Field(typeof(int), "x");
			}

			TypeGen TestClass = ag.Class("TestClass");
			{
				CodeGen g = TestClass.Public.Static.Method(typeof(void), "structtaker").Parameter(TheStruct, "s");
			    {
			        ITypeMapper typeMapper = ag.TypeMapper;
			        g.Assign(g.Arg("s").Field("x"), 5);
			    }

			    g = TestClass.Public.Static.Method(typeof(void), "classtaker").Parameter(TheClass, "c");
			    {
			        ITypeMapper typeMapper = ag.TypeMapper;
			        g.Assign(g.Arg("c").Field("x"), 5);
			    }

			    g = TestClass.Public.Static.Method(typeof(void), "Main");
				{
                    var a = g.Local(TheStruct);
					g.InitObj(a);
				    ITypeMapper typeMapper4 = ag.TypeMapper;
				    var b = g.Local(exp.New(TheClass));

				    ITypeMapper typeMapper = ag.TypeMapper;
				    g.Assign(a.Field("x"), 1);
				    ITypeMapper typeMapper2 = ag.TypeMapper;
				    g.Assign(b.Field("x"), 1);
					g.Invoke(TestClass, "structtaker", a);
					g.Invoke(TestClass, "classtaker", b);
				    ITypeMapper typeMapper3 = ag.TypeMapper;
				    g.WriteLine("a.x = {0}", a.Field("x"));
				    ITypeMapper typeMapper1 = ag.TypeMapper;
				    g.WriteLine("b.x = {0}", b.Field("x"));
				}
			}
		}
예제 #25
0
        // example based on the MSDN User-Defined Conversions Sample (conversion.cs)
        public static void GenConversion(AssemblyGen ag)
		{
            var st = ag.StaticFactory;
            var exp = ag.ExpressionFactory;

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

				CodeGen g = RomanNumeral.Public.Constructor().Parameter(typeof(int), "value");
				{
					g.Assign(value, g.Arg("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("value")));
				}

				// Declare an explicit conversion from a RomanNumeral to an int:
				g = RomanNumeral.Public.ExplicitConversionTo(typeof(int), "roman");
			    {
			        ITypeMapper typeMapper = ag.TypeMapper;
			        g.Return(g.Arg("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");
				{
                    var 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:
                    var s = g.Local(numeral.Cast(typeof(short)));

					g.WriteLine(s);
				}
			}
		}
예제 #26
0
        // example based on the MSDN Delegates Sample (compose.cs)
        public static void GenCompose(AssemblyGen ag)
        {
            var st = ag.StaticFactory;
            var exp = ag.ExpressionFactory;

            TypeGen myDelegate = ag.Delegate(typeof(void), "MyDelegate").Parameter(typeof(string), "string");

			TypeGen myClass = ag.Class("MyClass");
			{
				CodeGen g = myClass.Public.Static.Method(typeof(void), "Hello").Parameter(typeof(string), "s");
				{
					g.WriteLine("  Hello, {0}!", g.Arg("s"));
				}

				g = myClass.Public.Static.Method(typeof(void), "Goodbye").Parameter(typeof(string), "s");
				{
					g.WriteLine("  Goodbye, {0}!", g.Arg("s"));
				}

				g = myClass.Public.Static.Method(typeof(void), "Main");
				{
					ContextualOperand a = g.Local(), b = g.Local(), c = g.Local(), d = g.Local();

					// Create the delegate object a that references 
					// the method Hello:
				    ITypeMapper typeMapper = ag.TypeMapper;
				    g.Assign(a, exp.NewDelegate(myDelegate, myClass, "Hello"));
					// Create the delegate object b that references 
					// the method Goodbye:
				    ITypeMapper typeMapper1 = ag.TypeMapper;
				    g.Assign(b, exp.NewDelegate(myDelegate, myClass, "Goodbye"));
					// The two delegates, a and b, are composed to form c, 
					// which calls both methods in order:
					g.Assign(c, a + b);
					// Remove a from the composed delegate, leaving d, 
					// which calls only the method Goodbye:
					g.Assign(d, c - a);

					g.WriteLine("Invoking delegate a:");
					g.InvokeDelegate(a, "A");
					g.WriteLine("Invoking delegate b:");
					g.InvokeDelegate(b, "B");
					g.WriteLine("Invoking delegate c:");
					g.InvokeDelegate(c, "C");
					g.WriteLine("Invoking delegate d:");
					g.InvokeDelegate(d, "D");
				}
			}
		}
예제 #27
0
        public static void GenIndexer(AssemblyGen ag)
        {
            var st = ag.StaticFactory;
            var exp = ag.ExpressionFactory;

            ITypeMapper m = ag.TypeMapper;
            // Class to provide access to a large file
            // as if it were a byte array.
            TypeGen FileByteArray = ag.Public.Class("FileByteArray");
            {
                FieldGen stream = FileByteArray.Field(typeof(Stream), "stream"); // Holds the underlying stream
                // used to access the file.

                // Create a new FileByteArray encapsulating a particular file.
                CodeGen g = FileByteArray.Public.Constructor().Parameter(typeof(string), "fileName");
                {
                    //g.WriteLine(st.Invoke(typeof(File),"ReadAllText", g.Arg("fileName")));
                    g.Assign(stream, exp.New(typeof(FileStream), g.Arg("fileName"), FileMode.Open));
                }

                // Close the stream. This should be the last thing done
                // when you are finished.
                g = FileByteArray.Public.Method(typeof(void), "Close");
                {
                    g.Invoke(stream, "Close");
                    g.Assign(stream, null);
                }

                // Indexer to provide read/write access to the file.
                PropertyGen Item = FileByteArray.Public.Indexer(typeof(byte)).Index(typeof(long), "index"); // long is a 64-bit integer
                {
                    // Read one byte at offset index and return it.
                    g = Item.Getter();
                    {
                        var buffer = g.Local(exp.NewArray(typeof(byte), 1));
                        g.Invoke(stream, "Seek", g.Arg("index"), SeekOrigin.Begin);
                        g.Invoke(stream, "Read", buffer, 0, 1);
                        g.Return(buffer[0]);
                    }
                    // Write one byte at offset index and return it.
                    g = Item.Setter();
                    {
                        var buffer = g.Local(exp.NewInitializedArray(typeof(byte), g.PropertyValue()));
                        g.Invoke(stream, "Seek", g.Arg("index"), SeekOrigin.Begin);
                        g.Invoke(stream, "Write", buffer, 0, 1);
                    }
                }

                // Get the total length of the file.
                FileByteArray.Public.Property(typeof(long), "Length").Getter().GetCode()
                    .Return(stream.Invoke("Seek", m, 0, SeekOrigin.End));
            }

            // Demonstrate the FileByteArray class.
            // Reverses the bytes in a file.
            TypeGen Reverse = ag.Public.Class("Reverse");
            {
                CodeGen g = Reverse.Public.Static.Method(typeof(void), "Main").Parameter(typeof(string[]), "args");
                {
                    var args = g.Arg("args");

                    // Check for arguments.
                    g.If(args.ArrayLength() != 1);
                    {
                        g.WriteLine("Usage : Indexer <filename>");
                        g.Return();
                    }
                    g.End();

                    // Check for file existence
                    g.If(!st.Invoke(typeof(File), "Exists", args[0]));
                    {
                        g.WriteLine("File " + args[0] + " not found.");
                        g.Return();
                    }
                    g.End();

                    var file = g.Local(exp.New(FileByteArray, args[0]));
                    var len = g.Local(file.Property("Length"));

                    // Swap bytes in the file to reverse it.
                    var i = g.Local(typeof(long));
                    g.For(i.Assign(0), i < len / 2, i.Increment());
                    {
                        var t = g.Local();

                        // Note that indexing the "file" variable invokes the
                        // indexer on the FileByteStream class, which reads
                        // and writes the bytes in the file.
                        g.Assign(t, file[i]);
                        g.Assign(file[i], file[len - i - 1]);
                        g.Assign(file[len - i - 1], t);
                    }
                    g.End();

                    g.Invoke(file, "Close");
                }
            }
        }
			public NamespaceContext(AssemblyGen ag)
			{
				this.ag = ag;
				this.oldNs = ag.ns;
			}
 void GetStructNotImpl(AssemblyGen ag)
 {
     StructImpl(ag, false);
 }
예제 #30
0
        // example based on the MSDN Indexed Properties Sample (indexedproperty.cs)
        public static void GenIndexedProperty(AssemblyGen ag)
		{
            var st = ag.StaticFactory;
            var exp = ag.ExpressionFactory;

            CodeGen g;
		    ITypeMapper m = ag.TypeMapper;
		    
            TypeGen Document = ag.Public.Class("Document");
		    {
				FieldGen TextArray = Document.Private.Field(typeof(char[]), "TextArray");  // The text of the document.

				// Type allowing the document to be viewed like an array of words:
				TypeGen WordCollection = Document.Public.Class("WordCollection");
				{
					FieldGen document = WordCollection.ReadOnly.Field(Document, "document");    // The containing document
                    var document_TextArray = document.Field("TextArray", m);	// example of a saved expression - it is always re-evaluated when used

					g = WordCollection.Internal.Constructor().Parameter(Document, "d");
					{
						g.Assign(document, g.Arg("d"));
					}

					// Helper function -- search character array "text", starting at
					// character "begin", for word number "wordCount." Returns false
					// if there are less than wordCount words.Sets "start" and
					// length" to the position and length of the word within text:
					g = WordCollection.Private.Method(typeof(bool), "GetWord")
						.Parameter(typeof(char[]), "text")
						.Parameter(typeof(int), "begin")
						.Parameter(typeof(int), "wordCount")
						.Out.Parameter(typeof(int), "start")
						.Out.Parameter(typeof(int), "length")
						;
					{
						ContextualOperand text = g.Arg("text"), begin = g.Arg("begin"), wordCount = g.Arg("wordCount"),
							start = g.Arg("start"), length = g.Arg("length");

                        var end = g.Local(text.ArrayLength());
                        var count = g.Local(0);
                        var inWord = g.Local(-1);
						g.Assign(start, length.Assign(0));

                        var i = g.Local();
						g.For(i.Assign(begin), i <= end, i.Increment());
						{
                            var isLetter = g.Local(i < end && st.Invoke(typeof(char), "IsLetterOrDigit", text[i]));

							g.If(inWord >= 0);
							{
								g.If(!isLetter);
								{
									g.If(count.PostIncrement() == wordCount);
									{
										g.Assign(start, inWord);
										g.Assign(length, i - inWord);
										g.Return(true);
									}
									g.End();

									g.Assign(inWord, -1);
								}
								g.End();
							}
							g.Else();
							{
								g.If(isLetter);
								{
									g.Assign(inWord, i);
								}
								g.End();
							}
							g.End();
						}
						g.End();

						g.Return(false);
					}

					// Indexer to get and set words of the containing document:
					PropertyGen Item = WordCollection.Public.Indexer(typeof(string)).Index(typeof(int), "index");
					{
						g = Item.Getter();
						{
                            var index = g.Arg("index");

                            var start = g.Local(0);
                            var length = g.Local(0);

							g.If(g.This().Invoke("GetWord", document_TextArray, 0, index, start.Ref(), length.Ref()));
							{
								g.Return(exp.New(typeof(string), document_TextArray, start, length));
							}
							g.Else();
							{
								g.Throw(exp.New(typeof(IndexOutOfRangeException)));
							}
							g.End();
						}
						g = Item.Setter();
						{
                            var index = g.Arg("index");
                            var value = g.PropertyValue();

                            var start = g.Local(0);
                            var length = g.Local(0);

							g.If(g.This().Invoke("GetWord", document_TextArray, 0, index, start.Ref(), length.Ref()));
							{
								// Replace the word at start/length with the 
								// string "value":
								g.If(length == value.Property("Length"));
								{
									g.Invoke(typeof(Array), "Copy", value.Invoke("ToCharArray"), 0,
										document_TextArray, start, length);
								}
								g.Else();
								{
                                    var newText = g.Local(exp.NewArray(typeof(char),
										document_TextArray.ArrayLength() + value.Property("Length") - length));

									g.Invoke(typeof(Array), "Copy", document_TextArray, 0, newText,
										0, start);
									g.Invoke(typeof(Array), "Copy", value.Invoke("ToCharArray"), 0, newText,
										start, value.Property("Length"));
									g.Invoke(typeof(Array), "Copy", document_TextArray, start + length,
										newText, start + value.Property("Length"),
										document_TextArray.ArrayLength() - start
										- length);
									g.Assign(document_TextArray, newText);
								}
								g.End();
							}
							g.Else();
							{
								g.Throw(exp.New(typeof(IndexOutOfRangeException)));
							}
							g.End();
						}
					}

					// Get the count of words in the containing document:
					g = WordCollection.Public.Property(typeof(int), "Count").Getter();
					{
						ContextualOperand count = g.Local(0), start = g.Local(0), length = g.Local(0);

						g.While(g.This().Invoke("GetWord", document_TextArray, start + length, 0, start.Ref(), length.Ref()));
						{
							g.Increment(count);
						}
						g.End();

						g.Return(count);
					}
				}

				// Type allowing the document to be viewed like an "array" 
				// of characters:
				TypeGen CharacterCollection = Document.Public.Class("CharacterCollection");
				{
					FieldGen document = CharacterCollection.ReadOnly.Field(Document, "document");   // The containing document
                    var document_TextArray = document.Field("TextArray", m);

					g = CharacterCollection.Internal.Constructor().Parameter(Document, "d");
					{
						g.Assign(document, g.Arg("d"));
					}

					// Indexer to get and set characters in the containing document:
					PropertyGen Item = CharacterCollection.Public.Indexer(typeof(char)).Index(typeof(int), "index");
					{
						g = Item.Getter();
						{
							g.Return(document_TextArray[g.Arg("index")]);
						}
						g = Item.Setter();
						{
							g.Assign(document_TextArray[g.Arg("index")], g.PropertyValue());
						}
					}

					// Get the count of characters in the containing document:
					g = CharacterCollection.Public.Property(typeof(int), "Count").Getter();
					{
						g.Return(document_TextArray.ArrayLength());
					}
				}

				// Because the types of the fields have indexers, 
				// these fields appear as "indexed properties":
				FieldGen Words = Document.Public.ReadOnly.Field(WordCollection, "Words");
				FieldGen Characters = Document.Public.ReadOnly.Field(CharacterCollection, "Characters");

				g = Document.Public.Constructor().Parameter(typeof(string), "initialText");
				{
					g.Assign(TextArray, g.Arg("initialText").Invoke("ToCharArray"));
					g.Assign(Words, exp.New(WordCollection, g.This()));
					g.Assign(Characters, exp.New(CharacterCollection, g.This()));
				}

				g = Document.Public.Property(typeof(string), "Text").Getter();
				{
					g.Return(exp.New(typeof(string), TextArray));
				}
			}

			TypeGen Test = ag.Class("Test");
			{
				g = Test.Public.Static.Method(typeof(void), "Main");
				{
					var d = g.Local(exp.New(Document, "peter piper picked a peck of pickled peppers. How many pickled peppers did peter piper pick?"));

                    // Change word "peter" to "penelope":
                    var i = g.Local();
					g.For(i.Assign(0), i < d.Field("Words").Property("Count"), i.Increment());
					{
						g.If(d.Field("Words")[i] == "peter");
						{
							g.Assign(d.Field("Words")[i], "penelope");
						}
						g.End();
					}
					g.End();

					// Change character "p" to "P"
					g.For(i.Assign(0), i < d.Field("Characters").Property("Count"), i.Increment());
					{
						g.If(d.Field("Characters")[i] == 'p');
						{
							g.Assign(d.Field("Characters")[i], 'P');
						}
						g.End();
					}
					g.End();

					g.WriteLine(d.Property("Text"));
				}
			}
		}
예제 #31
0
 public NamespaceContext(AssemblyGen ag)
 {
     this.ag    = ag;
     this.oldNs = ag.ns;
 }
예제 #32
0
        // example based on the MSDN Collection Classes Sample (tokens2.cs)
        public static void GenTokens2(AssemblyGen ag)
		{
            var st = ag.StaticFactory;
            var exp = ag.ExpressionFactory;

            ITypeMapper m = ag.TypeMapper;
            TypeGen Tokens = ag.Public.Class("Tokens", typeof(object), m.MapType(typeof(IEnumerable)));
			{
				FieldGen elements = Tokens.Private.Field(typeof(string[]), "elements");

				CodeGen g = Tokens.Constructor()
					.Parameter(typeof(string), "source")
					.Parameter(typeof(char[]), "delimiters")
					;
			    {
					g.Assign(elements, g.Arg("source").Invoke("Split", new[] { g.Arg("delimiters") }));
				}

				// Inner class implements IEnumerator interface:

				TypeGen TokenEnumerator = Tokens.Public.Class("TokenEnumerator", typeof(object), m.MapType(typeof(IEnumerator)));
				{
					FieldGen position = TokenEnumerator.Field(typeof(int), "position", -1);
					FieldGen t = TokenEnumerator.Field(Tokens, "t");

					g = TokenEnumerator.Public.Constructor().Parameter(Tokens, "tokens");
					{
						g.Assign(t, g.Arg("tokens"));
					}

					g = TokenEnumerator.Public.Method(typeof(bool), "MoveNext");
					{
						g.If(position < t.Field("elements", m).ArrayLength() - 1);
						{
							g.Increment(position);
							g.Return(true);
						}
						g.Else();
						{
							g.Return(false);
						}
						g.End();
					}

					g = TokenEnumerator.Public.Method(typeof(void), "Reset");
					{
						g.Assign(position, -1);
					}

					// non-IEnumerator version: type-safe
					g = TokenEnumerator.Public.Property(typeof(string), "Current").Getter();
					{
						g.Return(t.Field("elements", m)[position]);
					}

					// IEnumerator version: returns object
					g = TokenEnumerator.Public.PropertyImplementation(typeof(IEnumerator), typeof(object), "Current").Getter();
					{
						g.Return(t.Field("elements", m)[position]);
					}
				}

				// IEnumerable Interface Implementation:

				// non-IEnumerable version
				g = Tokens.Public.Method(TokenEnumerator, "GetEnumerator");
				{
					g.Return(exp.New(TokenEnumerator, g.This()));
				}

				// IEnumerable version
				g = Tokens.Public.MethodImplementation(typeof(IEnumerable), typeof(IEnumerator), "GetEnumerator");
				{
					g.Return(exp.New(TokenEnumerator, g.This()).Cast(typeof(IEnumerator)));
				}

				// Test Tokens, TokenEnumerator

				g = Tokens.Static.Method(typeof(void), "Main");
				{
                    var f = g.Local(exp.New(Tokens, "This is a well-done program.",
						exp.NewInitializedArray(typeof(char), ' ', '-')));
                    var item = g.ForEach(typeof(string), f);	// try changing string to int
					{
						g.WriteLine(item);
					}
					g.End();
				}
			}
		}
예제 #33
0
        // example based on the MSDN Events Sample (events1.cs)
        public static void GenEvents1(AssemblyGen ag)
        {
            var st = ag.StaticFactory;
            var exp = ag.ExpressionFactory;

            ITypeMapper m = ag.TypeMapper;
		    TypeGen ChangedEventHandler, ListWithChangedEvent;

		    using (ag.Namespace("MyCollections"))
			{
				// A delegate type for hooking up change notifications.
				ChangedEventHandler = ag.Delegate(typeof(void), "ChangedEventHandler").Parameter(typeof(object), "sender").Parameter(typeof(EventArgs), "e");

				// A class that works just like ArrayList, but sends event
				// notifications whenever the list changes.
				ListWithChangedEvent = ag.Public.Class("ListWithChangedEvent", typeof(ArrayList));
				{
					// An event that clients can use to be notified whenever the
					// elements of the list change.
					EventGen Changed = ListWithChangedEvent.Public.Event(ChangedEventHandler, "Changed");

					// Invoke the Changed event; called whenever list changes
					CodeGen g = ListWithChangedEvent.Protected.Virtual.Method(typeof(void), "OnChanged").Parameter(typeof(EventArgs), "e");
					{
						g.If(Changed != null);
						{
							g.InvokeDelegate(Changed, g.This(), g.Arg("e"));
						}
						g.End();
					}

					// Override some of the methods that can change the list;
					// invoke event after each
					g = ListWithChangedEvent.Public.Override.Method(typeof(int), "Add").Parameter(typeof(object), "value");
					{
                        var i = g.Local(g.Base().Invoke("Add", new[] { g.Arg("value") }));
						g.Invoke(g.This(), "OnChanged", st.Field(typeof(EventArgs), "Empty"));
						g.Return(i);
					}

					g = ListWithChangedEvent.Public.Override.Method(typeof(void), "Clear");
					{
						g.Invoke(g.Base(), "Clear");
						g.Invoke(g.This(), "OnChanged", st.Field(typeof(EventArgs), "Empty"));
					}

					g = ListWithChangedEvent.Public.Override.Indexer(typeof(object)).Index(typeof(int), "index").Setter();
					{
						g.Assign(g.Base()[g.Arg("index")], g.PropertyValue());
						g.Invoke(g.This(), "OnChanged", st.Field(typeof(EventArgs), "Empty"));
					}
				}
			}

			using (ag.Namespace("TestEvents"))
			{
				TypeGen EventListener = ag.Class("EventListener");
				{
					FieldGen List = EventListener.Field(ListWithChangedEvent, "List");

					// This will be called whenever the list changes.
					CodeGen g = EventListener.Private.Method(typeof(void), "ListChanged").Parameter(typeof(object), "sender").Parameter(typeof(EventArgs), "eventArgs");
					{
						g.WriteLine("This is called when the event fires.");
					}

					g = EventListener.Public.Constructor().Parameter(ListWithChangedEvent, "list");
					{
						g.Assign(List, g.Arg("list"));
						// Add "ListChanged" to the Changed event on "List".
						g.SubscribeEvent(List, "Changed", exp.NewDelegate(ChangedEventHandler, g.This(), "ListChanged"));
					}

					g = EventListener.Public.Method(typeof(void), "Detach");
					{
						// Detach the event and delete the list
						g.UnsubscribeEvent(List, "Changed", exp.NewDelegate(ChangedEventHandler, g.This(), "ListChanged"));
						g.Assign(List, null);
					}
				}

				TypeGen Test = ag.Class("Test");
				{
					// Test the ListWithChangedEvent class.
					CodeGen g = Test.Public.Static.Method(typeof(void), "Main");
					{
                        // Create a new list.
                        var list = g.Local(exp.New(ListWithChangedEvent));

                        // Create a class that listens to the list's change event.
                        var listener = g.Local(exp.New(EventListener, list));

						// Add and remove items from the list.
						g.Invoke(list, "Add", "item 1");
						g.Invoke(list, "Clear");
						g.Invoke(listener, "Detach");
					}
				}
			}
		}
예제 #34
0
        // example based on the MSDN User-Defined Conversions Sample (structconversion.cs)
        public static void GenStructConversion(AssemblyGen ag)
        {
            var st = ag.StaticFactory;
            var exp = ag.ExpressionFactory;

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

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

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

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

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

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

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

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

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

				g = RomanNumeral.Public.ExplicitConversionTo(typeof(int), "roman");
			    {
			        ITypeMapper typeMapper = ag.TypeMapper;
			        g.Return(g.Arg("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");
				{
                    var roman = g.Local(RomanNumeral);
					g.Assign(roman, 10);
                    var 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);
				}
			}
		}
예제 #35
0
        public static AssemblyGen AG(this AstContext context)
        {
            Object obj;
            if (context.Values.TryGetValue(RunSharpContext.Key, out obj))
            {
                return obj as AssemblyGen;
            }

            // We should never reach here, and the AssemblyGen is created by the ScopePreparer
            var ag = new AssemblyGen(@"C:\Users\User\Projects\Shakespeare\Executables\Debug\output.exe", true);
            context.Values.Add(RunSharpContext.Key, ag);
            return ag;
        }
예제 #36
0
 public NamespaceContext(AssemblyGen ag)
 {
     _ag    = ag;
     _oldNs = ag._ns;
 }
        // example based on the MSDN Operator Overloading Sample (dbbool.cs)
        public static void GenDbBool(AssemblyGen ag)
        {
            var st = ag.StaticFactory;
            var exp = ag.ExpressionFactory;

            ITypeMapper m = ag.TypeMapper;
            TypeGen DBBool = ag.Public.Struct("DBBool");
			{
				// Private field that stores -1, 0, 1 for dbFalse, dbNull, dbTrue:
				FieldGen value = DBBool.Field(typeof(int), "value");

				// Private constructor. The value parameter must be -1, 0, or 1:
				CodeGen g = DBBool.Constructor().Parameter(typeof(int), "value");
				{
					g.Assign(value, g.Arg("value"));
				}

				// The three possible DBBool values:
			    FieldGen dbNull = DBBool.Public.Static.ReadOnly.Field(DBBool, "dbNull", exp.New(DBBool, 0));
				FieldGen dbFalse = DBBool.Public.Static.ReadOnly.Field(DBBool, "dbFalse", exp.New(DBBool, -1));
				FieldGen dbTrue = DBBool.Public.Static.ReadOnly.Field(DBBool, "dbTrue", exp.New(DBBool, 1));

				// Implicit conversion from bool to DBBool. Maps true to 
				// DBBool.dbTrue and false to DBBool.dbFalse:
				g = DBBool.ImplicitConversionFrom(typeof(bool), "x");
				{
                    var x = g.Arg("x");
					g.Return(x.Conditional(dbTrue, dbFalse));
				}

				// Explicit conversion from DBBool to bool. Throws an 
				// exception if the given DBBool is dbNull, otherwise returns
				// true or false:
				g = DBBool.ExplicitConversionTo(typeof(bool), "x");
				{
                    var x = g.Arg("x");
					g.If(x.Field("value") == 0);
					{
						g.Throw(exp.New(typeof(InvalidOperationException)));
					}
					g.End();

					g.Return(x.Field("value") > 0);
				}

				// Equality operator. Returns dbNull if either operand is dbNull, 
				// otherwise returns dbTrue or dbFalse:
				g = DBBool.Operator(Operator.Equality, DBBool, DBBool, "x", DBBool, "y");
			    {
			        var x = g.Arg("x");
                    var y = g.Arg("y");
					g.If(x.Field("value") == 0 || y.Field("value") == 0);
					{
						g.Return(dbNull);
					}
					g.End();

					g.Return((x.Field("value") == y.Field("value")).Conditional(dbTrue, dbFalse));
				}

				// Inequality operator. Returns dbNull if either operand is
				// dbNull, otherwise returns dbTrue or dbFalse:
				g = DBBool.Operator(Operator.Inequality, DBBool, DBBool, "x", DBBool, "y");
			    {
			        var x = g.Arg("x");
                    var y = g.Arg("y");
					g.If(x.Field("value") == 0 || y.Field("value") == 0);
					{
						g.Return(dbNull);
					}
					g.End();

					g.Return((x.Field("value") != y.Field("value")).Conditional(dbTrue, dbFalse));
				}

				// Logical negation operator. Returns dbTrue if the operand is 
				// dbFalse, dbNull if the operand is dbNull, or dbFalse if the
				// operand is dbTrue:
				g = DBBool.Operator(Operator.LogicalNot, DBBool, DBBool, "x");
				{
                    var x = g.Arg("x");
					g.Return(exp.New(DBBool, -x.Field("value")));
				}

				// Logical AND operator. Returns dbFalse if either operand is 
				// dbFalse, dbNull if either operand is dbNull, otherwise dbTrue:
				g = DBBool.Operator(Operator.And, DBBool, DBBool, "x", DBBool, "y");
			    {
			        var x = g.Arg("x");
                    var y = g.Arg("y");
					g.Return(exp.New(DBBool, (x.Field("value") < y.Field("value")).Conditional(x.Field("value"), y.Field("value"))));
				}

				// Logical OR operator. Returns dbTrue if either operand is 
				// dbTrue, dbNull if either operand is dbNull, otherwise dbFalse:
				g = DBBool.Operator(Operator.Or, DBBool, DBBool, "x", DBBool, "y");
			    {
			        var x = g.Arg("x");
                    var y = g.Arg("y");
					g.Return(exp.New(DBBool, (x.Field("value") > y.Field("value")).Conditional(x.Field("value"), y.Field("value"))));
				}

				// Definitely true operator. Returns true if the operand is 
				// dbTrue, false otherwise:
				g = DBBool.Operator(Operator.True, typeof(bool), DBBool, "x");
				{
                    var x = g.Arg("x");
					g.Return(x.Field("value") > 0);
				}

				// Definitely false operator. Returns true if the operand is 
				// dbFalse, false otherwise:
				g = DBBool.Operator(Operator.False, typeof(bool), DBBool, "x");
				{
                    var x = g.Arg("x");
					g.Return(x.Field("value") < 0);
				}

				// Overload the conversion from DBBool to string:
				g = DBBool.ImplicitConversionTo(typeof(string), "x");
				{
                    var x = g.Arg("x");

					g.Return((x.Field("value") > 0).Conditional("dbTrue",
						(x.Field("value") < 0).Conditional("dbFalse",
						                                      "dbNull")));
				}

				// Override the Object.Equals(object o) method:
				g = DBBool.Public.Override.Method(typeof(bool), "Equals").Parameter(typeof(object), "o");
				{
					g.Try();
					{
						g.Return((g.This() == g.Arg("o").Cast(DBBool)).Cast(typeof(bool)));
					}
					g.CatchAll();
					{
						g.Return(false);
					}
					g.End();
				}

				// Override the Object.GetHashCode() method:
				g = DBBool.Public.Override.Method(typeof(int), "GetHashCode");
				{
					g.Return(value);
				}

				// Override the ToString method to convert DBBool to a string:
				g = DBBool.Public.Override.Method(typeof(string), "ToString");
				{
					g.Switch(value);
					{
						g.Case(-1);
						g.Return("DBBool.False");
						g.Case(0);
						g.Return("DBBool.Null");
						g.Case(1);
						g.Return("DBBool.True");
						g.DefaultCase();
						g.Throw(exp.New(typeof(InvalidOperationException)));
					}
					g.End();
				}
			}

			TypeGen Test = ag.Class("Test");
			{
				CodeGen g = Test.Public.Static.Method(typeof(void), "Main");
				{
                    var a = g.Local(DBBool);
                    var b = g.Local(DBBool);
					g.Assign(a, st.Field(DBBool, "dbTrue"));
					g.Assign(b, st.Field(DBBool, "dbNull"));

					g.WriteLine("!{0} = {1}", a, !a);
					g.WriteLine("!{0} = {1}", b, !b);
					g.WriteLine("{0} & {1} = {2}", a, b, a & b);
					g.WriteLine("{0} | {1} = {2}", a, b, a | b);
					// Invoke the true operator to determine the Boolean 
					// value of the DBBool variable:
					g.If(b);
					{
						g.WriteLine("b is definitely true");
					}
					g.Else();
					{
						g.WriteLine("b is not definitely true");
					}
					g.End();
				}
			}
		}