protected override void GenerateInner(CodeGenerator generator, CodeCompositeTypeDeclaration enclosingType)
        {
            Modifiers.Generate(generator);

            generator.OutputIdentifier(TokenType.Identifier, enclosingType.Name);
            generator.Write(TokenType.Punctuation, '(');
            Parameters.GenerateCommaSeparated(generator);
            generator.Write(TokenType.Punctuation, ')');

            if (Initializer != null)
            {
                Initializer.Generate(generator);
            }

            if (Statements.Count > 0)
            {
                generator.WriteOpeningBrace();
                generator.Indent++;
                generator.EnterLocalScope();
                foreach (var parameter in Parameters)
                {
                    generator.ReserveLocal(parameter.Name);
                }
                Statements.Generate(generator, default(CodeStatementEmitOptions));
                generator.ExitLocalScope();
                generator.Indent--;
                generator.WriteClosingBrace();
            }
            else
            {
                generator.WriteEmptyBlock();
            }
        }
        protected override void GenerateInner(CodeGenerator generator)
        {
            Modifiers.Generate(generator);

            generator.Write(TokenType.Keyword, "enum");
            generator.Write(TokenType.Space, ' ');
            generator.OutputIdentifier(TokenType.TypeIdentifier, Name);

            if (UnderlyingType != null)
            {
                generator.Write(TokenType.Space, ' ');
                generator.Write(TokenType.Punctuation, ':');
                generator.Write(TokenType.Space, ' ');
                UnderlyingType.Generate(generator);
            }

            if (Members.Count > 0)
            {
                generator.WriteOpeningBrace();
                generator.Indent++;

                foreach (var member in Members)
                {
                    member.Generate(generator);
                }

                generator.Indent--;
                generator.WriteClosingBrace();
            }
            else
            {
                generator.WriteEmptyBlock();
            }
        }
