Files
mono/mcs/class/System/System.CodeDom.Compiler/CodeGenerator.cs
T
Gert Driesen c3f574d8f0 * CodeGeneratorFromExpressionTest.cs: Added tests for
CodePrimitiveExpression.
* CSharpCodeGenerator.cs: Override GeneratePrimitiveExpression to
match .NET 1.x and 2.0 for float, decimal, char, ushort, uint, ulong
and sbyte.
* CodeGenerator.cs: Modified GeneratePrimitiveExpression to throw
ArgumentException for sbyte value, use GenerateSingleFloatValue for
float, GenerateDecimalValue for decimal and GenerateDoubleValue for
double. Modified exception message for non-primitive types to match
MS.NET.
* ICodeCompiler.cs: Set eol-style to native.
* CodeCompiler.cs: Set eol-style to native.
* CodeDomConfigurationHandler.cs: Set eol-style to native.
* CodeDomProvider.cs: Set eol-style to native.
* CodeGeneratorOptions.cs: Set eol-style to native.
* CodeParser.cs: Set eol-style to native.
* CompilerError.cs: Set eol-style to native.
* CompilerErrorCollection.cs: Set eol-style to native.
* CompilerInfo.cs: Set eol-style to native.
* CompilerParameters.cs: Set eol-style to native.
* CompilerResults.cs: Set eol-style to native.
* Executor.cs: Set eol-style to native.
* GeneratorSupport.cs: Set eol-style to native.
* ICodeGenerator.cs: Set eol-style to native.
* ICodeParser.cs: Set eol-style to native.
* LanguageOptions.cs: Set eol-style to native.
* TempFileCollection.cs: Set eol-style to native.
* VBCodeGenerator.cs: Modified GeneratePrimitiveExpression to match
.NET 1.x and 2.0 for char, float, ushort, uint, ulong and sbyte.

svn path=/trunk/mcs/; revision=54032
2005-12-07 13:16:31 +00:00

1299 lines
37 KiB
C#

