Пример #1
0
        public MethodBodyBuilder(IMetadataHost host, IEnumerable<IParameterDefinition> parameters)
        {
            reflector = new UnitReflector(host);
            locals = new LocalVariableBindings(reflector);
            define = new DefinitionBuilder(reflector, locals, host.NameTable);
            create = new InstanceCreator(reflector, locals);
            declare = new DeclarationBuilder(define);
            call = new MethodCallBuilder(host, reflector, locals);
            changeType = new Converter(reflector);
            operators = new TypeOperatorBuilder(reflector);
            constant = new CompileTimeConstantBuilder(reflector);
            @if = new IfStatementBuilder();
            @return = new CodeReturnStatementBuilder();
            anonymousMethod = new AnonymousMethodTypeOptions(host, reflector);
            statement = new StatementBuilder();
            @params = new ParameterBindings();

            foreach (var parameter in parameters)
            {
                @params.AddBinding(parameter);
            }
        }
Пример #2
0
        /*
         *
         * //class modifiers
         *
         * @ abstract
         * $ sealed
         *
         * //type specifiers
         *
         * n namespace
         * c class
         * e enum
         * i interface
         * s struct
         *
         * m method
         * p property
         *
         */

        public string Generate(string template)
        {
            var result = new StringBuilder();
            var lines  = template.Split(Symbols.EOL, StringSplitOptions.RemoveEmptyEntries);

            var builders = new List <IDeclarationBuilder>();
            IDeclarationBuilder lastCb = null;

            string lineToParse = string.Empty;

            foreach (var line in lines)
            {
                lineToParse = line.Trim();
                if (lineToParse.StartsWith("*"))
                {
                    //Remove comment marker *
                    lineToParse = lineToParse.Substring(1).Trim();
                }

                var parts = lineToParse.Split(Symbols.SPACE, 2, StringSplitOptions.RemoveEmptyEntries);

                if (parts.Length == 0)
                {
                    continue;
                }

                var classifier = parts[0].Trim();

                switch (classifier)
                {
                case "e":
                    if (parts.Length <= 1)
                    {
                        break;
                    }

                    var eb = new EnumDeclarationBuilder(parts[1]);
                    builders.Add(eb);
                    break;

                case "c":
                    if (parts.Length <= 1)
                    {
                        break;
                    }

                    lastCb = new ClassDeclarationBuilder(parts[1]);
                    builders.Add(lastCb);
                    break;

                case "i":
                    if (parts.Length <= 1)
                    {
                        break;
                    }

                    lastCb = new InterfaceDeclarationBuilder(parts[1]);
                    builders.Add(lastCb);
                    break;

                case "s":
                    if (parts.Length <= 1)
                    {
                        break;
                    }

                    lastCb = new StructDeclarationBuilder(parts[1]);
                    builders.Add(lastCb);
                    break;

                case "m":
                    if (parts.Length <= 1)
                    {
                        break;
                    }

                    MethodDeclarationBuilder mb = new MethodDeclarationBuilder(parts[1]);

                    if (lastCb != null)
                    {
                        if (lastCb.GetType().Equals(typeof(InterfaceDeclarationBuilder)))
                        {
                            mb = new MethodDeclarationBuilder(parts[1], isInterface: true);
                        }
                        lastCb.AddBuilder(mb);
                    }
                    else
                    {
                        result.AppendLine(mb.Build());
                    }

                    break;

                default:
                    if (string.IsNullOrEmpty(lineToParse))
                    {
                        break;
                    }

                    var pb = new PropertyDeclarationBuilder(lineToParse);

                    if (lastCb != null)
                    {
                        if (lastCb.GetType().Equals(typeof(InterfaceDeclarationBuilder)))
                        {
                            pb = new PropertyDeclarationBuilder(lineToParse, isInterface: true);
                        }
                        lastCb.AddBuilder(pb);
                    }
                    else
                    {
                        result.AppendLine(pb.Build());
                    }
                    break;
                }
            }

            foreach (var item in builders)
            {
                result.AppendLine(item.Build());
            }

            //TODO: Use Roslyn to generate code from this string

            return(result.ToString());
        }
Пример #3
0
 public void AddBuilder(IDeclarationBuilder builder)
 {
     _builders.Add(builder);
 }