Beispiel #3
0
 protected override void GenerateInner(CodeGenerator generator, CodeStatementEmitOptions emitOptions)
 {
     generator.WriteBlankLineBeforeEnteringBlock();
     generator.EnterLocalScope();
     generator.Write(TokenType.Keyword, "using");
     generator.Write(TokenType.Space, ' ');
     generator.Write(TokenType.Punctuation, '(');
     InitStatement.Generate(generator, CodeStatementEmitOptions.OmitSemiColon);
     generator.Write(TokenType.Punctuation, ')');
     if (Statements.Count > 0)
     {
         generator.WriteOpeningBrace();
         generator.Indent++;
         generator.EnterLocalScope();
         Statements.ReserveLocals(generator, default(CodeStatementEmitOptions));
         Statements.Generate(generator, default(CodeStatementEmitOptions));
         generator.ExitLocalScope();
         generator.Indent--;
         generator.WriteClosingBrace();
     }
     else
     {
         generator.WriteEmptyBlock();
     }
     generator.ExitLocalScope();
 }
        protected override void GenerateInner(CodeGenerator generator, CodeCompositeTypeDeclaration enclosingType)
        {
            generator.Write(TokenType.Keyword, "static");
            generator.Write(TokenType.Space, ' ');
            generator.Write(TokenType.Identifier, enclosingType.Name);
            generator.Write(TokenType.Punctuation, "()");

            if (Statements.Count > 0)
            {
                generator.WriteOpeningBrace();
                generator.Indent++;
                generator.EnterLocalScope();
                foreach (var parameter in Parameters)
                {
                    generator.ReserveLocal(parameter.Name);
                }
                Statements.Generate(generator, default(CodeStatementEmitOptions));
                generator.ExitLocalScope();
                generator.Indent--;
                generator.WriteClosingBrace();
            }
            else
            {
                generator.WriteEmptyBlock();
            }
        }
 protected override void GenerateInner(CodeGenerator generator, CodeStatementEmitOptions emitOptions)
 {
     generator.WriteBlankLineBeforeEnteringBlock();
     generator.EnterLocalScope();
     generator.Write(TokenType.Keyword, "foreach");
     generator.Write(TokenType.Space, ' ');
     generator.Write(TokenType.Punctuation, '(');
     Declaration.Type.Generate(generator);
     generator.Write(TokenType.Space, ' ');
     generator.OutputIdentifier(TokenType.Identifier, Declaration.Name);
     generator.Write(TokenType.Space, ' ');
     generator.Write(TokenType.Keyword, "in");
     generator.Write(TokenType.Space, ' ');
     Expression.Generate(generator);
     generator.Write(TokenType.Punctuation, ')');
     if (Statements.Count > 0)
     {
         generator.WriteOpeningBrace();
         generator.Indent++;
         generator.EnterLocalScope();
         Statements.ReserveLocals(generator, default(CodeStatementEmitOptions));
         Statements.Generate(generator, default(CodeStatementEmitOptions));
         generator.ExitLocalScope();
         generator.Indent--;
         generator.WriteClosingBrace();
     }
     else
     {
         generator.WriteEmptyBlock();
     }
     generator.ExitLocalScope();
 }
        protected override void GenerateInner(CodeGenerator generator, CodeCompositeTypeDeclaration enclosingType)
        {
            generator.GenerateAttributes(ReturnTypeCustomAttributes, "return");

            if (ExplicitImplementationType == null)
            {
                Modifiers.Generate(generator);
            }

            ReturnType.Generate(generator);
            generator.Write(TokenType.Space, ' ');
            if (ExplicitImplementationType != null)
            {
                ExplicitImplementationType.Generate(generator);
                generator.Write(TokenType.Punctuation, '.');
            }
            generator.OutputIdentifier(TokenType.Identifier, Name);

            generator.OutputTypeParameters(TypeParameters);

            generator.Write(TokenType.Punctuation, '(');
            Parameters.GenerateCommaSeparated(generator);
            generator.Write(TokenType.Punctuation, ')');

            foreach (var typeParameter in TypeParameters)
            {
                typeParameter.GenerateConstraints(generator);
            }

            if (enclosingType.IsInterface ||
                (Modifiers & CodeMemberModifiers.ScopeMask) == CodeMemberModifiers.Abstract)
            {
                generator.WriteLine(TokenType.Punctuation, ';');
            }
            else
            {
                if (Statements.Count > 0)
                {
                    generator.WriteOpeningBrace();
                    generator.Indent++;

                    generator.EnterLocalScope();
                    foreach (var parameter in Parameters)
                    {
                        generator.ReserveLocal(parameter.Name);
                    }

                    Statements.Generate(generator, default(CodeStatementEmitOptions));
                    generator.ExitLocalScope();

                    generator.Indent--;
                    generator.WriteClosingBrace();
                }
                else
                {
                    generator.WriteEmptyBlock();
                }
            }
        }
        protected override void GenerateInner(CodeGenerator generator, CodeStatementEmitOptions emitOptions)
        {
            generator.WriteBlankLineBeforeEnteringBlock();
            generator.Write(TokenType.Keyword, "try");
            generator.WriteOpeningBrace();
            generator.Indent++;
            generator.EnterLocalScope();
            TryStatements.ReserveLocals(generator, default(CodeStatementEmitOptions));
            TryStatements.Generate(generator, default(CodeStatementEmitOptions));
            generator.ExitLocalScope();
            generator.Indent--;

            foreach (var catchClause in CatchClauses)
            {
                generator.WriteMiddleClosingBrace();
                generator.Write(TokenType.Keyword, "catch");
                generator.Write(TokenType.Space, ' ');
                generator.Write(TokenType.Punctuation, '(');
                catchClause.CatchExceptionType.Generate(generator);
                generator.Write(TokenType.Space, ' ');
                generator.OutputIdentifier(TokenType.Identifier, catchClause.LocalName);
                generator.Write(TokenType.Punctuation, ')');
                generator.WriteOpeningBrace();
                generator.Indent++;
                generator.EnterLocalScope();
                generator.ReserveLocal(catchClause.LocalName);
                catchClause.Statements.ReserveLocals(generator, default(CodeStatementEmitOptions));
                catchClause.Statements.Generate(generator, default(CodeStatementEmitOptions));
                generator.ExitLocalScope();
                generator.Indent--;
            }

            if (FinallyStatements.Count > 0)
            {
                generator.WriteMiddleClosingBrace();
                generator.Write(TokenType.Keyword, "finally");
                generator.WriteOpeningBrace();
                generator.Indent++;
                generator.EnterLocalScope();
                FinallyStatements.ReserveLocals(generator, default(CodeStatementEmitOptions));
                FinallyStatements.Generate(generator, default(CodeStatementEmitOptions));
                generator.ExitLocalScope();
                generator.Indent--;
            }
            generator.WriteClosingBrace();
        }
 protected override void GenerateInner(CodeGenerator generator, CodeStatementEmitOptions emitOptions)
 {
     if (Statements.Count > 0)
     {
         generator.WriteOpeningBrace();
         generator.Indent++;
         generator.EnterLocalScope();
         Statements.ReserveLocals(generator, default(CodeStatementEmitOptions));
         Statements.Generate(generator, default(CodeStatementEmitOptions));
         generator.ExitLocalScope();
         generator.Indent--;
         generator.WriteClosingBrace();
     }
     else
     {
         generator.WriteEmptyBlock();
     }
 }
        public void Generate(CodeGenerator generator)
        {
            generator.EnterElement(this);

            Comments.Generate(generator);

            generator.Write(TokenType.Keyword, "namespace");
            generator.Write(TokenType.Space, ' ');
            var names = Name.Split('.');

            generator.OutputIdentifier(TokenType.Identifier, names[0]);
            for (int i = 1; i < names.Length; i++)
            {
                generator.Write(TokenType.Punctuation, '.');
                generator.OutputIdentifier(TokenType.Identifier, names[i]);
            }
            generator.WriteOpeningBrace();
            generator.Indent++;

            Usings.Generate(generator);

            Usings.Add(new CodeUsingImport(Name));
            generator.PushUsingSet(Usings);

            bool needsBlankLine = false;

            foreach (var type in Types)
            {
                if (needsBlankLine)
                {
                    generator.WriteLine();
                }

                type.Generate(generator);
                needsBlankLine = true;
            }

            generator.PopUsingSet();

            generator.Indent--;
            generator.WriteClosingBrace();

            generator.ExitElement();
        }
        protected override void GenerateInner(CodeGenerator generator, CodeStatementEmitOptions emitOptions)
        {
            generator.WriteBlankLineBeforeEnteringBlock();
            generator.Write(TokenType.Keyword, "if");
            generator.Write(TokenType.Space, ' ');
            generator.Write(TokenType.Punctuation, '(');
            Condition.Generate(generator);
            generator.Write(TokenType.Punctuation, ')');
            if (TrueStatements.Count == 0 && FalseStatements.Count == 0)
            {
                generator.WriteEmptyBlock();
            }
            else
            {
                generator.WriteOpeningBrace();
                generator.Indent++;
                generator.EnterLocalScope();
                TrueStatements.ReserveLocals(generator, default(CodeStatementEmitOptions));
                TrueStatements.Generate(generator, default(CodeStatementEmitOptions));
                generator.ExitLocalScope();
                generator.Indent--;

                if (FalseStatements.Count > 0)
                {
                    generator.WriteMiddleClosingBrace();
                    generator.Write(TokenType.Keyword, "else");
                    generator.WriteOpeningBrace();
                    generator.Indent++;
                    generator.EnterLocalScope();
                    FalseStatements.ReserveLocals(generator, default(CodeStatementEmitOptions));
                    FalseStatements.Generate(generator, default(CodeStatementEmitOptions));
                    generator.ExitLocalScope();
                    generator.Indent--;
                }
                generator.WriteClosingBrace();
            }
        }
        protected override void GenerateInner(CodeGenerator generator)
        {
            Modifiers.Generate(generator);

            if (IsPartial)
            {
                generator.Write(TokenType.Keyword, "partial");
                generator.Write(TokenType.Space, ' ');
            }

            generator.Write(TokenType.Keyword, Keyword);
            generator.Write(TokenType.Space, ' ');
            generator.OutputIdentifier(TokenType.TypeIdentifier, Name);

            generator.OutputTypeParameters(TypeParameters);

            var firstTypeRef = true;

            foreach (CodeTypeReference typeRef in BaseTypes)
            {
                if (firstTypeRef)
                {
                    generator.Write(TokenType.Space, ' ');
                    generator.Write(TokenType.Punctuation, ':');
                    generator.Write(TokenType.Space, ' ');
                    firstTypeRef = false;
                }
                else
                {
                    generator.Write(TokenType.Punctuation, ',');
                    generator.Write(TokenType.Space, ' ');
                }
                typeRef.Generate(generator);
            }

            foreach (var typeParameter in TypeParameters)
            {
                typeParameter.GenerateConstraints(generator);
            }

            if (Members.Count > 0)
            {
                generator.WriteOpeningBrace();
                generator.Indent++;

                CodeCompositeTypeMember previousMember = null;
                var sortedMembers = GetMembersSortedByCategory();

                foreach (var member in sortedMembers)
                {
                    if (previousMember != null && (previousMember.Category != member.Category || ShouldLineSeparateIndividualMember(previousMember.Category)))
                    {
                        generator.WriteLine();
                    }

                    member.Generate(generator, this);
                    previousMember = member;
                }

                generator.Indent--;
                generator.WriteClosingBrace();
            }
            else
            {
                generator.WriteEmptyBlock();
            }
        }
