csharpgen.cs

C#编写的c#编译器

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

using DDW.CSharp.Dom;
using DDW.CSharp.Walk;

namespace DDW.CSharp.Gen
{		
	public class CSharpGen : GraphParserBase
	{
		LineWriter sb;
		private bool termStmt = true;
		private bool addSpace = true;
		private bool isInterface = false;

		public CSharpGen(TextWriter tw)
		{
			sb = new LineWriter(tw); 
		}
		

		#region CompileUnit *
		public override void ParseElement(CompileUnit gr)
		{
			if(gr.Imports.Count != 0)
			{
				Parse(gr.Imports);
				sb.WriteLine("");
			}
			if(gr.AssemblyCustomAttributes.Count != 0)
			{
				Parse(gr.AssemblyCustomAttributes);
				sb.WriteLine("");
			}
			Parse(gr.Namespaces);
		}
		#endregion
		#region Import *
		public override void ParseElement(Import gr)
		{
			sb.Write("using "); 
			if(gr.Alias != null) 
				sb.Write(gr.Alias + " = ");
			sb.WriteLine(gr.Namespace + ";");
		}
		#endregion
		#region NamespaceDecl *
		public override void ParseElement(NamespaceDecl gr)
		{
			sb.Write("namespace " + gr.Name);
			OpenBlock();
			Parse(gr.Imports);
			Parse(gr.Types);
			CloseBlock();
		}
		#endregion

