Inheritance: CodeMemberMethod
        public void Run()
        {
            var compileUnit = new CodeCompileUnit();
            var myNamespace = new CodeNamespace("MyNamespace");
            myNamespace.Imports.Add(new CodeNamespaceImport("System"));
            var myClass = new CodeTypeDeclaration("MyClass");
            var start = new CodeEntryPointMethod();
            var cs1 = new CodeMethodInvokeExpression(
                new CodeTypeReferenceExpression("Console"),
                "WriteLine", new CodePrimitiveExpression("Hello World!"));

            compileUnit.Namespaces.Add(myNamespace);
            myNamespace.Types.Add(myClass);
            myClass.Members.Add(start);
            start.Statements.Add(cs1);

            var provider = new CSharpCodeProvider();

            using (var sw = new StreamWriter("HelloWorld.cs", false))
            {
                var tw = new IndentedTextWriter(sw, "    ");
                provider.GenerateCodeFromCompileUnit(compileUnit, tw,
                    new CodeGeneratorOptions());
                tw.Close();
            }
        }
Ejemplo n.º 2
0
        static void AddEntryPoint()
        {
            CodeEntryPointMethod start = new CodeEntryPointMethod();
            CodeObjectCreateExpression objectCreate =
                new CodeObjectCreateExpression(
                new CodeTypeReference("CodeDOMCreatedClass"),
                new CodePrimitiveExpression(5.3),
                new CodePrimitiveExpression(6.9));

            // Add the statement:
            // "CodeDOMCreatedClass testClass =
            //     new CodeDOMCreatedClass(5.3, 6.9);"
            start.Statements.Add(new CodeVariableDeclarationStatement(
                new CodeTypeReference("CodeDOMCreatedClass"), "testClass",
                objectCreate));

            // Creat the expression:
            // "testClass.ToString()"
            CodeMethodInvokeExpression toStringInvoke =
                new CodeMethodInvokeExpression(
                new CodeVariableReferenceExpression("testClass"), "ToString");

            // Add a System.Console.WriteLine statement with the previous
            // expression as a parameter.
            start.Statements.Add(new CodeMethodInvokeExpression(
                new CodeTypeReferenceExpression("System.Console"),
                "WriteLine", toStringInvoke));
            targetClass.Members.Add(start);
        }
Ejemplo n.º 3
0
        public CodeNamespace CreateCodeHelloDemo()
        {
            var method = new CodeMemberMethod();
            method.Name = "SayHello";
            method.Attributes = MemberAttributes.Public | MemberAttributes.Final;
            method.ReturnType = new CodeTypeReference(typeof(string));
            method.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression("Hello From Code!")));

            CodeEntryPointMethod main = new CodeEntryPointMethod();
            main.Statements.Add(new CodeVariableDeclarationStatement("HelloWord", "hw", new CodeObjectCreateExpression("HelloWord", new CodeExpression[] { })));

            CodeMethodInvokeExpression methodInvoke = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("hw"), "SayHello",  new CodeExpression[] { });
            main.Statements.Add(new CodeMethodInvokeExpression(new CodeTypeReferenceExpression("System.Console"),"WriteLine",methodInvoke));
            main.Statements.Add(new CodeMethodInvokeExpression(new CodeTypeReferenceExpression("System.Console"), "Read"));

            CodeTypeDeclaration helloword=new CodeTypeDeclaration("HelloWord");
            helloword.Attributes=MemberAttributes.Public;
            helloword.Members.AddRange(new CodeTypeMember[]{method,main});

            CodeNamespace nspace=new CodeNamespace("HelloDemo1");
            nspace.Imports.Add(new CodeNamespaceImport("System"));

            nspace.Types.Add(helloword);
            return nspace;
        }
Ejemplo n.º 4
0
        /// <summary>
        /// This is a simple helper method to create a test valid
        /// CodeObject to be feed into the 
        ///     CreateScriptSource(CodeObject content, string id)
        ///     
        /// However, CodeObject is simply a base class so we probably
        /// need a specific type of CodeObject but what?
        /// 
        /// [Bill - has indicate that CodeObject parameter for CreateScriptSource
        ///  does in fact need to be a CodeMemberMethod - Maybe a spec BUG]
        /// 
        /// Probably need to put this somewhere else maybe put this in:
        ///     ScriptEngineTestHelper.cs
        /// </summary>
        /// <returns>A valid CodeObject boxes some kind of CompileUnit</returns>
        private static CodeObject BuildCountCode()
        {
            // Create a new CodeCompileUnit to contain
            // the program graph.
            CodeCompileUnit compileUnit = new CodeCompileUnit();

            // Declare a new namespace called Samples.
            CodeNamespace samples = new CodeNamespace("Samples");
            // Add the new namespace to the compile unit.
            compileUnit.Namespaces.Add(samples);

            // Declare a new code entry point method.
            CodeEntryPointMethod start = new CodeEntryPointMethod();

            CodeConstructor codecon = new CodeConstructor();

            //
            CodeNamespace cns = new CodeNamespace("Test");
            CodeTypeDeclaration ctd = new CodeTypeDeclaration("testclass");
            ctd.IsClass = true;

            CodeMemberMethod method = new CodeMemberMethod();
            method.Attributes = MemberAttributes.Public | MemberAttributes.Final;
            method.Name = "AddTenToNumber";
            method.ReturnType = new CodeTypeReference("Int32");
            method.Parameters.Add(new CodeParameterDeclarationExpression("int", "number"));
            method.Statements.Add(new CodeSnippetExpression("return number+10"));
            ctd.Members.Add(method);

            samples.Types.Add(ctd);
            // If we return just the method this will not throw exception
            // on CreateScriptSource
            // return method;
            return compileUnit;
        }