Beispiel #12
0
        protected override void GenerateInner(CodeGenerator generator)
        {
            bool implicitlyTyped = true;

            foreach (var parameter in Parameters)
            {
                if (parameter.Type.RawName != "var")
                {
                    implicitlyTyped = false;
                }
            }

            generator.EnterLocalScope();

            if (implicitlyTyped)
            {
                if (Parameters.Count == 1)
                {
                    generator.OutputIdentifier(TokenType.Identifier, Parameters[0].Name);
                }
                else
                {
                    generator.Write(TokenType.Punctuation, '(');
                    bool first = true;
                    foreach (var parameter in Parameters)
                    {
                        if (first)
                        {
                            first = false;
                        }
                        else
                        {
                            generator.Write(TokenType.Punctuation, ',');
                            generator.Write(TokenType.Space, ' ');
                        }

                        generator.OutputIdentifier(TokenType.Identifier, parameter.Name);
                    }
                    generator.Write(TokenType.Punctuation, ')');
                }
            }
            else
            {
                generator.Write(TokenType.Punctuation, '(');
                Parameters.GenerateCommaSeparated(generator);
                generator.Write(TokenType.Punctuation, ')');
            }

            generator.Write(TokenType.Space, ' ');
            generator.Write(TokenType.Operator, "=>");
            generator.Write(TokenType.Space, ' ');

            if (ExpressionBody != null)
            {
                ExpressionBody.Generate(generator);
            }
            else
            {
                generator.WriteOpeningBrace();
                generator.Indent++;
                Statements.Generate(generator, default(CodeStatementEmitOptions));
                generator.Indent--;
                generator.WriteClosingBrace(true);
            }

            generator.ExitLocalScope();
        }