csharpast.cs

C#编写的c#编译器

			this.CloseScope();
			return graph;
		}
	}
	#endregion 
		#region	UncheckedStmt *
	public class				UncheckedStmt : Statement
	{
		public override Dom.IGraph			GetGraph()				
		{	
			Dom.UncheckedStmt graph = 
				new Dom.UncheckedStmt();
			return this.GetGraph(graph);
		}	
		public Dom.UncheckedStmt	
			GetGraph(Dom.UncheckedStmt graph)
		{		
			//graph.Clear();
			this.OpenBlockScope();
			base.GetGraph(graph);

			AST tok = this.getFirstChild();
			while(tok != null)
			{
				if(tok is Statements)
				{
					((Statements)tok).GetGraph(graph.Statements);
				}
				tok = tok.getNextSibling();
			}
			this.CloseScope();
			return graph;
		}
	}
	#endregion 
		#region	LockStmt *
	public class				LockStmt : Statement
	{
		public override Dom.IGraph			GetGraph()				
		{	
			Dom.LockStmt graph = 
				new Dom.LockStmt();
			return this.GetGraph(graph);
		}	
		public Dom.LockStmt	
			GetGraph(Dom.LockStmt graph)
		{		
			//graph.Clear();
			this.OpenBlockScope();
			base.GetGraph(graph);

			AST tok = this.getFirstChild();
			while(tok != null)
			{
				if(tok is Statements)
				{
					((Statements)tok).GetGraph(graph.Statements);
				}
				else if(tok is Expression)
				{
					graph.Target = Expression.Parse(((Expression)tok));
				}
				tok = tok.getNextSibling();
			}
			this.CloseScope();
			AddRootExpression(graph.Target, graph.GetType(), "Target");
			return graph;
		}
	}
	#endregion 
		#region	UsingStmt *
	public class				UsingStmt : Statement
	{
		public override Dom.IGraph			GetGraph()				
		{	
			Dom.UsingStmt graph = 
				new Dom.UsingStmt();
			return this.GetGraph(graph);
		}	
		public Dom.UsingStmt
			GetGraph(Dom.UsingStmt graph)
		{		
			//graph.Clear();
			this.OpenBlockScope();
			base.GetGraph(graph);

			AST tok = this.getFirstChild();
			while(tok != null)
			{
				if(tok is Statements)
				{
					((Statements)tok).GetGraph(graph.Statements);
				}
				else if(tok is Expression)
				{
					AST ctok = tok.getFirstChild();
					while(ctok != null)
					{
						if(ctok is Expression)
						{
							graph.Target = Expression.Parse(((Expression)ctok));
						}
						else if(ctok is VariableDeclStmt)
						{
							graph.Declaration = 
								(Dom.VariableDeclStmt)((VariableDeclStmt)ctok).GetGraph();
						}
						ctok = ctok.getNextSibling();
					}
					
				}
				tok = tok.getNextSibling();
			}
			this.CloseScope();
			AddRootExpression(graph.Target, graph.GetType(), "Target");
			return graph;
		}
	}
	#endregion 
		#region	ThrowStmt 
	public class				ThrowStmt : Statement
	{
		public override Dom.IGraph			GetGraph()				
		{	
			Dom.ThrowStmt graph = 
				new Dom.ThrowStmt();
			return this.GetGraph(graph);
		}	
		public Dom.ThrowStmt	
			GetGraph(Dom.ThrowStmt graph)
		{		
			//graph.Clear();
			base.GetGraph(graph);

			AST tok = this.getFirstChild();
			while(tok != null)
			{
				if(tok is Expression)
				{
					graph.ToThrow = Expression.Parse(((Expression)tok));
				}
				tok = tok.getNextSibling();
			}
			AddRootExpression(graph.ToThrow, graph.GetType(), "ToThrow");
			return graph;
		}


	}
	#endregion 
		#region	TryCatchFinallyStmt 
	public class				TryCatchFinallyStmt : Statement
	{
		public override Dom.IGraph			GetGraph()				
		{	
			Dom.TryCatchFinallyStmt graph = 
				new Dom.TryCatchFinallyStmt();
			return this.GetGraph(graph);
		}	
		public Dom.TryCatchFinallyStmt	
			GetGraph(Dom.TryCatchFinallyStmt graph)
		{		
			//graph.Clear();
			base.GetGraph(graph);

			AST tok = this.getFirstChild();
			while(tok != null)
			{
				if(tok is CatchClause)
				{
					this.OpenBlockScope();
					graph.CatchClauses.Add( 
						(Dom.Catch)((CatchClause)tok).GetGraph() );
					this.CloseScope();
				}
				else if(tok is TryStmt)
				{
					this.OpenBlockScope();
					Statements stmtsTok = (Statements)tok.getFirstChild();
					stmtsTok.GetGraph(graph.Try);
					this.CloseScope();
				}
				else if(tok is FinallyStmt)
				{
					this.OpenBlockScope();
					Statements stmtsTok = (Statements)tok.getFirstChild();
					stmtsTok.GetGraph(graph.Finally);
					this.CloseScope();
				}

				tok = tok.getNextSibling();
			}
			return graph;
		}

	}
	#endregion 
			#region	TryStmt *
	public class				TryStmt : CSharpAST
	{
		public override Dom.IGraph	GetGraph()
		{
			throw new MethodAccessException("Code should never call GetGraph() on TryStmt");
		}
		// Holder class
	}
	#endregion 
			#region	CatchClause *
	public class				CatchClause : Statement
	{
		public override Dom.IGraph			GetGraph()				
		{	
			Dom.Catch graph = 
				new Dom.Catch();
			return this.GetGraph(graph);
		}	
		public Dom.Catch	
			GetGraph(Dom.Catch graph)
		{		
			//graph.Clear();
			base.GetGraph(graph);

			AST tok = this.getFirstChild();
			while(tok != null)
			{				
				if(tok is Ident)
					graph.LocalName = tok.getText();
				else if(tok is TypeRef)
				{
					graph.CatchExceptionType = (Dom.TypeRef)((TypeRef)tok).GetGraph();
				}
				else if(tok is Statements)
				{
					((Statements)tok).GetGraph(graph.Statements);
				}

				tok = tok.getNextSibling();
			}
			return graph;
		}
	}
	#endregion 
			#region	FinallyStmt *
	public class				FinallyStmt : CSharpAST
	{
		public override Dom.IGraph	GetGraph()
		{
			throw new MethodAccessException("Code should never call GetGraph() on FinallyStmt");
		}
		// Holder class
	}
	#endregion 
		#region CommentNode *
	public class						CommentNode : Statement
	{
		public override Dom.IGraph			GetGraph()				
		{	
			Dom.CommentStmt graph = 
				new Dom.CommentStmt();
			return this.GetGraph(graph);
		}	
		public Dom.CommentStmt	
			GetGraph(Dom.CommentStmt graph)
		{		
			//graph.Clear();
			//base.GetGraph(graph);

			AST tok = this.getFirstChild();
			while(tok != null)
			{
				if(tok is StringLiteral)
				{
					graph.Comment.CommentText = tok.getText();
				}	

				tok = tok.getNextSibling();
			}
			return graph;
		}

		public Dom.CommentStmtCollection	
			GetGraph(Dom.CommentStmtCollection graph)
		{		
			//graph.Clear();
			//base.GetGraph(graph);

			AST tok = this.getFirstChild();
			while(tok != null)
			{
				if(tok is CommentNode)
				{
					Dom.CommentStmt cs = new Dom.CommentStmt();
					graph.Add( this.GetGraph(cs) );
				}	
				tok = tok.getNextSibling();
			}
			return graph;
		}

	}
	#endregion 
	
	#region	Expressions 
	public class				Expressions : CSharpAST
	{
		public override Dom.IGraph	GetGraph()
		{
			throw new MethodAccessException("Code should never call GetGraph() on Expressions");
		}
	}
	#endregion 
	#region	Expression 
	public class				Expression : CSharpAST
	{
		public override Dom.IGraph	GetGraph()
		{
			throw new MethodAccessException("Code should never call GetGraph() on Expression");
		}
		// maybe get rid of this too...
		public virtual Dom.IGraph	GetGraph(Dom.IGraph graph)
		{
			base.GetGraph(graph);
			return null;
		}
		// from here on use a static method to avoid automatic creation 
		// of generic expression in Dom classes, and then discarding it 
		// for a more specific type.
		// Probably a better way to avoid this...
		public static Dom.Expression Parse(Expression tok)
		{		
			if(tok == null) return null;
			Dom.Expression de = null;

			if(tok is AssignExpr)
				de = (Dom.Expression)((AssignExpr)tok).GetGraph();
			else if(tok is UnaryExpr)
				de = (Dom.UnaryExpr)((UnaryExpr)tok).GetGraph();
			else if(tok is BinaryExpr)
				de = (Dom.BinaryExpr)((BinaryExpr)tok).GetGraph();
			else if(tok is TernaryExpr)
				de = (Dom.TernaryExpr)((TernaryExpr)tok).GetGraph();
			else if(tok is CastExpr)
				de = (Dom.CastExpr)((CastExpr)tok).GetGraph();
			else if(tok is SubExpr)
				de = (Dom.SubExpr)((SubExpr)tok).GetGraph();
				// TODO: ternary expressions
			else if(tok is PrimaryExpression)
				de = PrimaryExpression.ParsePrimaryExpr(tok);

			// if this is 'just' and expression indicator, the meat is below.
			else if(!(tok is PrimaryFollowExpression))
			{
				AST ctok = tok.getFirstChild();
				try
				{
					Expression etok = (Expression)ctok;
					return Expression.Parse(etok);
				}
				catch(Exception e)
				{
					Console.WriteLine("Missed Expression type: " + ctok.Type + " - " + e);
				}

			}
			AST ntok = tok.getNextSibling();
			if(ntok != null && ntok is PrimaryFollowExpression)
			{
				de = PrimaryFollowExpression.ParseFollow(
					(PrimaryFollowExpression)ntok, de);
			}
			return de;
		}

	}
	#endregion 
		#region	AssignExpr *
	public class				AssignExpr : Expression
	{
		// Left Expression, Right Expression
		public override Dom.IGraph			GetGraph()				
		{	
			Dom.AssignExpr graph = 
				new Dom.AssignExpr();
			return this.GetGraph(graph);
		}	
		public Dom.AssignExpr	
			GetGraph(Dom.AssignExpr graph)
		{		
			//graph.Clear();
			base.GetGraph(graph);
			graph.Operator = 
				Dom.AssignExpr.OperatorFromString(this.getText());

			AST tok = this.getFirstChild();
			while(tok != null)
			{
				if(tok is Expression)
				{
					string side = tok.getText(); // left or right
					if(side == "left")
					{
						AST ltok = tok.getFirstChild();
						if(ltok is Expression)
							graph.Left = Expression.Parse(((Expression)ltok));
					}
					else if (side == "right")
					{
						AST rtok = tok.getFirstChild();
						if(rtok is Expression)
							graph.Right = Expression.Parse(((Expression)rtok));
					}
				}
				tok = tok.getNextSibling();
			}
			return graph;
		}
			 
					 			
	}				 
	#endregion		 
		#region	UnaryExpr *
	public class				UnaryExpr : Expression
	{
		// Left Expression, Right Expression
		public override Dom.IGraph			GetGraph()				
		{	
			Dom.UnaryExpr graph = 
				new Dom.UnaryExpr();
			return this.GetGraph(graph);
		}	
		public Dom.UnaryExpr	
			GetGraph(Dom.UnaryExpr graph)
		{		
			//graph.Clear();
			base.GetGraph(graph);
			graph.Operator = 
				Dom.UnaryExpr.OperatorFromString(this.getText());

			AST tok = this.getNextSibling();
			if(tok is Expression)
			{
				graph.Right = Expression.Parse(((Expression)tok));
			}

			return graph;
		}	
	}
	#endregion 
		#region	BinaryExpr *
	public class				BinaryExpr : Expression
	{
		// Left Expression, Right Expression
		public override Dom.IGraph			GetGraph()				
		{	
			Dom.BinaryExpr graph = 
				new Dom.BinaryExpr();
			return this.GetGraph(graph);
		}	
		public Dom.BinaryExpr	
			GetGraph(Dom.BinaryExpr graph)
		{		
			//graph.Clear();
			base.GetGraph(graph);
			graph.Operator = 
				Dom.BinaryExpr.OperatorFromString(this.getText());

			AST tok = this.getFirstChild();
			while(tok != null)
			{
				if(tok is Expression)
				{
					string side = tok.getText(); // left or right
					if(side == "left")
					{
						AST ltok = tok.getFirstChild();
						if(ltok is Expression)
							graph.Left = Expression.Parse(((Expression)ltok));
					}
					else if (side == "right")
					{
						AST rtok = tok.getFirstChild();
						if(rtok is Expression)
							graph.Right = Expression.Parse(((Expression)rtok));
					}
				}

				tok = tok.getNextSibling();
			}
			return graph;
		}
	}
	#endregion 
		#region	TernaryExpr 
	public class				TernaryExpr : Expression
	{
		public override Dom.IGraph			GetGraph()				
		{	
			Dom.TernaryExpr graph = 
				new Dom.TernaryExpr();
			return this.GetGraph(graph);
		}	
		public Dom.TernaryExpr	
			GetGraph(Dom.TernaryExpr graph)
		{		
			base.GetGraph(graph);

			AST tok = this.getFirstChild();
			while(tok != null)
			{
				if(tok is Expression)
				{
					string side = tok.getText(); // left or right
					if(side == "test")
					{
						AST tstok = tok.getFirstChild();
						if(tstok is Expression)
							graph.Test = Expression.Parse(((Expression)tstok));
					}
					else if(side == "true")
					{
						AST ttok = tok.getFirstChi