//
// System.CodeDom.Compiler.CodeGenerator.cs
//
// Authors:
// Miguel de Icaza ([email protected])
// Daniel Stodden ([email protected])
// Gonzalo Paniagua Javier ([email protected])
// Andreas Nahr ([email protected])
// Marek Safar ([email protected])
//
// (C) 2001-2003 Ximian, Inc.
//
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System.Globalization;
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
//
#if NET_2_0
protected CodeTypeDeclaration CurrentClass {
get {
return currentType;
}
}
#endif
protected CodeTypeMember CurrentMember {
get {
return currentMember;
}
}
protected string CurrentMemberName {
get {
if (currentMember == null)
return "<% unknown %>";
return currentMember.Name;
}
}
protected string CurrentTypeName {
get {
if (currentType == null)
return "<% unknown %>";
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 && !(currentType is CodeTypeDelegate);
}
}
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);
#if NET_2_0
[MonoTODO]
public virtual void GenerateCodeFromMember (CodeTypeMember member, TextWriter writer, CodeGeneratorOptions options)
{
throw new NotImplementedException ();
}
#endif
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) {
foreach (CodeAttributeDeclaration att in attributes) {
GenerateAttributeDeclarationsStart (attributes);
output.Write ("assembly: ");
OutputAttributeDeclaration (att);
GenerateAttributeDeclarationsEnd (attributes);
}
output.WriteLine ();
}
foreach (CodeNamespace ns in compileUnit.Namespaces)
GenerateNamespace (ns);
GenerateCompileUnitEnd (compileUnit);
}
protected virtual void GenerateCompileUnitEnd (CodeCompileUnit compileUnit)
{
#if NET_2_0
if (compileUnit.EndDirectives.Count > 0)
GenerateDirectives (compileUnit.EndDirectives);
#endif
}
protected virtual void GenerateCompileUnitStart (CodeCompileUnit compileUnit)
{
#if NET_2_0
if (compileUnit.StartDirectives.Count > 0) {
GenerateDirectives (compileUnit.StartDirectives);
Output.WriteLine ();
}
#endif
}
protected abstract void GenerateConditionStatement (CodeConditionStatement s);
protected abstract void GenerateConstructor (CodeConstructor x, CodeTypeDeclaration d);
protected virtual void GenerateDecimalValue (Decimal d)
{
Output.Write (d.ToString (CultureInfo.InvariantCulture));
}
#if NET_2_0
[MonoTODO]
protected virtual void GenerateDefaultValueExpression (CodeDefaultValueExpression e)
{
throw new NotImplementedException ();
}
#endif
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 virtual void GenerateDoubleValue (Double d)
{
Output.Write (d.ToString (CultureInfo.InvariantCulture));
}
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)
{
if (e == null)
throw new ArgumentNullException ("Value cannot be null.");
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;
}
throw new ArgumentException ("Element type " + e + " is not supported.");
}
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) {
if (import.LinePragma != null)
GenerateLinePragmaStart (import.LinePragma);
GenerateNamespaceImport (import);
if (import.LinePragma != null)
GenerateLinePragmaEnd (import.LinePragma);
}
output.WriteLine();
foreach (CodeTypeDeclaration type in ns.Types) {
GenerateType (type);
output.WriteLine();
}
GenerateNamespaceEnd (ns);
}
protected abstract void GenerateNamespaceStart (CodeNamespace ns);
protected abstract void GenerateNamespaceEnd (CodeNamespace ns);
protected abstract void GenerateNamespaceImport (CodeNamespaceImport i);
protected void GenerateNamespaceImports (CodeNamespace e)
{
foreach (CodeNamespaceImport import in e.Imports) {
if (import.LinePragma != null)
GenerateLinePragmaStart (import.LinePragma);
GenerateNamespaceImport (import);
if (import.LinePragma != null)
GenerateLinePragmaEnd (import.LinePragma);
}
}
protected void GenerateNamespaces (CodeCompileUnit e)
{
foreach (CodeNamespace ns in e.Namespaces)
GenerateNamespace (ns);
}
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 (NullToken);
return;
}
Type type = e.Value.GetType ();
if (type == typeof (bool)) {
output.Write (e.Value.ToString ().ToLower (CultureInfo.InvariantCulture));
} else if (type == typeof (char)) {
output.Write ("'" + e.Value.ToString () + "'");
} else if (type == typeof (string)) {
output.Write (QuoteSnippetString ((string) e.Value));
} else if (type == typeof (float)) {
GenerateSingleFloatValue((float) e.Value);
} else if (type == typeof (double)) {
GenerateDoubleValue((double) e.Value);
} else if (type == typeof (decimal)) {
this.GenerateDecimalValue((decimal) e.Value);
} else if (type == typeof (byte) || type == typeof (short) ||
type == typeof (int) || type == typeof (long)) {
// All of these should be IFormatable, I am just being safe/slow
IFormattable formattable = e.Value as IFormattable;
if (formattable != null) {
output.Write (formattable.ToString (null, CultureInfo.InvariantCulture));
} else {
output.Write (e.Value.ToString ());
}
} else {
throw new ArgumentException (string.Format(CultureInfo.InvariantCulture,
"Invalid Primitive Type: {0}. Only CLS compliant primitive " +
"types can be used. Consider using CodeObjectCreateExpression.",
type.FullName));
}
}
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 virtual void GenerateSingleFloatValue (Single s)
{
output.Write (s.ToString(CultureInfo.InvariantCulture));
}
protected virtual void GenerateSnippetCompileUnit (CodeSnippetCompileUnit e)
{
if (e.LinePragma != null)
GenerateLinePragmaStart (e.LinePragma);
output.WriteLine (e.Value);
if (e.LinePragma != null)
GenerateLinePragmaEnd (e.LinePragma);
}
protected abstract void GenerateSnippetExpression (CodeSnippetExpression e);
protected abstract void GenerateSnippetMember (CodeSnippetTypeMember m);
protected virtual void GenerateSnippetStatement (CodeSnippetStatement s)
{
output.WriteLine (s.Value);
}
protected void GenerateStatement (CodeStatement s)
{
bool handled = false;
#if NET_2_0
if (s.StartDirectives.Count > 0)
GenerateDirectives (s.StartDirectives);
#endif
if (s.LinePragma != null)
GenerateLinePragmaStart (s.LinePragma);
CodeAssignStatement assign = s as CodeAssignStatement;
if (assign != null) {
GenerateAssignStatement (assign);
handled = true;
}
CodeAttachEventStatement attach = s as CodeAttachEventStatement;
if (attach != null) {
GenerateAttachEventStatement (attach);
handled = true;
}
CodeCommentStatement comment = s as CodeCommentStatement;
if (comment != null) {
GenerateCommentStatement (comment);
handled = true;
}
CodeConditionStatement condition = s as CodeConditionStatement;
if (condition != null) {
GenerateConditionStatement (condition);
handled = true;
}
CodeExpressionStatement expression = s as CodeExpressionStatement;
if (expression != null) {
GenerateExpressionStatement (expression);
handled = true;
}
CodeGotoStatement gotostmt = s as CodeGotoStatement;
if (gotostmt != null) {
GenerateGotoStatement (gotostmt);
handled = true;
}
CodeIterationStatement iteration = s as CodeIterationStatement;
if (iteration != null) {
GenerateIterationStatement (iteration);
handled = true;
}
CodeLabeledStatement label = s as CodeLabeledStatement;
if (label != null) {
GenerateLabeledStatement (label);
handled = true;
}
CodeMethodReturnStatement returnstmt = s as CodeMethodReturnStatement;
if (returnstmt != null) {
GenerateMethodReturnStatement (returnstmt);
handled = true;
}
CodeRemoveEventStatement remove = s as CodeRemoveEventStatement;
if (remove != null) {
GenerateRemoveEventStatement (remove);
handled = true;
}
CodeSnippetStatement snippet = s as CodeSnippetStatement;
if (snippet != null) {
#if NET_2_0
int indent = Indent;
try {
Indent = 0;
GenerateSnippetStatement (snippet);
} finally {
Indent = indent;
}
#else
GenerateSnippetStatement (snippet);
#endif
handled = true;
}
CodeThrowExceptionStatement exception = s as CodeThrowExceptionStatement;
if (exception != null) {
GenerateThrowExceptionStatement (exception);
handled = true;
}
CodeTryCatchFinallyStatement trycatch = s as CodeTryCatchFinallyStatement;
if (trycatch != null) {
GenerateTryCatchFinallyStatement (trycatch);
handled = true;
}
CodeVariableDeclarationStatement declaration = s as CodeVariableDeclarationStatement;
if (declaration != null) {
GenerateVariableDeclarationStatement (declaration);
handled = true;
}
if (!handled)
throw new ArgumentException ("Element type " + s + " is not supported.");
if (s.LinePragma != null)
GenerateLinePragmaEnd (s.LinePragma);
#if NET_2_0
if (s.EndDirectives.Count > 0)
GenerateDirectives (s.EndDirectives);
#endif
}
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 void GenerateTypes (CodeNamespace e)
{
foreach (CodeTypeDeclaration type in e.Types)
GenerateType (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) && (name.Length > 0)) {
output.Write (name);
output.Write ('=');
}
GenerateExpression (argument.Value);
}
private void OutputAttributeDeclaration (CodeAttributeDeclaration attribute)
{
output.Write (attribute.Name.Replace ('+', '.'));
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:
#if NET_2_0
output.Write ("internal ");
#else
output.Write ("/*FamANDAssem*/ internal ");
#endif
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 NET_2_0
if ((attributes & MemberAttributes.VTableMask) == MemberAttributes.New)
output.Write( "new " );
#endif
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.
//
// On .NET 2.0, internal members
// are also marked "virtual".
//
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) {
if (first)
first = false;
else
output.Write (", ");
GenerateExpression (expr);
}
}
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 (currentType is CodeTypeDelegate)
output.Write ("delegate ");
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;
}
void ICodeGenerator.GenerateCodeFromCompileUnit (CodeCompileUnit compileUnit,
TextWriter output,
CodeGeneratorOptions options)
{
InitOutput (output, options);
if (compileUnit is CodeSnippetCompileUnit) {
GenerateSnippetCompileUnit ((CodeSnippetCompileUnit) compileUnit);
} else {
GenerateCompileUnit (compileUnit);
}
}
void ICodeGenerator.GenerateCodeFromExpression (CodeExpression expression,
TextWriter output,
CodeGeneratorOptions options)
{
InitOutput (output, options);
GenerateExpression (expression);
}
void ICodeGenerator.GenerateCodeFromNamespace (CodeNamespace ns,
TextWriter output,
CodeGeneratorOptions options)
{
InitOutput (output, options);
GenerateNamespace (ns);
}
void ICodeGenerator.GenerateCodeFromStatement (CodeStatement statement,
TextWriter output,
CodeGeneratorOptions options)
{
InitOutput (output, options);
GenerateStatement (statement);
}
void ICodeGenerator.GenerateCodeFromType (CodeTypeDeclaration type,
TextWriter output,
CodeGeneratorOptions options)
{
InitOutput (output, options);
GenerateType (type);
}
private void GenerateType (CodeTypeDeclaration type)
{
this.currentType = type;
#if NET_2_0
if (type.StartDirectives.Count > 0)
GenerateDirectives (type.StartDirectives);
#endif
foreach (CodeCommentStatement statement in type.Comments)
GenerateCommentStatement (statement);
if (type.LinePragma != null)
GenerateLinePragmaStart (type.LinePragma);
GenerateTypeStart (type);
CodeTypeMember[] members = new CodeTypeMember[type.Members.Count];
type.Members.CopyTo (members, 0);
#if NET_2_0
if (!Options.VerbatimOrder)
#endif
{
int[] order = new int[members.Length];
for (int n = 0; n < members.Length; n++)
order[n] = Array.IndexOf (memberTypes, members[n].GetType ()) * members.Length + n;
Array.Sort (order, members);
}
// WARNING: if anything is missing in the foreach loop and you add it, add the type in
// its corresponding place in CodeTypeMemberComparer class (below)
CodeTypeDeclaration subtype = null;
foreach (CodeTypeMember member in members) {
CodeTypeMember prevMember = this.currentMember;
this.currentMember = member;
if (prevMember != null && subtype == null) {
if (prevMember.LinePragma != null)
GenerateLinePragmaEnd (prevMember.LinePragma);
#if NET_2_0
if (prevMember.EndDirectives.Count > 0)
GenerateDirectives (prevMember.EndDirectives);
#endif
}
if (options.BlankLinesBetweenMembers)
output.WriteLine ();
subtype = member as CodeTypeDeclaration;
if (subtype != null) {
GenerateType (subtype);
this.currentType = type;
continue;
}
#if NET_2_0
if (currentMember.StartDirectives.Count > 0)
GenerateDirectives (currentMember.StartDirectives);
#endif
foreach (CodeCommentStatement statement in member.Comments)
GenerateCommentStatement (statement);
if (member.LinePragma != null)
GenerateLinePragmaStart (member.LinePragma);
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;
}
this.currentMember = prevMember;
}
// Hack because of previous continue usage
if (currentMember != null && !(currentMember is CodeTypeDeclaration)) {
if (currentMember.LinePragma != null)
GenerateLinePragmaEnd (currentMember.LinePragma);
#if NET_2_0
if (currentMember.EndDirectives.Count > 0)
GenerateDirectives (currentMember.EndDirectives);
#endif
}
this.currentType = type;
GenerateTypeEnd (type);
if (type.LinePragma != null)
GenerateLinePragmaEnd (type.LinePragma);
#if NET_2_0
if (type.EndDirectives.Count > 0)
GenerateDirectives (type.EndDirectives);
#endif
}
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);
}
public static bool IsValidLanguageIndependentIdentifier (string value)
{
if (value == null)
return false;
if (value.Equals (string.Empty))
return false;
switch (char.GetUnicodeCategory (value[0]))
{
case UnicodeCategory.LetterNumber:
case UnicodeCategory.LowercaseLetter:
case UnicodeCategory.TitlecaseLetter:
case UnicodeCategory.UppercaseLetter:
case UnicodeCategory.OtherLetter:
case UnicodeCategory.ModifierLetter:
case UnicodeCategory.ConnectorPunctuation:
if (value.Length > 1)
{
for (int x = 0; x < value.Length; x++)
{
switch (char.GetUnicodeCategory (value[x]))
{
case UnicodeCategory.LetterNumber:
case UnicodeCategory.LowercaseLetter:
case UnicodeCategory.TitlecaseLetter:
case UnicodeCategory.UppercaseLetter:
case UnicodeCategory.OtherLetter:
case UnicodeCategory.ModifierLetter:
case UnicodeCategory.ConnectorPunctuation:
case UnicodeCategory.DecimalDigitNumber:
case UnicodeCategory.NonSpacingMark:
case UnicodeCategory.SpacingCombiningMark:
case UnicodeCategory.Format:
return true;
}
return false;
}
}
else
return true;
break;
}
return false;
}
protected abstract bool Supports (GeneratorSupport supports);
bool ICodeGenerator.Supports (GeneratorSupport value)
{
return Supports (value);
}
protected virtual void ValidateIdentifier (string value)
{
if (!(IsValidIdentifier (value)))
throw new ArgumentException ("Identifier is invalid", "value");
}
[MonoTODO]
public static void ValidateIdentifiers (CodeObject e)
{
throw new NotImplementedException();
}
void ICodeGenerator.ValidateIdentifier (string value)
{
ValidateIdentifier (value);
}
// 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)
};
#if NET_2_0
protected virtual void GenerateDirectives (CodeDirectiveCollection directives)
{
}
#endif
}
}