Ejemplo n.º 5
0
        static void Main(string[] args)
        {
            CodeCompileUnit compileUnit = new CodeCompileUnit();
            CodeNamespace myNamespace = new CodeNamespace("MyNamespace");
            myNamespace.Imports.Add(new CodeNamespaceImport("System"));
            CodeTypeDeclaration myClass = new CodeTypeDeclaration("MyClass");
            CodeEntryPointMethod start = new CodeEntryPointMethod();
            CodeMethodInvokeExpression cs1 = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression("Console"), "WriteLine", new CodePrimitiveExpression("Hello World"));
            compileUnit.Namespaces.Add(myNamespace);
            myNamespace.Types.Add(myClass);
            myClass.Members.Add(start);
            start.Statements.Add(cs1);

            CSharpCodeProvider provider = new CSharpCodeProvider();

            using(StreamWriter sw = new StreamWriter("HelloWorld.cs", false))
            {
                IndentedTextWriter tw = new IndentedTextWriter(sw, " ");
                provider.GenerateCodeFromCompileUnit(compileUnit, tw, new CodeGeneratorOptions());
                tw.Close();
            }

            Console.WriteLine("HelloWorld.cs generated in .../bin/Debug or .../bin/Release project folders.");

            Console.Write("Press a key to exit");
            Console.ReadKey();
        }
Ejemplo n.º 6
0
        public void CompileGreeter()
        {
            Lexer lexer = new Lexer(@"
            PRINT ""Enter your name: ""
            name = INPUT()
            PRINT ""Hello, "" + name + ""!""
            ");

            CodeCompileUnit ccu = new CodeCompileUnit();
            CodeNamespace samples = new CodeNamespace("Samples");
            samples.Imports.Add(new CodeNamespaceImport("System"));

            CodeTypeDeclaration targetClass = new CodeTypeDeclaration("CreatedClass");
            targetClass.IsClass = true;
            targetClass.TypeAttributes = TypeAttributes.Public | TypeAttributes.Sealed;

            CodeEntryPointMethod start = new CodeEntryPointMethod();
            targetClass.Members.Add(start);

            var token = lexer.Next();
            if (token is SubCallToken)
            {
                SubCallToken subCallToken = (SubCallToken) token;
                if (subCallToken.Name == "PRINT")
                {
                    CodeMethodInvokeExpression cs1 = new CodeMethodInvokeExpression(
                        new CodeTypeReferenceExpression("Console"),
                        "WriteLine",
                        subCallToken.Arguments.Select(ConvertSubCallArgument).ToArray());
                    start.Statements.Add(cs1);
                }
            }

            samples.Types.Add(targetClass);

            ccu.Namespaces.Add(samples);

            CodeDomProvider provider = CodeDomProvider.CreateProvider("CSharp");
            CodeGeneratorOptions options = new CodeGeneratorOptions();
            options.BracingStyle = "C";
            StringWriter writer = new StringWriter();
            provider.GenerateCodeFromCompileUnit(ccu, writer, options);
            string result = writer.ToString();
            Console.WriteLine(result);

            //StringAssert.Contains(@"Console.WriteLine(""Enter your name: "");", result);

            var compileResults = provider.CompileAssemblyFromDom(new CompilerParameters(), ccu);
            Assert.IsNotNull(compileResults);
            Assert.AreEqual(0, compileResults.Errors.Count);

            Console.WriteLine(compileResults.PathToAssembly);
        }
Ejemplo n.º 7
0
        /// <summary>
        /// This function generates the default CodeCompileUnit template
        /// </summary>
        public CodeCompileUnit GetCodeCompileUnit(IDesignerHost host)
		{
            this.host = host;
            IDesignerHost idh = (IDesignerHost)this.host.GetService(typeof(IDesignerHost));
            root = idh.RootComponent;
            Hashtable nametable = new Hashtable(idh.Container.Components.Count);

            ns = new CodeNamespace("DesignerHostSample");
            myDesignerClass = new CodeTypeDeclaration();
            initializeComponent = new CodeMemberMethod();

            CodeCompileUnit code = new CodeCompileUnit();

            // Imports
            ns.Imports.Add(new CodeNamespaceImport("System"));
            ns.Imports.Add(new CodeNamespaceImport("System.ComponentModel"));
            ns.Imports.Add(new CodeNamespaceImport("System.Windows.Forms"));
            code.Namespaces.Add(ns);
            myDesignerClass = new CodeTypeDeclaration(root.Site.Name);
            myDesignerClass.BaseTypes.Add(typeof(Form).FullName);

            IDesignerSerializationManager manager = host.GetService(typeof(IDesignerSerializationManager)) as IDesignerSerializationManager;

            ns.Types.Add(myDesignerClass);

            // Constructor
            CodeConstructor con = new CodeConstructor();

            con.Attributes = MemberAttributes.Public;
            con.Statements.Add(new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), "InitializeComponent")));
            myDesignerClass.Members.Add(con);

            // Main
            CodeEntryPointMethod main = new CodeEntryPointMethod();

            main.Name = "Main";
            main.Attributes = MemberAttributes.Public | MemberAttributes.Static;
            main.CustomAttributes.Add(new CodeAttributeDeclaration("System.STAThreadAttribute"));
            main.Statements.Add(new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(typeof(System.Windows.Forms.Application)), "Run"), new CodeExpression[] {
				new CodeObjectCreateExpression(new CodeTypeReference(root.Site.Name))
			}));
            myDesignerClass.Members.Add(main);

            // InitializeComponent
            initializeComponent.Name = "InitializeComponent";
            initializeComponent.Attributes = MemberAttributes.Private;
            initializeComponent.ReturnType = new CodeTypeReference(typeof(void));
            initializeComponent.Statements.Add(new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "Text"), new CodePrimitiveExpression(root.Site.Name))); //roman//
            myDesignerClass.Members.Add(initializeComponent);
            codeCompileUnit = code;
            return codeCompileUnit;
		}