		#region MethodDecl *
		public override void ParseElement(MethodDecl gr)
		{
			Parse(gr.Comments);
			Parse(gr.CustomAttributes);
			Parse(gr.ReturnTypeCustomAttributes);

			ParseElement(gr.Attributes);
			Parse(gr.ReturnType);
			sb.Write(gr.Name);
			Parse(gr.Parameters); 
			if(	isInterface || 
				(int)(gr.Attributes & Modifiers.Abstract) > 0)
			{
				sb.WriteLine(";");
			}
			else
			{
				OpenBlock();
				Parse(gr.Statements);
				CloseBlock();
			}
		}
		#endregion
		#region FieldDecl *
		public override void ParseElement(FieldDecl gr)
		{
			Parse(gr.Comments);
			Parse(gr.CustomAttributes);
			ParseElement(gr.Attributes);
			Parse(gr.Type);
			string comma = "";
			foreach(Declarator dl in gr.Delcarators)
			{
				sb.Write(comma);
				ParseElement(dl);
				comma = ", ";
			}
			sb.WriteLine(";");
		}
		#endregion
		#region PropertyDecl *
		public override void ParseElement(PropertyDecl gr)
		{
			Parse(gr.Comments);
			Parse(gr.CustomAttributes);
			ParseElement(gr.Attributes);
			Parse(gr.Type);
			sb.Write(gr.Name);
			OpenBlock();
			if(	isInterface ||
				(int)(gr.Attributes & Modifiers.Abstract) > 0)
			{
				if(gr.HasGet)sb.WriteLine("get;");
			}
			else
			{
				Parse(gr.GetAccessor);
			}
			if(	isInterface ||
				(int)(gr.Attributes & Modifiers.Abstract) > 0)
			{
				if(gr.HasSet)sb.WriteLine("set;");
			}
			else
			{
				Parse(gr.SetAccessor);
			}
			CloseBlock();
		}
		#endregion
		#region EventDecl *
		public override void ParseElement(EventDecl gr)
		{
			Parse(gr.Comments);
			Parse(gr.CustomAttributes);
			ParseElement(gr.Attributes);
			sb.Write("event ");
			Parse(gr.Type);
			string comma = "";
			foreach(Declarator dl in gr.Delcarators)
			{
				sb.Write(comma);
				ParseElement(dl); // will only be name part...
				comma = ", ";
			}
			if(gr.UsesAccessors)
			{
				// always uses both accessors
				OpenBlock();
				if(	isInterface ||
					(int)(gr.Attributes & Modifiers.Abstract) > 0)
				{
					sb.WriteLine("add;");
				}
				else
				{
					Parse(gr.AddAccessor);
				}
				if(	isInterface ||
					(int)(gr.Attributes & Modifiers.Abstract) > 0)
				{
					sb.WriteLine("remove;");
				}
				else
				{
					Parse(gr.RemoveAccessor);
				}
				CloseBlock();
			}
			else
			{
				sb.WriteLine(";");
			}
		}
		#endregion
		#region ConstantDecl *
		public override void ParseElement(ConstantDecl gr)
		{
			Parse(gr.Comments);
			Parse(gr.CustomAttributes);
			ParseElement(gr.Attributes);
			sb.Write("const ");
			Parse(gr.Type);
			string comma = "";
			foreach(Declarator dl in gr.Delcarators)
			{
				sb.Write(comma);
				ParseElement(dl);
				comma = ", ";
			}
			sb.WriteLine(";");
		}
		#endregion
		#region IndexerDecl *
		public override void ParseElement(IndexerDecl gr)
		{
			Parse(gr.Comments);
			Parse(gr.CustomAttributes);
			ParseElement(gr.Attributes);
			Parse(gr.Type);
			if(gr.InterfaceType != null)
				sb.Write(gr.InterfaceType.TypeName + ".");
			sb.Write("this[");
			Parse(gr.Parameters); 
			sb.Write("]");			
			OpenBlock();
			if(	isInterface ||
				(int)(gr.Attributes & Modifiers.Abstract) > 0)
			{
				if(gr.HasGet)sb.WriteLine("get;");
			}
			else
			{
				Parse(gr.GetAccessor);
			}
			if(	isInterface ||
				(int)(gr.Attributes & Modifiers.Abstract) > 0)
			{
				if(gr.HasSet)sb.WriteLine("set;");
			}
			else
			{
				Parse(gr.SetAccessor);
			}
			CloseBlock();
		}
		#endregion
		#region OperatorDecl *
		public override void ParseElement(OperatorDecl gr)
		{
			Parse(gr.Comments);
			Parse(gr.CustomAttributes);
			ParseElement(gr.Attributes);
			Parse(gr.Type);
			sb.Write("operator ");
			ParseElement(gr.Operator);
			// always one param
			sb.Write("(");
			Parse(gr.FirstParameter);
			if(gr.SecondParameter != null)
			{
				sb.Write(", ");
				Parse(gr.FirstParameter);
			}
			sb.Write(")");
			if(gr.Statements.Count > 0)
			{
				OpenBlock();
				Parse(gr.Statements);
				CloseBlock();
			}
			else
			{
				sb.WriteLine(";");
			}
		}
		#endregion
		#region ConstructorDecl *
		public override void ParseElement(ConstructorDecl gr)
		{
			Parse(gr.Comments);
			Parse(gr.CustomAttributes);

			ParseElement(gr.Attributes);
			sb.Write(gr.Name);
			Parse(gr.Parameters); 
			if(gr.InvokeBase)
			{
				sb.Write(": base(");
				Parse(gr.BaseParameters); 
				sb.Write(")");
			}
			else if(gr.InvokeChain)
			{
				sb.Write(": this(");
				Parse(gr.ChainParameters); 
				sb.Write(")");
			}
			OpenBlock();
			Parse(gr.Statements);
			CloseBlock();
		}
		#endregion
		#region DestructorDecl
		public override void ParseElement(DestructorDecl gr)
		{
			Parse(gr.Comments);
			Parse(gr.CustomAttributes);

			ParseElement(gr.Attributes);
			sb.Write(" ~ " + gr.Name + "( )");
			OpenBlock();
			Parse(gr.Statements);
			CloseBlock();
		}
		#endregion
		#region AccessorDecl *
		public override void ParseElement(AccessorDecl gr)
		{
			if(gr.AccessorModifier == AccessorModifiers.Empty) return;
			Parse(gr.Comments);
			Parse(gr.CustomAttributes);
            sb.Write(Enum.GetName(	gr.AccessorModifier.GetType(), 
									gr.AccessorModifier).ToLower() );
			OpenBlock();
			Parse(gr.Statements);
			CloseBlock();
		}
		#endregion
		#region EnumMemberDecl *
		public override void ParseElement(EnumMemberDecl gr)
		{
			Parse(gr.CustomAttributes);
			sb.Write(gr.Name);
			if(gr.Value != null)
			{
				sb.Write(" = ");
				Parse(gr.Value);
			}
		}
		#endregion

