csharpgen.cs

C#编写的c#编译器

			Parse(gr.Condition);
			sb.Write(")");
			OpenBlock();
            Parse(gr.Cases);
			CloseBlock();
		}
		#endregion
		#region Case *
		public override void ParseElement(Case gr)
		{
			if(gr.IsDefault)
			{
				sb.Write("default :");
			}
			else
			{
				sb.Write("case ");
				Parse(gr.Condition);
				sb.Write(" :");
			}
			OpenBlock();
            Parse(gr.Statements);
			CloseBlock();
		}
		#endregion
		#region IterationStmt *
		public override void ParseElement(IterationStmt gr)
		{
			if(gr.TestFirst)
			{
				termStmt = false;
				sb.Write("for(");
				if(gr.Init != null)
				{						
					string comma = "";
					foreach(Statement o in gr.Init)
					{
						sb.Write(comma);
						Parse(o);
						comma = ", ";
					}
				}
				sb.Write("; ");
				Parse(gr.Test);
				sb.Write("; ");
				if(gr.Increment != null)
				{						
					string comma = "";
					foreach(Statement o in gr.Increment)
					{
						sb.Write(comma);
						Parse(o);
						comma = ", ";
					}
				}
				sb.Write(")");
				termStmt = true;
				OpenBlock();
				Parse(gr.Statements);
				CloseBlock();					
			}
			else
			{
				sb.Write("do");
				OpenBlock();
				Parse(gr.Statements);
				CloseBlock();
				sb.Write("while(");
				Parse(gr.Test);
				sb.WriteLine(");");
			}
		}
		#endregion
		#region ForEachStmt
		public override void ParseElement(ForEachStmt gr)
		{
			sb.Write("foreach(");
			Parse(gr.Type);
			sb.Write(" " + gr.Name + " in ");
			Parse(gr.Collection);
			sb.Write(")");
			OpenBlock();
			Parse(gr.Statements);
			CloseBlock();			
		}
		#endregion
		#region GotoStmt
		public override void ParseElement(GotoStmt gr)
		{			
			sb.Write("goto " + gr.Label);
			if(gr.CaseLabel != null)
			{
				sb.Write(" " );
				Parse(gr.CaseLabel);
			}
			sb.WriteLine(";");
		}
		#endregion
		#region LabeledStmt
		public override void ParseElement(LabeledStmt gr)
		{
			int ind = sb.Indent;
			int tabSize = 4; // how to get this..?
			sb.Indent = 0;
			string lbl = gr.Label + ":";
			sb.Write(lbl.PadRight(ind * tabSize, ' ') );
			Parse(gr.Statement);
			sb.Indent = ind;
		}
		#endregion
		#region ReturnStmt
		public override void ParseElement(ReturnStmt gr)
		{
			sb.Write("return");
			if(gr.Expression != null)
			{
				sb.Write(" ");
				Parse(gr.Expression);
			}
			sb.WriteLine(";");
		}
		#endregion
		#region BreakStmt
		public override void ParseElement(BreakStmt gr)
		{
			sb.WriteLine("break;");
		}
		#endregion
		#region ContinueStmt
		public override void ParseElement(ContinueStmt gr)
		{
			sb.WriteLine("continue;");
		}
		#endregion
		#region CheckedStmt
		public override void ParseElement(CheckedStmt gr)
		{
			sb.Write("checked");
			OpenBlock();
			Parse(gr.Statements);
			CloseBlock();
		}
		#endregion
		#region UncheckedStmt
		public override void ParseElement(UncheckedStmt gr)
		{
			sb.Write("unchecked");
			OpenBlock();
			Parse(gr.Statements);
			CloseBlock();
		}
		#endregion
		#region LockStmt
		public override void ParseElement(LockStmt gr)
		{
			sb.Write("lock(");
			Parse(gr.Target);
			sb.Write(")");
			OpenBlock();
			Parse(gr.Statements);
			CloseBlock();
		}
		#endregion
		#region UsingStmt
		public override void ParseElement(UsingStmt gr)
		{
			sb.Write("using(");
			if(gr.DeclaresResource)
			{
				termStmt = false;
				Parse(gr.Declaration);
				termStmt = true;
			}
			else
			{
				Parse(gr.Target);
			}
			sb.Write(")");
			OpenBlock();
			Parse(gr.Statements);
			CloseBlock();
		}
		#endregion
		#region ThrowStmt
		public override void ParseElement(ThrowStmt gr)
		{
			sb.Write("throw(");
			Parse(gr.ToThrow);
			sb.WriteLine(");");
		}
		#endregion
		#region TryCatchFinallyStmt
		public override void ParseElement(TryCatchFinallyStmt gr)
		{
			sb.Write("try");
			OpenBlock();
			Parse(gr.Try);
			CloseBlock();
			Parse(gr.CatchClauses);
			Parse(gr.Finally);
		}
		#endregion
		#region Catch
		public override void ParseElement(Catch gr)
		{
			sb.Write("catch(");
			Parse(gr.CatchExceptionType);
			sb.Write(gr.LocalName);
			sb.Write(")");
			OpenBlock();
			Parse(gr.Statements);
			CloseBlock();
		}
		#endregion
		#region AttachDelegateStmt TODO: not parsing yet
		public override void ParseElement(AttachDelegateStmt gr)
		{
			//gr.Event;
			//gr.Listener;
		}
		#endregion
		#region RemoveDelegateStmt TODO: not parsing yet
		public override void ParseElement(RemoveDelegateStmt gr)
		{
		}
		#endregion

		#region AssignExpr
		public override void ParseElement(AssignExpr gr)
		{
			Parse(gr.Left);
			sb.Write(" " + AssignExpr.StringFromOperator(gr.Operator) + " ");
			Parse(gr.Right);
		}
		#endregion
		#region UnaryExpr
		public override void ParseElement(UnaryExpr gr)
		{
			sb.Write(UnaryExpr.StringFromOperator(gr.Operator));
			Parse(gr.Right);
		}
		#endregion
		#region BinaryExpr
		public override void ParseElement(BinaryExpr gr)
		{
			Parse(gr.Left);
			sb.Write(" " + BinaryExpr.StringFromOperator(gr.Operator) + " ");
			Parse(gr.Right);
		}
		#endregion
		#region Ternary
		public override void ParseElement(TernaryExpr gr)
		{
			Parse(gr.Test);
			sb.Write(" ? ");
			Parse(gr.True);
			sb.Write(" : ");
			Parse(gr.False);
		}
		#endregion
		#region CastExpr
		public override void ParseElement(CastExpr gr)
		{
			sb.Write("(");
			addSpace = false;
			Parse(gr.TargetType);
			addSpace = true;
			sb.Write(")");
			Parse(gr.Expression);
		}
		#endregion
		#region SubExpr
		public override void ParseElement(SubExpr gr)
		{
			sb.Write("(");
			addSpace = false;
			Parse(gr.Expression);
			addSpace = true;
			sb.Write(")");
		}
		#endregion
		#region UnknownReference
		public override void ParseElement(UnknownReference gr)
		{
			sb.Write(gr.VariableName);
		}
		#endregion
		#region ThisRef
		public override void ParseElement(ThisRef gr)
		{
			sb.Write("this");
		}
		#endregion
		#region BaseRef
		public override void ParseElement(BaseRef gr)
		{
			sb.Write("base");
		}
		#endregion
		#region PropertySetValueRef
		public override void ParseElement(PropertySetValueRef gr)
		{
			sb.Write("value");
		}
		#endregion
		#region ArgumentRef
		public override void ParseElement(ArgumentRef gr)
		{
			sb.Write(gr.ParameterName);
		}
		#endregion
		#region LocalRef
		public override void ParseElement(LocalRef gr)
		{
			sb.Write(gr.VariableName);
		}
		#endregion
		#region TypeOfExpr
		public override void ParseElement(TypeOfExpr gr)
		{
			sb.Write("typeof(");
			Parse(gr.Type);
			sb.Write(")");
		}
		#endregion
		#region FieldRef
		public override void ParseElement(FieldRef gr)
		{
			if(gr.Target != null)
			{
				Parse(gr.Target);
				sb.Write(".");
			}
			sb.Write(gr.FieldName);
		}
		#endregion
		#region ArrayElementRef
		public override void ParseElement(ArrayElementRef gr)
		{
			if(gr.Target != null)
			{
				Parse(gr.Target);
			}
			sb.Write("[");
			if(gr.Indices != null)
			{
				string comma = "";
				foreach(Expression o in gr.Indices)
				{
					sb.Write(comma);
					Parse(o);
					comma = ", ";
				}
			}
			sb.Write("]");

		}
		#endregion
		#region MethodRef
		public override void ParseElement(MethodRef gr)
		{
			if(gr.Target != null)
			{
				Parse(gr.Target);
			}
			else if(gr.MethodName != "")
				sb.Write(gr.MethodName);
		}
		#endregion
		#region PropertyRef
		public override void ParseElement(PropertyRef gr)
		{
			if(gr.Target != null)
			{
				Parse(gr.Target);
				sb.Write(".");
			}
			sb.Write(gr.PropertyName);
		}
		#endregion
		#region EventRef
		public override void ParseElement(EventRef gr)
		{
			if(gr.Target != null)
			{
				Parse(gr.Target);
				sb.Write(".");
			}
			sb.Write(gr.EventName);
		}
		#endregion
		#region MethodInvokeExpr
		public override void ParseElement(MethodInvokeExpr gr)
		{
			Parse(gr.Target);
			sb.Write("(");
			if(gr.Parameters != null)
			{
				string comma = "";
				foreach(Param o in gr.Parameters)
				{
					sb.Write(comma);
					Parse(o);
					comma = ", ";
				}
			}
			sb.Write(")");
		}
		#endregion
		#region PostfixExpr
		public override void ParseElement(PostfixExpr gr)
		{
			Parse(gr.Left);
			if(gr.Operator == PostfixOperator.Increment)
				sb.Write("++");
			else if(gr.Operator == PostfixOperator.Decrement)
				sb.Write("--");
		}
		#endregion
		#region DelegateInvokeExpr
		public override void ParseElement(DelegateInvokeExpr gr)
		{
			Parse(gr.Target);
			sb.Write("(");
			if(gr.Parameters != null)
			{
				string comma = "";
				foreach(Param o in gr.Parameters)
				{
					sb.Write(comma);
					Parse(o);
					comma = ", ";
				}
			}
			sb.Write(")");
		}
		#endregion
		#region IndexerRef
		public override void ParseElement(IndexerRef gr)
		{
			Parse(gr.Target);
			sb.Write("[");
			if(gr.Indices != null)
			{
				string comma = "";
				foreach(Expression o in gr.Indices)
				{
					sb.Write(comma);
					Parse(o);
					comma = ", ";
				}
			}
			sb.Write("]");
		}
		#endregion
		#region MemberAccess
		public override void ParseElement(MemberAccess gr)
		{
			addSpace = false;
			Parse(gr.Target);
			addSpace = true;
			sb.Write("." + gr.MemberName);
		}
		#endregion
		#region ArrayCreateExpr
		public override void ParseElement(ArrayCreateExpr gr)
		{
			string comma = "";
			sb.Write("new ");
			sb.Write(gr.CreateType.TypeName);
			sb.Write("[");
			for(int i = 0; i < gr.DimensionCount; i++)
			{
				if(gr.Sizes != null && gr.Sizes.Count > i && gr.Sizes[i] != null)
				{	
					sb.Write(comma);
					Parse(gr.Sizes[i]);
					comma = ", ";
				}
				else
				{
					sb.Write(comma);
					comma = ",";
				}