codedomvisitor.cs

c#源代码

// CodeDOMVisitor.cs
// Copyright (C) 2003 Mike Krueger ([e-mail])
// 
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

using System;
using System.Reflection;
using System.CodeDom;
using System.Text;
using System.Collections;

using ICSharpCode.SharpRefactory.Parser.AST.VB;

namespace ICSharpCode.SharpRefactory.Parser.VB
{
	public class CodeDOMVisitor : AbstractASTVisitor
	{
		Stack namespaceDeclarations = new Stack();
		Stack typeDeclarations     = new Stack();
		CodeMemberMethod currentMethod = null;
		TypeDeclaration currentTypeDeclaration;
		
		public CodeCompileUnit codeCompileUnit = new CodeCompileUnit();
		public ArrayList namespaces            = new ArrayList();
		public ArrayList withEventsFields      = new ArrayList();
		
		static string[,] typeConversionList = new string[,] {
			{"System.Object",	"OBJECT"},
			{"System.Boolean",	"BOOLEAN"},
			{"System.Byte",		"BYTE"},
			{"System.Char",		"CHAR"},
			{"System.Int16",	"SHORT"},
			{"System.Int32",	"INTEGER"},
			{"System.Int64",	"LONG"},
			{"System.Single",	"SINGLE"},
			{"System.Double",	"DOUBLE"},
			{"System.Decimal",	"DECIMAL"},
			{"System.String",	"STRING"},
			{"System.DateTime",	"DATE"}
		};
		
		static Hashtable typeConversionTable = new Hashtable();
		
		static CodeDOMVisitor()
		{
			for (int i = 0; i < typeConversionList.GetLength(0); ++i) {
				typeConversionTable[typeConversionList[i, 1]] = typeConversionList[i, 0];
			}
		}
		string ConvType(string type) 
		{
			string upperType = type.ToUpper(System.Globalization.CultureInfo.InvariantCulture);
			if (typeConversionTable[upperType] != null) {
				return typeConversionTable[upperType].ToString();
			}
			return type;
		}
		// FIXME: map all modifiers correctly
		MemberAttributes ConvMemberAttributes(Modifier modifier) 
		{
			MemberAttributes attr = (MemberAttributes)0;
			
			if ((modifier & Modifier.Private) != 0) {
				attr |=  MemberAttributes.Private;
			}
			if ((modifier & Modifier.Public) != 0) {
				attr |=  MemberAttributes.Public;
			}
			if ((modifier & Modifier.Protected) != 0) {
				attr |=  MemberAttributes.Family;
			}
			if ((modifier & Modifier.Friend) != 0) {
				attr |=  MemberAttributes.Assembly;
			}
			if ((modifier & Modifier.Static) != 0) {
				attr |=  MemberAttributes.Static;
			}
			return attr;
		}
		
#region ICSharpCode.SharpRefactory.Parser.IASTVisitor interface implementation
		public override object Visit(INode node, object data)
		{
			return null;
		}
		
		public override object Visit(CompilationUnit compilationUnit, object data)
		{
			CodeNamespace globalNamespace = new CodeNamespace("Global");
			namespaces.Add(globalNamespace);
			namespaceDeclarations.Push(globalNamespace);
			compilationUnit.AcceptChildren(this, data);
			codeCompileUnit.Namespaces.Add(globalNamespace);
			return globalNamespace;
		}
		
		public override object Visit(NamespaceDeclaration namespaceDeclaration, object data)
		{
			CodeNamespace currentNamespace = new CodeNamespace(namespaceDeclaration.NameSpace);
			namespaces.Add(currentNamespace);
			// add imports from mother namespace
			foreach (CodeNamespaceImport import in ((CodeNamespace)namespaceDeclarations.Peek()).Imports) {
				currentNamespace.Imports.Add(import);
			}
			namespaceDeclarations.Push(currentNamespace);
			namespaceDeclaration.AcceptChildren(this, data);
			namespaceDeclarations.Pop();
			codeCompileUnit.Namespaces.Add(currentNamespace);
			
			// TODO : Nested namespaces allowed in CodeDOM ? Doesn't seem so :(
			return null;
		}
		
		public override object Visit(ImportsDeclaration importsDeclaration, object data)
		{
			((CodeNamespace)namespaceDeclarations.Peek()).Imports.Add(new CodeNamespaceImport(importsDeclaration.Namespace));
			return null;
		}
		
		public override object Visit(ImportsAliasDeclaration importsAliasDeclaration, object data)
		{
			return null;
		}
		
		public override object Visit(AttributeSection attributeSection, object data)
		{
			return null;
		}
		
		// TODO: OptionCompareDeclaration, OptionExplicitDeclaration, OptionStrictDeclaration
		