		#region ClassDecl *
		public override void ParseElement(ClassDecl gr)
		{
			Parse(gr.Comments);
			Parse(gr.CustomAttributes);
			ParseElement(gr.Attributes);
			sb.Write("class " + gr.Name +" ");
			Parse(gr.BaseTypes);
			OpenBlock();
			Parse(gr.Members);
			CloseBlock();
		}
		#endregion
		#region InterfaceDecl *
		public override void ParseElement(InterfaceDecl gr)
		{
			Parse(gr.CustomAttributes);
			ParseElement(gr.Attributes);
			sb.Write("interface " + gr.Name +" ");
			Parse(gr.BaseTypes);
			OpenBlock();

			isInterface = true;
			Parse(gr.Members);
			isInterface = false;

			CloseBlock();
		}
		#endregion
		#region StructDecl *
		public override void ParseElement(StructDecl gr)
		{
			Parse(gr.CustomAttributes);
			ParseElement(gr.Attributes);
			sb.Write("struct " + gr.Name +" ");
			Parse(gr.BaseTypes);
			OpenBlock();
			Parse(gr.Members);
			CloseBlock();
		}
		#endregion
		#region EnumDecl *
		public override void ParseElement(EnumDecl gr)
		{
			Parse(gr.CustomAttributes);
			ParseElement(gr.Attributes);
			sb.Write("enum " + gr.Name +" ");
			Parse(gr.BaseTypes);
			OpenBlock();
			string comma = "";
			foreach(EnumMemberDecl em in gr.Members)
			{
				if(comma != "") sb.WriteLine(comma);
				ParseElement(em);
				comma = ",";
			}
			sb.WriteLine("");
			CloseBlock();
		}
		#endregion
		#region DelegateDecl *
		public override void ParseElement(DelegateDecl gr)
		{
			Parse(gr.CustomAttributes);
			ParseElement(gr.Attributes);
			Parse(gr.ReturnType);
			sb.Write("delegate ");
			sb.Write(gr.Name);
			Parse(gr.Parameters); 
			sb.WriteLine(";");
			//Parse(gr.BaseTypes); //delegate has no base types
			//OpenBlock();
			//Parse(gr.Members); //delegate has no members
			//CloseBlock();

		}
		#endregion

		#region ExprStmt
		public override void ParseElement(ExprStmt gr)
		{
			Parse(gr.Expression);
			if(termStmt) sb.WriteLine(";");
		}
		#endregion
		#region CommentStmt
		public override void ParseElement(CommentStmt gr)
		{
			Parse(gr.Comment);			
			if(termStmt) sb.WriteLine("");
		}
		#endregion
		#region VariableDeclStmt *
		public override void ParseElement(VariableDeclStmt gr)
		{ 
			Parse(gr.Type);
			string comma = "";
			foreach(Declarator dl in gr.Delcarators)
			{
				sb.Write(comma);
				ParseElement(dl);
				comma = ", ";
			}
			if(termStmt) sb.WriteLine(";");
		}
		#endregion
		#region ConstantDeclStmt *
		public override void ParseElement(ConstantDeclStmt gr)
		{
			sb.Write("const ");
			Parse(gr.Type);
			string comma = "";
			foreach(Declarator dl in gr.Delcarators)
			{
				sb.Write(comma);
				ParseElement(dl);
				comma = ", ";
			}
			if(termStmt) sb.WriteLine(";");
		}
		#endregion
		#region IfStmt *
		public override void ParseElement(IfStmt gr)
		{
			// maybe check for one stmt, then don't use brackets...
			sb.Write("if(");
			Parse(gr.Condition);
			sb.Write(")");			
			if(gr.TrueStatements.Count > 0)
			{
				// dont use blocks for single statement
				if(gr.TrueStatements.Count > 1)
				{
					OpenBlock();
					Parse(gr.TrueStatements);
					CloseBlock();
				}
				else
				{
					sb.Indent++;
					sb.WriteLine("");
					Parse(gr.TrueStatements);
					sb.Indent--;
				}
				if(gr.FalseStatements.Count > 0)
				{
					sb.Write("else ");
					Parse(gr.FalseStatements);
				}
			}
			else
			{
				sb.Write(";");
			}
		}
		#endregion
		#region SwitchStmt *
		public override void ParseElement(SwitchStmt gr)
		{
			sb.Write("switch(");