Ejemplo n.º 8
0
 public Script(string namespaceToGen, string className)
 {
     this.compileUnit = new CodeCompileUnit();
     this.codeNamespace = new CodeNamespace(namespaceToGen);
     this.compileUnit.Namespaces.Add(this.codeNamespace);
     this.codeClass = new CodeTypeDeclaration(className);
     this.codeNamespace.Types.Add(this.codeClass);
     this.proxySetting = ProxySettings.RequiredHeaders;
     this.mainMethod = new CodeEntryPointMethod();
     this.mainMethod.Name = "Main";
     this.mainMethod.Attributes = MemberAttributes.Public | MemberAttributes.Static;
     this.codeClass.Members.Add(this.mainMethod);
     this.dumpMethodRef = this.BuildDumper();
 }
Ejemplo n.º 9
0
        /// <summary>
        /// Compile the parse tree to CSharp.
        /// </summary>
        /// <returns></returns>
        private string Compile()
        {
            // this.buf = ['var interp'];
            _buf = new CodeEntryPointMethod();
            if (_pp)
                // _buf.Push("/* var __indent = []; */");
                _buf.Statements.Add(new CodeVariableDeclarationStatement("string[]", "__indent"));
            _lastBufferedIdx = 1;
            Visit(_node);

            var gen = new CSharpCodeProvider();
            var writer = new StringWriter();
            gen.GenerateCodeFromMember(_buf, writer, null);
            return writer.ToString();
        }
Ejemplo n.º 10
0
        static CodeCompileUnit HelloWorldCodeDOM()
        {
            CodeCompileUnit compileUnit = new CodeCompileUnit();
            CodeNamespace myNamespace = new CodeNamespace("MyNamespace");
            myNamespace.Imports.Add(new CodeNamespaceImport("System"));
            CodeTypeDeclaration myClass = new CodeTypeDeclaration("MyClass");
            CodeEntryPointMethod start = new CodeEntryPointMethod();
            CodeMethodInvokeExpression cs1 = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression("Console"), "WriteLine", new CodePrimitiveExpression("Hello World!"));

            compileUnit.Namespaces.Add(myNamespace);
            myNamespace.Types.Add(myClass);
            myClass.Members.Add(start);
            start.Statements.Add(cs1);

            return compileUnit;
        }
        public void Run()
        {
            var compileUnit = new CodeCompileUnit();
            var myNamespace = new CodeNamespace("MyNamespace");
            myNamespace.Imports.Add(new CodeNamespaceImport("System"));
            var myClass = new CodeTypeDeclaration("MyClass");
            var start = new CodeEntryPointMethod();
            var cs1 = new CodeMethodInvokeExpression(
                new CodeTypeReferenceExpression("Console"),
                "WriteLine", new CodePrimitiveExpression("Hello World!"));

            compileUnit.Namespaces.Add(myNamespace);
            myNamespace.Types.Add(myClass);
            myClass.Members.Add(start);
            start.Statements.Add(cs1);
        }
        public CodeCompileUnit GetCompierUnit()
        {
            CodeCompileUnit cu = new CodeCompileUnit();
            CodeNamespace cn = new CodeNamespace("MyNameSpace");
            cn.Imports.Add(new CodeNamespaceImport("System"));

            CodeTypeDeclaration myclass = new CodeTypeDeclaration("MyClass");
            CodeEntryPointMethod method = new CodeEntryPointMethod();
            CodeMethodInvokeExpression cs1 = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression("Console"), "WriteLine", new CodePrimitiveExpression("Hello World"));

            cu.Namespaces.Add(cn);
            cn.Types.Add(myclass);
            myclass.Members.Add(method);
            method.Statements.Add(cs1);
            return cu;
        }
        static void Main(string[] args)
        {
            //Create a provider
            CSharpCodeProvider provider = new CSharpCodeProvider();

            //Create a compile unit, root of object graph
            CodeCompileUnit compileUnit = new CodeCompileUnit();
            //The namespace we are goin
            CodeNamespace nameSpace = new CodeNamespace("CodeDOMExample");
            //Import system
            nameSpace.Imports.Add(new CodeNamespaceImport("System"));
            //add the namespace to the root graph
            compileUnit.Namespaces.Add(nameSpace);

            //program class
            CodeTypeDeclaration programClass = new CodeTypeDeclaration("Program");
            nameSpace.Types.Add(programClass);

            //Create an entry point for the application
            CodeEntryPointMethod entryPoint = new CodeEntryPointMethod();
            //Create expressions to first write a line and read a key
            CodeMethodInvokeExpression writeLnExpression = new CodeMethodInvokeExpression(
                new CodeTypeReferenceExpression("Console"),
                "WriteLine", new CodePrimitiveExpression("Hello World!!! Press any key to exit"));

            CodeMethodInvokeExpression readKeyExpression = new CodeMethodInvokeExpression(
                new CodeTypeReferenceExpression("Console"),
                "ReadKey",new CodePrimitiveExpression(false));

            //add these expressions to the method
            entryPoint.Statements.Add(writeLnExpression);
            entryPoint.Statements.Add(readKeyExpression);

            //Add the entry point
            programClass.Members.Add(entryPoint);

            //Save source file
            SaveSourceFile(provider, compileUnit);

            //Compile source file
            GenerateAssembly(provider, compileUnit);

            Console.ReadKey();
        }