		public override object Visit(TypeDeclaration typeDeclaration, object data)
		{
			// skip nested types.
			if (currentTypeDeclaration != null) {
				return data;
			}
			if (typeDeclaration.Type == Types.Enum) {
				return data;
			}
			this.currentTypeDeclaration = typeDeclaration;
			CodeTypeDeclaration codeTypeDeclaration = new CodeTypeDeclaration(typeDeclaration.Name);
			codeTypeDeclaration.IsClass     = typeDeclaration.Type == Types.Class;
			codeTypeDeclaration.IsEnum      = typeDeclaration.Type == Types.Enum;
			codeTypeDeclaration.IsInterface = typeDeclaration.Type == Types.Interface;
			codeTypeDeclaration.IsStruct    = typeDeclaration.Type == Types.Structure;
			
			if (typeDeclaration.BaseType != null) {
				codeTypeDeclaration.BaseTypes.Add(new CodeTypeReference(typeDeclaration.BaseType));
			}
			
			if (typeDeclaration.BaseInterfaces != null) {
				foreach (object o in typeDeclaration.BaseInterfaces) {
					codeTypeDeclaration.BaseTypes.Add(new CodeTypeReference(o.ToString()));
				}
			}
			
			typeDeclarations.Push(codeTypeDeclaration);
			typeDeclaration.AcceptChildren(this,data);
//			((INode)typeDeclaration.Children[0]).(this, data);
			
			typeDeclarations.Pop();
			
			((CodeNamespace)namespaceDeclarations.Peek()).Types.Add(codeTypeDeclaration);
			this.currentTypeDeclaration = null;
			return null;
		}
		
		public override object Visit(DelegateDeclaration delegateDeclaration, object data)
		{
//			CodeTypeDelegate codeTypeDelegate = new CodeTypeDelegate(delegateDeclaration.Name);
//			codeTypeDelegate.Parameters
//			
//			((CodeNamespace)namespaceDeclarations.Peek()).Types.Add(codeTypeDelegate);
			return null;
		}
		
		public override object Visit(VariableDeclaration variableDeclaration, object data)
		{
			return null;
		}
		
		public override object Visit(FieldDeclaration fieldDeclaration, object data)
		{
			for (int i = 0; i < fieldDeclaration.Fields.Count; ++i) {
				VariableDeclaration field = (VariableDeclaration)fieldDeclaration.Fields[i];
				if (field.Type != null) {
					CodeMemberField memberField = new CodeMemberField(new CodeTypeReference(ConvType(field.Type.Type)), field.Name);
					if ((fieldDeclaration.Modifier & Modifier.WithEvents) != 0) {
						withEventsFields.Add(field);
					}
					memberField.Attributes = ConvMemberAttributes(fieldDeclaration.Modifier);
					if (field.Initializer != null) {
						memberField.InitExpression =  (CodeExpression)((INode)field.Initializer).AcceptVisitor(this, data);
					}
					((CodeTypeDeclaration)typeDeclarations.Peek()).Members.Add(memberField);
				}
			}
			
			return null;
		}
		
		public override object Visit(MethodDeclaration methodDeclaration, object data)
		{
			CodeMemberMethod memberMethod = new CodeMemberMethod();
			memberMethod.Name = methodDeclaration.Name;
			currentMethod = memberMethod;
			((CodeTypeDeclaration)typeDeclarations.Peek()).Members.Add(memberMethod);
			if (memberMethod.Name.ToUpper(System.Globalization.CultureInfo.InvariantCulture) == "INITIALIZECOMPONENT") {
				methodDeclaration.Body.AcceptChildren(this, data);
			}
			currentMethod = null;
			return null;
		}
		
		public override object Visit(PropertyDeclaration propertyDeclaration, object data)
		{
			return null;
		}
		
		public override object Visit(PropertyGetRegion propertyGetRegion, object data)
		{
			return null;
		}
		
		public override object Visit(PropertySetRegion PropertySetRegion, object data)
		{
			return null;
		}
		
		public override object Visit(EventDeclaration eventDeclaration, object data)
		{
			return null;
		}
		
		// TODO: HandlesClause, ImplementsClause
		
		public override object Visit(ConstructorDeclaration constructorDeclaration, object data)
		{
			CodeConstructor memberMethod = new CodeConstructor();
			// HACK: fake public constructor
			memberMethod.Attributes = MemberAttributes.Public;
			currentMethod = memberMethod;
			((CodeTypeDeclaration)typeDeclarations.Peek()).Members.Add(memberMethod);
			constructorDeclaration.Body.AcceptChildren(this, data);
			currentMethod = null;
			return null;
		}
		
		public override object Visit(BlockStatement blockStatement, object data)
		{
			blockStatement.AcceptChildren(this, data);
			return null;
		}
		
		public override object Visit(StatementExpression statementExpression, object data)
		{
			if (statementExpression.Expression == null) {
				Console.WriteLine("Warning: Got empty statement expression!!!");
				return null;
			}
			CodeExpression expr = (CodeExpression)statementExpression.Expression.AcceptVisitor(this, data);
			if (expr == null) {
				if (!(statementExpression.Expression is AssignmentExpression)) {
					Console.WriteLine("NULL EXPRESSION : " + statementExpression.Expression);
				}
			} else {
				currentMethod.Statements.Add(new CodeExpressionStatement(expr));
			}
			
			return null;
		}
		
		public string Convert(TypeReference typeRef)
		{
			StringBuilder builder = new StringBuilder();
			builder.Append(ConvType(typeRef.Type));
			
			if (typeRef.RankSpecifier != null) {
				for (int i = 0; i < typeRef.RankSpecifier.Count; ++i) {
					builder.Append('[');
					for (int j = 1; j < (int)typeRef.RankSpecifier[i]; ++j) {
						builder.Append(',');
					}
					builder.Append(']');
				}
			}
			
			return builder.ToString();