Files
mono/mcs/class/System/System.CodeDom.Compiler/CodeGenerator.cs
T
Gonzalo Paniagua Javier fd6f5a46b5 2003-04-24 Gonzalo Paniagua Javier <[email protected]>
* Microsoft.CSharp/CSharpCodeGenerator.cs: implemented
	GenerateSnippetMember and some little fixes.

	* System.CodeDom/CodeMemberProperty.cs: fixed HasGet and HasSet to
	actually generate code for the property.

	* System.CodeDom.Compiler/CodeGenerator.cs: more fixes and sorted the
	output.

	* System.CodeDom.Compiler/IndentedTextWriter.cs: don't output tabs in
	WriteLine ().

svn path=/trunk/mcs/; revision=13960
2003-04-24 06:32:22 +00:00

1016 lines
28 KiB
C#
Executable File

//
// System.CodeDom.Compiler CodeGenerator class
//
// Author:
// Miguel de Icaza ([email protected])
// Daniel Stodden ([email protected])
// Gonzalo Paniagua Javier ([email protected])
//
// (C) 2001-2003 Ximian, Inc.
//
using System.CodeDom;
using System.Reflection;
using System.IO;
using System.Collections;
namespace System.CodeDom.Compiler {
public abstract class CodeGenerator
: ICodeGenerator
{
private IndentedTextWriter output;
private CodeGeneratorOptions options;
private CodeTypeMember currentMember;
private CodeTypeDeclaration currentType;
//
// Constructors
//
protected CodeGenerator()
{
}
//
// Properties
//
protected CodeTypeMember CurrentMember {
get {
return currentMember;
}
}
protected string CurrentMemberName {
get {
if ( currentType == null )
return null;
return currentMember.Name;
}
}
protected string CurrentTypeName {
get {
if ( currentType == null )
return null;
return currentType.Name;
}
}
protected int Indent {
get {
return output.Indent;
}
set {
output.Indent = value;
}
}
protected bool IsCurrentClass {
get {
if ( currentType == null )
return false;
return currentType.IsClass;
}
}
protected bool IsCurrentDelegate {
get {
return currentType is CodeTypeDelegate;
}
}
protected bool IsCurrentEnum {
get {
if ( currentType == null )
return false;
return currentType.IsEnum;
}
}
protected bool IsCurrentInterface {
get {
if ( currentType == null )
return false;
return currentType.IsInterface;
}
}
protected bool IsCurrentStruct {
get {
if ( currentType == null )
return false;
return currentType.IsStruct;
}
}
protected abstract string NullToken {
get;
}
protected CodeGeneratorOptions Options {
get {
return options;
}
}
protected TextWriter Output {
get {
return output;
}
}
//
// Methods
//
protected virtual void ContinueOnNewLine( string st )
{
output.WriteLine (st);
}
/*
* Code Generation methods
*/
protected abstract void GenerateArgumentReferenceExpression (CodeArgumentReferenceExpression e);
protected abstract void GenerateArrayCreateExpression (CodeArrayCreateExpression e);
protected abstract void GenerateArrayIndexerExpression( CodeArrayIndexerExpression e );
protected abstract void GenerateAssignStatement (CodeAssignStatement s);
protected abstract void GenerateAttachEventStatement (CodeAttachEventStatement s);
protected abstract void GenerateAttributeDeclarationsStart( CodeAttributeDeclarationCollection attributes );
protected abstract void GenerateAttributeDeclarationsEnd( CodeAttributeDeclarationCollection attributes );
protected abstract void GenerateBaseReferenceExpression (CodeBaseReferenceExpression e);
protected virtual void GenerateBinaryOperatorExpression (CodeBinaryOperatorExpression e)
{
output.Write ('(');
GenerateExpression (e.Left);
output.Write (' ');
OutputOperator (e.Operator);
output.Write (' ');
GenerateExpression (e.Right);
output.Write (')');
}
protected abstract void GenerateCastExpression (CodeCastExpression e);
protected abstract void GenerateComment( CodeComment comment );
protected virtual void GenerateCommentStatement( CodeCommentStatement statement )
{
GenerateComment( statement.Comment );
}
protected virtual void GenerateCommentStatements (CodeCommentStatementCollection statements)
{
foreach ( CodeCommentStatement comment in statements )
GenerateCommentStatement( comment );
}
protected virtual void GenerateCompileUnit( CodeCompileUnit compileUnit )
{
GenerateCompileUnitStart( compileUnit );
CodeAttributeDeclarationCollection attributes = compileUnit.AssemblyCustomAttributes;
if ( attributes.Count != 0 ) {
GenerateAttributeDeclarationsStart( attributes );
output.Write( "assembly: " );
OutputAttributeDeclarations( compileUnit.AssemblyCustomAttributes );
GenerateAttributeDeclarationsEnd( attributes );
}
foreach ( CodeNamespace ns in compileUnit.Namespaces )
GenerateNamespace( ns );
GenerateCompileUnitEnd( compileUnit );
}
protected virtual void GenerateCompileUnitEnd( CodeCompileUnit compileUnit )
{
}
protected virtual void GenerateCompileUnitStart( CodeCompileUnit compileUnit )
{
}
protected abstract void GenerateConditionStatement( CodeConditionStatement s );
protected abstract void GenerateConstructor (CodeConstructor x, CodeTypeDeclaration d);
protected abstract void GenerateDelegateCreateExpression( CodeDelegateCreateExpression e );
protected abstract void GenerateDelegateInvokeExpression( CodeDelegateInvokeExpression e );
protected virtual void GenerateDirectionExpression( CodeDirectionExpression e )
{
OutputDirection( e.Direction );
output.Write( ' ' );
GenerateExpression( e.Expression );
}
protected abstract void GenerateEntryPointMethod( CodeEntryPointMethod m, CodeTypeDeclaration d );
protected abstract void GenerateEvent( CodeMemberEvent ev, CodeTypeDeclaration d );
protected abstract void GenerateEventReferenceExpression( CodeEventReferenceExpression e );
protected void GenerateExpression( CodeExpression e )
{
CodeArgumentReferenceExpression argref = e as CodeArgumentReferenceExpression;
if ( argref != null ) {
GenerateArgumentReferenceExpression( argref );
return;
}
CodeArrayCreateExpression mkarray = e as CodeArrayCreateExpression;
if ( mkarray != null ) {
GenerateArrayCreateExpression( mkarray );
return;
}
CodeArrayIndexerExpression arrayidx = e as CodeArrayIndexerExpression;
if ( arrayidx != null ) {
GenerateArrayIndexerExpression( arrayidx );
return;
}
CodeBaseReferenceExpression baseref = e as CodeBaseReferenceExpression;
if ( baseref != null ) {
GenerateBaseReferenceExpression( baseref );
return;
}
CodeBinaryOperatorExpression binary = e as CodeBinaryOperatorExpression;
if ( binary != null ) {
GenerateBinaryOperatorExpression( binary );
return;
}
CodeCastExpression cast = e as CodeCastExpression;
if ( cast != null ) {
GenerateCastExpression( cast );
return;
}
CodeDelegateCreateExpression mkdel = e as CodeDelegateCreateExpression;
if ( mkdel != null ) {
GenerateDelegateCreateExpression( mkdel );
return;
}
CodeDelegateInvokeExpression delinvoke = e as CodeDelegateInvokeExpression;
if ( delinvoke != null ) {
GenerateDelegateInvokeExpression( delinvoke );
return;
}
CodeDirectionExpression direction = e as CodeDirectionExpression;
if ( direction != null ) {
GenerateDirectionExpression( direction );
return;
}
CodeEventReferenceExpression eventref = e as CodeEventReferenceExpression;
if ( eventref != null ) {
GenerateEventReferenceExpression( eventref );
return;
}
CodeFieldReferenceExpression fieldref = e as CodeFieldReferenceExpression;
if ( fieldref != null ) {
GenerateFieldReferenceExpression( fieldref );
return;
}
CodeIndexerExpression idx = e as CodeIndexerExpression;
if ( idx != null ) {
GenerateIndexerExpression( idx );
return;
}
CodeMethodInvokeExpression methodinv = e as CodeMethodInvokeExpression;
if ( methodinv != null ) {
GenerateMethodInvokeExpression( methodinv );
return;
}
CodeMethodReferenceExpression methodref = e as CodeMethodReferenceExpression;
if ( methodref != null ) {
GenerateMethodReferenceExpression( methodref );
return;
}
CodeObjectCreateExpression objref = e as CodeObjectCreateExpression;
if ( objref != null ) {
GenerateObjectCreateExpression( objref );
return;
}
CodeParameterDeclarationExpression param = e as CodeParameterDeclarationExpression;
if ( param != null ) {
GenerateParameterDeclarationExpression( param );
return;
}
CodePrimitiveExpression primitive = e as CodePrimitiveExpression;
if ( primitive != null ) {
GeneratePrimitiveExpression( primitive );
return;
}
CodePropertyReferenceExpression propref = e as CodePropertyReferenceExpression;
if ( propref != null ) {
GeneratePropertyReferenceExpression( propref );
return;
}
CodePropertySetValueReferenceExpression propset = e as CodePropertySetValueReferenceExpression;
if ( propset != null ) {
GeneratePropertySetValueReferenceExpression( propset );
return;
}
CodeSnippetExpression snippet = e as CodeSnippetExpression;
if ( snippet != null ) {
GenerateSnippetExpression( snippet );
return;
}
CodeThisReferenceExpression thisref = e as CodeThisReferenceExpression;
if ( thisref != null ) {
GenerateThisReferenceExpression( thisref );
return;
}
CodeTypeOfExpression typeOf = e as CodeTypeOfExpression;
if ( typeOf != null ) {
GenerateTypeOfExpression( typeOf );
return;
}
CodeTypeReferenceExpression typeref = e as CodeTypeReferenceExpression;
if ( typeref != null ) {
GenerateTypeReferenceExpression( typeref );
return;
}
CodeVariableReferenceExpression varref = e as CodeVariableReferenceExpression;
if ( varref != null ) {
GenerateVariableReferenceExpression( varref );
return;
}
}
protected abstract void GenerateExpressionStatement( CodeExpressionStatement statement );
protected abstract void GenerateField (CodeMemberField f);
protected abstract void GenerateFieldReferenceExpression (CodeFieldReferenceExpression e);
protected abstract void GenerateGotoStatement( CodeGotoStatement statement );
protected abstract void GenerateIndexerExpression (CodeIndexerExpression e);
protected abstract void GenerateIterationStatement( CodeIterationStatement s );
protected abstract void GenerateLabeledStatement( CodeLabeledStatement statement );
protected abstract void GenerateLinePragmaStart (CodeLinePragma p);
protected abstract void GenerateLinePragmaEnd (CodeLinePragma p);
protected abstract void GenerateMethod (CodeMemberMethod m, CodeTypeDeclaration d);
protected abstract void GenerateMethodInvokeExpression (CodeMethodInvokeExpression e);
protected abstract void GenerateMethodReferenceExpression( CodeMethodReferenceExpression e );
protected abstract void GenerateMethodReturnStatement (CodeMethodReturnStatement e);
protected virtual void GenerateNamespace (CodeNamespace ns)
{
foreach ( CodeCommentStatement statement in ns.Comments )
GenerateCommentStatement( statement );
GenerateNamespaceStart( ns );
foreach ( CodeNamespaceImport import in ns.Imports )
GenerateNamespaceImport( import );
output.WriteLine();
foreach ( CodeTypeDeclaration type in ns.Types )
GenerateCodeFromType( type, output, options );
GenerateNamespaceEnd( ns );
}
protected abstract void GenerateNamespaceStart (CodeNamespace ns);
protected abstract void GenerateNamespaceEnd (CodeNamespace ns);
protected abstract void GenerateNamespaceImport (CodeNamespaceImport i);
protected abstract void GenerateObjectCreateExpression (CodeObjectCreateExpression e);
protected virtual void GenerateParameterDeclarationExpression (CodeParameterDeclarationExpression e)
{
if (e.CustomAttributes != null && e.CustomAttributes.Count > 0)
OutputAttributeDeclarations( e.CustomAttributes );
OutputDirection( e.Direction );
OutputType( e.Type );
output.Write( ' ' );
output.Write( e.Name );
}
protected virtual void GeneratePrimitiveExpression (CodePrimitiveExpression e)
{
if (e.Value == null) {
output.Write ("null");
return;
}
if (e.Value is bool) {
output.Write (e.Value.ToString ().ToLower ());
return;
}
output.Write (e.Value);
}
protected abstract void GenerateProperty (CodeMemberProperty p, CodeTypeDeclaration d);
protected abstract void GeneratePropertyReferenceExpression (CodePropertyReferenceExpression e);
protected abstract void GeneratePropertySetValueReferenceExpression( CodePropertySetValueReferenceExpression e );
protected abstract void GenerateRemoveEventStatement( CodeRemoveEventStatement statement );
protected abstract void GenerateSnippetExpression( CodeSnippetExpression e );
protected abstract void GenerateSnippetMember( CodeSnippetTypeMember m );
protected virtual void GenerateSnippetStatement( CodeSnippetStatement s )
{
output.Write( s.Value );
}
protected void GenerateStatement( CodeStatement s )
{
CodeAssignStatement assign = s as CodeAssignStatement;
if ( assign != null ) {
GenerateAssignStatement( assign );
return;
}
CodeAttachEventStatement attach = s as CodeAttachEventStatement;
if ( attach != null ) {
GenerateAttachEventStatement( attach );
return;
}
CodeCommentStatement comment = s as CodeCommentStatement;
if ( comment != null ) {
GenerateCommentStatement( comment );
return;
}
CodeConditionStatement condition = s as CodeConditionStatement;
if ( condition != null ) {
GenerateConditionStatement( condition );
return;
}
CodeExpressionStatement expression = s as CodeExpressionStatement;
if ( expression != null ) {
GenerateExpressionStatement( expression );
return;
}
CodeGotoStatement gotostmt = s as CodeGotoStatement;
if ( gotostmt != null ) {
GenerateGotoStatement( gotostmt );
return;
}
CodeIterationStatement iteration = s as CodeIterationStatement;
if ( iteration != null ) {
GenerateIterationStatement( iteration );
return;
}
CodeLabeledStatement label = s as CodeLabeledStatement;
if ( label != null ) {
GenerateLabeledStatement( label );
return;
}
CodeMethodReturnStatement returnstmt = s as CodeMethodReturnStatement;
if ( returnstmt != null ) {
GenerateMethodReturnStatement( returnstmt );
return;
}
CodeRemoveEventStatement remove = s as CodeRemoveEventStatement;
if ( remove != null ) {
GenerateRemoveEventStatement( remove );
return;
}
CodeSnippetStatement snippet = s as CodeSnippetStatement;
if ( snippet != null ) {
GenerateSnippetStatement( snippet );
return;
}
CodeThrowExceptionStatement exception = s as CodeThrowExceptionStatement;
if ( exception != null ) {
GenerateThrowExceptionStatement( exception );
return;
}
CodeTryCatchFinallyStatement trycatch = s as CodeTryCatchFinallyStatement;
if ( trycatch != null ) {
GenerateTryCatchFinallyStatement( trycatch );
return;
}
CodeVariableDeclarationStatement declaration = s as CodeVariableDeclarationStatement;
if ( declaration != null ) {
GenerateVariableDeclarationStatement( declaration );
return;
}
}
protected void GenerateStatements( CodeStatementCollection c )
{
foreach ( CodeStatement statement in c )
GenerateStatement( statement );
}
protected abstract void GenerateThisReferenceExpression (CodeThisReferenceExpression e);
protected abstract void GenerateThrowExceptionStatement (CodeThrowExceptionStatement s);
protected abstract void GenerateTryCatchFinallyStatement (CodeTryCatchFinallyStatement s);
protected abstract void GenerateTypeEnd( CodeTypeDeclaration declaration );
protected abstract void GenerateTypeConstructor( CodeTypeConstructor constructor );
protected virtual void GenerateTypeOfExpression (CodeTypeOfExpression e)
{
output.Write( "typeof(" );
OutputType( e.Type );
output.Write( ")" );
}
protected virtual void GenerateTypeReferenceExpression (CodeTypeReferenceExpression e)
{
OutputType( e.Type );
}
protected abstract void GenerateTypeStart( CodeTypeDeclaration declaration );
protected abstract void GenerateVariableDeclarationStatement (CodeVariableDeclarationStatement e);
protected abstract void GenerateVariableReferenceExpression( CodeVariableReferenceExpression e );
//
// Other members
//
/*
* Output Methods
*/
protected virtual void OutputAttributeArgument( CodeAttributeArgument argument )
{
string name = argument.Name;
if ( name != null ) {
output.Write( name );
output.Write( '=' );
}
GenerateExpression( argument.Value );
}
private void OutputAttributeDeclaration( CodeAttributeDeclaration attribute )
{
output.Write( attribute.Name );
output.Write( '(' );
IEnumerator enumerator = attribute.Arguments.GetEnumerator();
if ( enumerator.MoveNext() ) {
CodeAttributeArgument argument = (CodeAttributeArgument)enumerator.Current;
OutputAttributeArgument( argument );
while ( enumerator.MoveNext() ) {
output.Write( ',' );
argument = (CodeAttributeArgument)enumerator.Current;
OutputAttributeArgument( argument );
}
}
output.Write( ')' );
}
protected virtual void OutputAttributeDeclarations( CodeAttributeDeclarationCollection attributes )
{
GenerateAttributeDeclarationsStart( attributes );
IEnumerator enumerator = attributes.GetEnumerator();
if ( enumerator.MoveNext() ) {
CodeAttributeDeclaration attribute = (CodeAttributeDeclaration)enumerator.Current;
OutputAttributeDeclaration( attribute );
while ( enumerator.MoveNext() ) {
attribute = (CodeAttributeDeclaration)enumerator.Current;
output.WriteLine( ',' );
OutputAttributeDeclaration( attribute );
}
}
GenerateAttributeDeclarationsEnd( attributes );
}
protected virtual void OutputDirection( FieldDirection direction )
{
switch ( direction ) {
case FieldDirection.In:
//output.Write( "in " );
break;
case FieldDirection.Out:
output.Write( "out " );
break;
case FieldDirection.Ref:
output.Write( "ref " );
break;
}
}
protected virtual void OutputExpressionList( CodeExpressionCollection expressions )
{
OutputExpressionList( expressions, false );
}
protected virtual void OutputExpressionList( CodeExpressionCollection expressions,
bool newLineBetweenItems )
{
IEnumerator enumerator = expressions.GetEnumerator();
if ( enumerator.MoveNext() ) {
CodeExpression expression = (CodeExpression)enumerator.Current;
GenerateExpression( expression );
while ( enumerator.MoveNext() ) {
expression = (CodeExpression)enumerator.Current;
output.Write( ',' );
if ( newLineBetweenItems )
output.WriteLine();
else
output.Write( ' ' );
GenerateExpression( expression );
}
}
}
protected virtual void OutputFieldScopeModifier( MemberAttributes attributes )
{
if ( (attributes & MemberAttributes.VTableMask) == MemberAttributes.New )
output.Write( "new " );
switch ( attributes & MemberAttributes.ScopeMask ) {
case MemberAttributes.Static:
output.Write( "static " );
break;
case MemberAttributes.Const:
output.Write( "const " );
break;
}
}
protected virtual void OutputIdentifier( string ident )
{
output.Write (ident);
}
protected virtual void OutputMemberAccessModifier( MemberAttributes attributes )
{
switch ( attributes & MemberAttributes.AccessMask ) {
case MemberAttributes.Assembly:
output.Write( "internal " );
break;
case MemberAttributes.FamilyAndAssembly:
output.Write( "/* FamAndAssem */ internal " );
break;
case MemberAttributes.Family:
output.Write( "protected " );
break;
case MemberAttributes.FamilyOrAssembly:
output.Write( "protected internal " );
break;
case MemberAttributes.Private:
output.Write( "private " );
break;
case MemberAttributes.Public:
output.Write( "public " );
break;
}
}
protected virtual void OutputMemberScopeModifier( MemberAttributes attributes )
{
if ( (attributes & MemberAttributes.VTableMask) == MemberAttributes.New )
output.Write( "new " );
switch ( attributes & MemberAttributes.ScopeMask ) {
case MemberAttributes.Abstract:
output.Write( "abstract " );
break;
case MemberAttributes.Final:
// Do nothing
break;
case MemberAttributes.Static:
output.Write( "static " );
break;
case MemberAttributes.Override:
output.Write( "override " );
break;
default:
//
// FUNNY! if the scope value is
// rubbish (0 or >Const), and access
// is public or protected, make it
// "virtual".
//
// i'm not sure whether this is 100%
// correct, but it seems to be MS
// behavior.
//
MemberAttributes access = attributes & MemberAttributes.AccessMask;
if ( access == MemberAttributes.Public ||
access == MemberAttributes.Family )
output.Write( "virtual " );
break;
}
}
protected virtual void OutputOperator( CodeBinaryOperatorType op )
{
switch (op) {
case CodeBinaryOperatorType.Add:
output.Write ("+");
break;
case CodeBinaryOperatorType.Subtract:
output.Write ("-");
break;
case CodeBinaryOperatorType.Multiply:
output.Write ("*");
break;
case CodeBinaryOperatorType.Divide:
output.Write ("/");
break;
case CodeBinaryOperatorType.Modulus:
output.Write ("%");
break;
case CodeBinaryOperatorType.Assign:
output.Write ("=");
break;
case CodeBinaryOperatorType.IdentityInequality:
output.Write ("!=");
break;
case CodeBinaryOperatorType.IdentityEquality:
output.Write ("==");
break;
case CodeBinaryOperatorType.ValueEquality:
output.Write ("==");
break;
case CodeBinaryOperatorType.BitwiseOr:
output.Write ("|");
break;
case CodeBinaryOperatorType.BitwiseAnd:
output.Write ("&");
break;
case CodeBinaryOperatorType.BooleanOr:
output.Write ("||");
break;
case CodeBinaryOperatorType.BooleanAnd:
output.Write ("&&");
break;
case CodeBinaryOperatorType.LessThan:
output.Write ("<");
break;
case CodeBinaryOperatorType.LessThanOrEqual:
output.Write ("<=");
break;
case CodeBinaryOperatorType.GreaterThan:
output.Write (">");
break;
case CodeBinaryOperatorType.GreaterThanOrEqual:
output.Write (">=");
break;
}
}
protected virtual void OutputParameters( CodeParameterDeclarationExpressionCollection parameters )
{
bool first = true;
foreach (CodeParameterDeclarationExpression expr in parameters) {
GenerateExpression (expr);
if (first)
first = false;
else
output.Write (", ");
}
}
protected abstract void OutputType( CodeTypeReference t );
protected virtual void OutputTypeAttributes( TypeAttributes attributes,
bool isStruct,
bool isEnum )
{
switch ( attributes & TypeAttributes.VisibilityMask ) {
case TypeAttributes.NotPublic:
// private by default
break;
case TypeAttributes.Public:
case TypeAttributes.NestedPublic:
output.Write( "public " );
break;
case TypeAttributes.NestedPrivate:
output.Write( "private " );
break;
}
if ( isStruct )
output.Write( "struct " );
else if ( isEnum )
output.Write( "enum " );
else {
if ( (attributes & TypeAttributes.Interface) != 0 )
output.Write( "interface " );
else {
if ( (attributes & TypeAttributes.Sealed) != 0 )
output.Write( "sealed " );
if ( (attributes & TypeAttributes.Abstract) != 0 )
output.Write( "abstract " );
output.Write( "class " );
}
}
}
protected virtual void OutputTypeNamePair( CodeTypeReference type,
string name )
{
OutputType( type );
output.Write( ' ' );
output.Write( name );
}
protected abstract string QuoteSnippetString( string value );
/*
* ICodeGenerator
*/
protected abstract string CreateEscapedIdentifier( string value );
string ICodeGenerator.CreateEscapedIdentifier( string value )
{
return CreateEscapedIdentifier( value );
}
protected abstract string CreateValidIdentifier( string value );
string ICodeGenerator.CreateValidIdentifier( string value )
{
return CreateValidIdentifier( value );
}
private void InitOutput( TextWriter output, CodeGeneratorOptions options )
{
if ( options == null )
options = new CodeGeneratorOptions();
this.output = new IndentedTextWriter( output, options.IndentString );
this.options = options;
}
public virtual void GenerateCodeFromCompileUnit( CodeCompileUnit compileUnit,
TextWriter output,
CodeGeneratorOptions options )
{
InitOutput( output, options );
GenerateCompileUnit( compileUnit );
}
[MonoTODO]
public virtual void GenerateCodeFromExpression( CodeExpression expression,
TextWriter output,
CodeGeneratorOptions options )
{
InitOutput( output, options );
}
public virtual void GenerateCodeFromNamespace( CodeNamespace ns,
TextWriter output,
CodeGeneratorOptions options )
{
InitOutput( output, options );
GenerateNamespace( ns );
}
public virtual void GenerateCodeFromStatement( CodeStatement statement,
TextWriter output,
CodeGeneratorOptions options )
{
InitOutput( output, options );
}
public virtual void GenerateCodeFromType( CodeTypeDeclaration type,
TextWriter output,
CodeGeneratorOptions options )
{
CodeTypeDeclaration prevType = this.currentType;
this.currentType = type;
InitOutput( output, options );
GenerateTypeStart( type );
CodeTypeMember [] members = new CodeTypeMember [type.Members.Count];
type.Members.CopyTo (members, 0);
Array.Sort (members, CodeTypeMemberComparer.Default);
// WARNING: if anything is missing in the foreach loop and you add it, add the type in
// its corresponding place in CodeTypeMemberComparer class (below)
foreach ( CodeTypeMember member in members ) {
CodeTypeMember prevMember = this.currentMember;
this.currentMember = member;
if ( options.BlankLinesBetweenMembers )
output.WriteLine();
CodeMemberEvent eventm = member as CodeMemberEvent;
if ( eventm != null ) {
GenerateEvent( eventm, type );
continue;
}
CodeMemberField field = member as CodeMemberField;
if ( field != null ) {
GenerateField( field );
continue;
}
CodeEntryPointMethod epmethod = member as CodeEntryPointMethod;
if ( epmethod != null ) {
GenerateEntryPointMethod( epmethod, type );
continue;
}
CodeTypeConstructor typeCtor = member as CodeTypeConstructor;
if (typeCtor != null) {
GenerateTypeConstructor (typeCtor);
continue;
}
CodeConstructor ctor = member as CodeConstructor;
if (ctor != null) {
GenerateConstructor (ctor, type);
continue;
}
CodeMemberMethod method = member as CodeMemberMethod;
if ( method != null ) {
GenerateMethod( method, type );
continue;
}
CodeMemberProperty property = member as CodeMemberProperty;
if ( property != null ) {
GenerateProperty( property, type );
continue;
}
CodeSnippetTypeMember snippet = member as CodeSnippetTypeMember;
if ( snippet != null ) {
GenerateSnippetMember( snippet );
continue;
}
CodeTypeDeclaration subtype = member as CodeTypeDeclaration;
if ( subtype != null ) {
GenerateCodeFromType( subtype, output, options );
continue;
}
this.currentMember = prevMember;
}
GenerateTypeEnd( type );
this.currentType = prevType;
}
protected abstract string GetTypeOutput( CodeTypeReference type );
string ICodeGenerator.GetTypeOutput( CodeTypeReference type )
{
return GetTypeOutput( type );
}
protected abstract bool IsValidIdentifier( string value );
bool ICodeGenerator.IsValidIdentifier( string value )
{
return IsValidIdentifier( value );
}
protected abstract bool Supports( GeneratorSupport supports );
bool ICodeGenerator.Supports( GeneratorSupport value )
{
return Supports( value );
}
[MonoTODO]
protected virtual void ValidateIdentifier( string value )
{
throw new NotImplementedException();
}
void ICodeGenerator.ValidateIdentifier( string value )
{
ValidateIdentifier( value );
}
class CodeTypeMemberComparer : IComparer
{
private CodeTypeMemberComparer () {}
static CodeTypeMemberComparer instance = new CodeTypeMemberComparer ();
// The position in the array determines the order in which those
// kind of CodeTypeMembers are generated. Less is more ;-)
static Type [] memberTypes = { typeof (CodeMemberField),
typeof (CodeSnippetTypeMember),
typeof (CodeTypeConstructor),
typeof (CodeConstructor),
typeof (CodeMemberProperty),
typeof (CodeMemberEvent),
typeof (CodeMemberMethod),
typeof (CodeTypeDeclaration),
typeof (CodeEntryPointMethod)
};
public IComparer Default {
get { return instance; }
}
int IComparer.Compare (object x, object y)
{
int xindex = Array.IndexOf (memberTypes, x.GetType ());
int yindex = Array.IndexOf (memberTypes, y.GetType ());
return xindex - yindex;
}
}
}
}