Ejemplo n.º 14
0
        //Create main method
        private void CreateEntryPoint(List<string> statements)
        {
            //Create an object and assign the name as "Main"
            CodeEntryPointMethod mymain = new CodeEntryPointMethod();
            mymain.Name = "Main";
            //Mark the access modifier for the main method as Public and //static
            mymain.Attributes = MemberAttributes.Public | MemberAttributes.Static;
            //Change string to statements
            if(statements != null){

                foreach (string item in statements) {
                    if (item != null) {
                        CodeSnippetExpression exp1 = new CodeSnippetExpression(@item);
                        CodeExpressionStatement ces1 = new CodeExpressionStatement(exp1);
                        mymain.Statements.Add(ces1);
                    }
                }
            }
            myclass.Members.Add(mymain);
        }
Ejemplo n.º 15
0
        static void Main()
        {
            //
            // Demonstration of client calls to a JSON-RPC service.
            //
            
            JsonRpcClient client = new JsonRpcClient();
            client.Url = "http://www.raboof.com/projects/jayrock/demo.ashx";
            Console.WriteLine(client.Invoke("system.about"));
            Console.WriteLine(client.Invoke("system.version"));
            Console.WriteLine(string.Join(Environment.NewLine, (string[]) (new ArrayList((ICollection) client.Invoke("system.listMethods"))).ToArray(typeof(string))));
            Console.WriteLine(client.Invoke("now"));
            Console.WriteLine(client.Invoke("sum", 123, 456));
            Console.WriteLine(client.Invoke("total", new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 }));
            client.CookieContainer = new CookieContainer();
            Console.WriteLine(client.Invoke("counter"));
            Console.WriteLine(client.Invoke("counter"));

            //
            // Demonstration of a JsonWriter implementation (JsonCodeWriter) 
            // that writes code in terms of itself. So we take some JSON
            // text and covert it into the JsonWriter API.
            //

            CodeEntryPointMethod codeMainMethod = new CodeEntryPointMethod();
            codeMainMethod.Statements.Add(new CodeVariableDeclarationStatement(typeof(JsonWriter), "writer", new CodeObjectCreateExpression(typeof(EmptyJsonWriter))));

            JsonCodeWriter writer = new JsonCodeWriter(new CodeVariableReferenceExpression("writer"), codeMainMethod.Statements);
            writer.WriteFromReader(new JsonTextReader(new StringReader(@"
                { 
                    firstName : 'John', 
                    lastName : 'Doe' 
                }")));
            
            CodeTypeDeclaration codeType = new CodeTypeDeclaration("Program");
            codeType.Members.Add(codeMainMethod);
            
            CodeGeneratorOptions options = new CodeGeneratorOptions();
            GetLanguageProvider("c#").CreateGenerator().GenerateCodeFromType(codeType, Console.Out, options);
            GetLanguageProvider("vb").CreateGenerator().GenerateCodeFromType(codeType, Console.Out, options);
        }
Ejemplo n.º 16
0
Archivo: Program.cs Proyecto: nyet/nyet
        static void Main(string[] args)
        {
            CodeCompileUnit compileUnit = new CodeCompileUnit();

            CodeNamespace samples = new CodeNamespace("Samples");
            samples.Imports.Add(new CodeNamespaceImport("System"));
            compileUnit.Namespaces.Add(samples);

            CodeTypeDeclaration class1 = new CodeTypeDeclaration("Class1");
            samples.Types.Add(class1);

            CodeEntryPointMethod start = new CodeEntryPointMethod();
            /*
            CodeMethodInvokeExpression cs1 = new CodeMethodInvokeExpression(
                new CodeTypeReferenceExpression("System.Console"),
                "WriteLine", new CodePrimitiveExpression("Hello World!"));
            start.Statements.Add(cs1);
            */
            class1.Members.Add(start);

            GenerateCSharpCode(compileUnit);
        }
Ejemplo n.º 17
0
    public static System.CodeDom.CodeCompileUnit BuildGraph()
    {
        System.CodeDom.CodeCompileUnit CompileUnit = new System.CodeDom.CodeCompileUnit();

        System.CodeDom.CodeNamespace nSpace = new System.CodeDom.CodeNamespace("HelloWorldViaCodeDOM");
        CompileUnit.Namespaces.Add(nSpace);

        nSpace.Imports.Add(new System.CodeDom.CodeNamespaceImport("System"));

        System.CodeDom.CodeTypeDeclaration clsStartup = new System.CodeDom.CodeTypeDeclaration("Startup");
        nSpace.Types.Add(clsStartup);

        System.CodeDom.CodeEntryPointMethod        main   = new System.CodeDom.CodeEntryPointMethod();
        System.CodeDom.CodePrimitiveExpression     exp    = new System.CodeDom.CodePrimitiveExpression("Hello World!");
        System.CodeDom.CodeTypeReferenceExpression refExp = new System.CodeDom.CodeTypeReferenceExpression("System.Console");
        System.CodeDom.CodeMethodInvokeExpression  invoke = new System.CodeDom.CodeMethodInvokeExpression(refExp, "WriteLine", exp);
        main.Statements.Add(new System.CodeDom.CodeExpressionStatement(invoke));

        clsStartup.Members.Add(main);

        return(CompileUnit);
    }
Ejemplo n.º 18
0
        public void CreateEntryPoint(ref CodeTypeDeclaration customClass)
        {
            //Create an object and assign the name as “Main”
            CodeEntryPointMethod main = new CodeEntryPointMethod();
            main.Name = "Main";

            //Mark the access modifier for the main method as Public and //static
            main.Attributes = MemberAttributes.Public | MemberAttributes.Static;

            //Provide defenition to the main method.
            //Create an object of the “Cmyclass” and invoke the method
            //by passing the required parameters.
            CodeSnippetExpression exp = new CodeSnippetExpression(CallingMethod(customClass));

            //Create expression statements for the snippets
            CodeExpressionStatement ces = new CodeExpressionStatement(exp);

            //Add the expression statements to the main method.
            main.Statements.Add(ces);

            //Add the main method to the class
            customClass.Members.Add(main);
        }
Ejemplo n.º 19
0
        static void Main(string[] args)
        {
            CodeCompileUnit compileUnit = new CodeCompileUnit();

            CodeNamespace myNamespace = new CodeNamespace("TestNamespace");
            myNamespace.Imports.Add(new CodeNamespaceImport("System"));

            CodeTypeDeclaration myClass = new CodeTypeDeclaration("MyClass");
            CodeEntryPointMethod start = new CodeEntryPointMethod();
            CodeMethodInvokeExpression cs1 = new CodeMethodInvokeExpression(
                new CodeTypeReferenceExpression("Console"),
                "WriteLine", new CodePrimitiveExpression("Hello World!"));

            CodeMemberField memberField = new CodeMemberField();
            memberField.Type = new CodeTypeReference(typeof(float));

            CodeMemberProperty memberPropery = new CodeMemberProperty();
            //memberPropery.ha

            CodeConditionStatement cond = new CodeConditionStatement();

            compileUnit.Namespaces.Add(myNamespace);
            myNamespace.Types.Add(myClass);
            myClass.Members.Add(start);
            start.Statements.Add(cs1);

            CSharpCodeProvider provider = new CSharpCodeProvider();

            using (StreamWriter sw = new StreamWriter("Helloworld.cs", false))
            {
                IndentedTextWriter tw = new IndentedTextWriter(sw, "    ");
                provider.GenerateCodeFromCompileUnit(compileUnit, tw, new CodeGeneratorOptions());

                tw.Close();
            }
        }
Ejemplo n.º 20
0
        private Assembly GenerateExecutableAssembly(PrologCompilerParameters compilerParameters, ArrayList instructions)
        {
            CodeCompileUnit compileUnit = new CodeCompileUnit();

            // Declare namespace, default is Prolog.Assembly
            CodeNamespace plNamespace = new CodeNamespace("Prolog.Assembly");

            plNamespace.Imports.Add(new CodeNamespaceImport("System"));
            plNamespace.Imports.Add(new CodeNamespaceImport("System.Collections"));
            plNamespace.Imports.Add(new CodeNamespaceImport("Axiom.Runtime"));

            compileUnit.Namespaces.Add(plNamespace);

            // Declare class type
            CodeTypeDeclaration classType = new CodeTypeDeclaration("PrologApp");
            plNamespace.Types.Add(classType);
            classType.TypeAttributes = TypeAttributes.Public;

            // Declare private members
            CodeMemberField machineField = new CodeMemberField(new CodeTypeReference("AbstractMachineState"), "machine");

            CodeMemberField moreField = new CodeMemberField(new CodeTypeReference("System.Boolean"), "_more");

            classType.Members.Add(machineField);
            classType.Members.Add(moreField);

            // Generate constructor method
            CodeConstructor cons = new CodeConstructor();
            cons.Attributes = MemberAttributes.Public;
            cons.Statements.Add(new CodeSnippetExpression("Init()"));
            classType.Members.Add(cons);

            // Generate Init() method
            GenerateInitMethod(classType, instructions);

            // Generate main method
            CodeEntryPointMethod mainMethod = new CodeEntryPointMethod();
            mainMethod.Name = "Main";
            mainMethod.Attributes = MemberAttributes.Static | MemberAttributes.Public;
            mainMethod.Statements.Add(new CodeSnippetStatement("PrologApp app = new PrologApp();"));
            mainMethod.Statements.Add(new CodeSnippetStatement("app.Run();"));
            classType.Members.Add(mainMethod);

            CodeMemberMethod runMethod = new CodeMemberMethod();
            runMethod.Name = "Run";
            runMethod.Attributes = MemberAttributes.Public;
            runMethod.Statements.Add(new CodeSnippetStatement("machine.Call(\"main\");"));
            classType.Members.Add(runMethod);

            // Compile the file into a DLL
            CompilerParameters compparams = new CompilerParameters(new string[] { "mscorlib.dll", "Axiom.Runtime.dll" });

            compparams.GenerateInMemory = false;
            compparams.GenerateExecutable = true;
            compparams.OutputAssembly = compilerParameters.OutputAssembly;
            compparams.TempFiles.KeepFiles = true;

            Microsoft.CSharp.CSharpCodeProvider csharp = new Microsoft.CSharp.CSharpCodeProvider();
            ICodeCompiler cscompiler = csharp.CreateCompiler();

            CompilerResults compresult = cscompiler.CompileAssemblyFromDom(compparams, compileUnit);

            if (compresult.Errors.Count > 0)
            {
                foreach (CompilerError err in compresult.Errors)
                {
                    Console.WriteLine(err);
                }
                return null;
            }

            return compresult.CompiledAssembly;
        }
 public override void Flush()
 {
     if (this.dirty)
     {
         XmlDocument document = new XmlDocument();
         document.AppendChild(document.CreateElement("DOCUMENT_ELEMENT"));
         IComponent root = this.host.RootComponent;
         Hashtable nametable = new Hashtable(this.host.Container.Components.Count);
         document.DocumentElement.AppendChild(this.WriteObject(document, nametable, root));
         foreach (IComponent comp in this.host.Container.Components)
         {
             if (!((comp == root) || nametable.ContainsKey(comp)))
             {
                 document.DocumentElement.AppendChild(this.WriteObject(document, nametable, comp));
             }
         }
         CodeCompileUnit code = new CodeCompileUnit();
         CodeNamespace ns = new CodeNamespace(root.Site.Name + "Namespace");
         ns.Imports.Add(new CodeNamespaceImport("System"));
         SampleTypeResolutionService strs = this.host.GetService(typeof(ITypeResolutionService)) as SampleTypeResolutionService;
         foreach (Assembly assm in strs.RefencedAssemblies)
         {
             ns.Imports.Add(new CodeNamespaceImport(assm.GetName().Name));
         }
         RootDesignerSerializerAttribute a = TypeDescriptor.GetAttributes(root)[typeof(RootDesignerSerializerAttribute)] as RootDesignerSerializerAttribute;
         CodeDomSerializer cds = Activator.CreateInstance(this.host.GetType(a.SerializerTypeName)) as CodeDomSerializer;
         IDesignerSerializationManager manager = this.host.GetService(typeof(IDesignerSerializationManager)) as IDesignerSerializationManager;
         CodeTypeDeclaration td = cds.Serialize(manager, root) as CodeTypeDeclaration;
         CodeConstructor con = new CodeConstructor();
         con.Attributes = MemberAttributes.Public;
         con.Statements.Add(new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), "InitializeComponent"), new CodeExpression[0]));
         td.Members.Add(con);
         CodeEntryPointMethod main = new CodeEntryPointMethod();
         main.Name = "Main";
         main.Attributes = MemberAttributes.Public | MemberAttributes.Static;
         main.CustomAttributes.Add(new CodeAttributeDeclaration("System.STAThreadAttribute"));
         main.Statements.Add(new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(typeof(Application)), "Run"), new CodeExpression[] { new CodeObjectCreateExpression(new CodeTypeReference(root.Site.Name), new CodeExpression[0]) }));
         td.Members.Add(main);
         ns.Types.Add(td);
         code.Namespaces.Add(ns);
         this.dirty = false;
         this.xmlDocument = document;
         this.codeCompileUnit = code;
         this.UpdateCodeWindows();
     }
 }
Ejemplo n.º 22
0
        // Create a CodeDOM graph.
        static void CreateGraph(CodeDomProvider provider, CodeCompileUnit cu)
        {
            //<Snippet8>
            if (!provider.Supports(GeneratorSupport.GenericTypeReference |
                                   GeneratorSupport.GenericTypeDeclaration))
            {
                // Return if the generator does not support generics.
                return;
            }
            //</Snippet8>

            CodeNamespace ns = new CodeNamespace("DemoNamespace");

            ns.Imports.Add(new CodeNamespaceImport("System"));
            ns.Imports.Add(new CodeNamespaceImport("System.Collections.Generic"));
            cu.Namespaces.Add(ns);

            // Declare a generic class.
            CodeTypeDeclaration class1 = new CodeTypeDeclaration();

            class1.Name = "MyDictionary";
            class1.BaseTypes.Add(new CodeTypeReference("Dictionary",
                                                       new CodeTypeReference[] {
                new CodeTypeReference("TKey"),
                new CodeTypeReference("TValue"),
            }));
            //<Snippet2>
            //<Snippet10>
            CodeTypeParameter kType = new CodeTypeParameter("TKey");

            //</Snippet2>
            //<Snippet3>
            kType.HasConstructorConstraint = true;
            //</Snippet3>
            //<Snippet4>
            kType.Constraints.Add(new CodeTypeReference(typeof(IComparable)));
            //</Snippet4>
            //<Snippet5>
            kType.CustomAttributes.Add(new CodeAttributeDeclaration(
                                           "System.ComponentModel.DescriptionAttribute",
                                           new CodeAttributeArgument(new CodePrimitiveExpression("KeyType"))));
            //</Snippet5>

            CodeTypeReference iComparableT = new CodeTypeReference("IComparable");

            iComparableT.TypeArguments.Add(new CodeTypeReference(kType));

            kType.Constraints.Add(iComparableT);

            CodeTypeParameter vType = new CodeTypeParameter("TValue");

            vType.Constraints.Add(new CodeTypeReference(typeof(IList <System.String>)));
            vType.CustomAttributes.Add(new CodeAttributeDeclaration(
                                           "System.ComponentModel.DescriptionAttribute",
                                           new CodeAttributeArgument(new CodePrimitiveExpression("ValueType"))));

            class1.TypeParameters.Add(kType);
            class1.TypeParameters.Add(vType);
            //</Snippet10>

            ns.Types.Add(class1);

            //<Snippet6>
            // Declare a generic method.
            CodeMemberMethod  printMethod = new CodeMemberMethod();
            CodeTypeParameter sType       = new CodeTypeParameter("S");

            sType.HasConstructorConstraint = true;
            CodeTypeParameter tType = new CodeTypeParameter("T");

            sType.HasConstructorConstraint = true;

            printMethod.Name = "Print";
            printMethod.TypeParameters.Add(sType);
            printMethod.TypeParameters.Add(tType);

            //</Snippet6>
            //<Snippet7>
            printMethod.Statements.Add(ConsoleWriteLineStatement(
                                           new CodeDefaultValueExpression(new CodeTypeReference("T"))));
            printMethod.Statements.Add(ConsoleWriteLineStatement(
                                           new CodeDefaultValueExpression(new CodeTypeReference("S"))));
            //</Snippet7>

            printMethod.Attributes = MemberAttributes.Public;
            class1.Members.Add(printMethod);

            CodeTypeDeclaration class2 = new CodeTypeDeclaration();

            class2.Name = "Demo";

            CodeEntryPointMethod methodMain = new CodeEntryPointMethod();

            CodeTypeReference myClass = new CodeTypeReference(
                "MyDictionary",
                new CodeTypeReference[] {
                new CodeTypeReference(typeof(int)),
                new CodeTypeReference("List",
                                      new CodeTypeReference[]
                                      { new CodeTypeReference("System.String") })
            });

            methodMain.Statements.Add(
                new CodeVariableDeclarationStatement(myClass,
                                                     "dict",
                                                     new CodeObjectCreateExpression(myClass)));

            methodMain.Statements.Add(ConsoleWriteLineStatement(
                                          new CodePropertyReferenceExpression(
                                              new CodeVariableReferenceExpression("dict"),
                                              "Count")));

//<Snippet9>
            methodMain.Statements.Add(new CodeExpressionStatement(
                                          new CodeMethodInvokeExpression(
                                              new CodeMethodReferenceExpression(
                                                  new CodeVariableReferenceExpression("dict"),
                                                  "Print",
                                                  new CodeTypeReference[] {
                new CodeTypeReference("System.Decimal"),
                new CodeTypeReference("System.Int32"),
            }),
                                              new CodeExpression[0])));

//</Snippet9>
            string dictionaryTypeName = typeof(System.Collections.Generic.Dictionary <int,
                                                                                      System.Collections.Generic.List <string> >[]).FullName;

            CodeTypeReference dictionaryType = new CodeTypeReference(dictionaryTypeName);

            methodMain.Statements.Add(
                new CodeVariableDeclarationStatement(dictionaryType, "dict2",
                                                     new CodeArrayCreateExpression(dictionaryType, new CodeExpression[1] {
                new CodePrimitiveExpression(null)
            })));

            methodMain.Statements.Add(ConsoleWriteLineStatement(
                                          new CodePropertyReferenceExpression(
                                              new CodeVariableReferenceExpression("dict2"),
                                              "Length")));

            class2.Members.Add(methodMain);
            ns.Types.Add(class2);
        }
Ejemplo n.º 23
0
        private CodeMemberMethod GenerateEntryPointMethod()
        {
            CodeMemberMethod cmmMain = null;
            CodeDomProvider codeProvider = EnsureCodeProvider();

            if (codeProvider.Supports(GeneratorSupport.EntryPointMethod))
            {
                //
                // [STAThread]
                // public static void Main () {
                //

                cmmMain = new CodeEntryPointMethod();
                cmmMain.Attributes = MemberAttributes.Public | MemberAttributes.Static;
                cmmMain.CustomAttributes.Add(new CodeAttributeDeclaration(typeof(STAThreadAttribute).FullName));
                AddDebuggerNonUserCodeAttribute(cmmMain);
                AddGeneratedCodeAttribute(cmmMain);
                GenerateXmlComments(cmmMain, "Application Entry Point.");
                cmmMain.ReturnType = new CodeTypeReference(typeof(void));
            }

            return cmmMain;
        }
		protected override void GenerateEntryPointMethod(CodeEntryPointMethod e, CodeTypeDeclaration c)
		{
			Output.WriteLine("[CodeEntryPointMethod: {0}]", e.ToString());
		}
Ejemplo n.º 25
0
 protected override void GenerateEntryPointMethod(CodeEntryPointMethod e, CodeTypeDeclaration c)
 {
     if (e.CustomAttributes.Count > 0)
     {
         this.OutputAttributes(e.CustomAttributes, false);
     }
     base.Output.WriteLine("Public Shared Sub Main()");
     base.Indent++;
     this.GenerateVBStatements(e.Statements);
     base.Indent--;
     base.Output.WriteLine("End Sub");
 }
Ejemplo n.º 26
0
        private static CodeMemberMethod CreateEntryPointMethod(string className)
        {
            CodeMemberMethod entryPointMethod = new CodeEntryPointMethod();

            entryPointMethod.CustomAttributes.Add(new CodeAttributeDeclaration(new CodeTypeReference(typeof(STAThreadAttribute))));

            entryPointMethod.Statements.Add(new CodeSnippetStatement("            System.Windows.ApplicationHost.Current.Run(() =>"));
            entryPointMethod.Statements.Add(new CodeSnippetStatement("            {"));
            entryPointMethod.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference(className), "application", new CodeObjectCreateExpression(new CodeTypeReference(className))));
            entryPointMethod.Statements.Add(new CodeExpressionStatement(new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("application"), "InitializeComponent")));
            entryPointMethod.Statements.Add(new CodeExpressionStatement(new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("application"), "Run")));
            entryPointMethod.Statements.Add(new CodeSnippetStatement("            });"));

            return entryPointMethod;
        }
Ejemplo n.º 27
0
 protected override void GenerateEntryPointMethod(System.CodeDom.CodeEntryPointMethod e, System.CodeDom.CodeTypeDeclaration c)
 {
     //ничего не делаем
 }
Ejemplo n.º 28
0
		protected override void GenerateEntryPointMethod (CodeEntryPointMethod e, CodeTypeDeclaration c)
		{
		}
Ejemplo n.º 29
0
		protected override void GenerateEntryPointMethod (CodeEntryPointMethod method, CodeTypeDeclaration declaration)
		{
			OutputAttributes (method.CustomAttributes, null,
				LineHandling.ContinueLine);

			Output.WriteLine ("Public Shared Sub Main()");
			Indent++;
			GenerateStatements (method.Statements);
			Indent--;
			Output.WriteLine ("End Sub");
		}
Ejemplo n.º 30
0
		protected abstract void GenerateEntryPointMethod (CodeEntryPointMethod m, CodeTypeDeclaration d);
Ejemplo n.º 31
0
			public void Visit (CodeEntryPointMethod o)
			{
				g.GenerateEntryPointMethod (o, g.CurrentClass);
			}
Ejemplo n.º 32
0
        protected override void GenerateEntryPointMethod(CodeEntryPointMethod e, CodeTypeDeclaration c) {

            Output.Write("public static void Main()");
            OutputStartingBrace();
            Indent++;

            GenerateStatements(e.Statements);

            Indent--;
            Output.WriteLine("}");
        }
        private  void GenerateEntryPointMethod(CodeEntryPointMethod e, CodeTypeDeclaration c) {

            if (e.CustomAttributes.Count > 0) {
                GenerateAttributes(e.CustomAttributes);
            }
            Output.Write("public static ");
            OutputType(e.ReturnType);
            Output.Write(" Main()");
            OutputStartingBrace();
            Indent++;

            GenerateStatements(e.Statements);

            Indent--;
            Output.WriteLine("}");
        }