codedomoutputvisitor.cs

根据cs源码解析为codedom

        // RG
        public override object VisitPropertyDeclaration(PropertyDeclaration propertyDeclaration, object data)
        {
            CodeMemberProperty memberProperty = new CodeMemberProperty();
            memberProperty.Name = propertyDeclaration.Name;
            memberProperty.Attributes = ConvMemberAttributes(propertyDeclaration.Modifier);
            memberProperty.HasGet = propertyDeclaration.HasGetRegion;
            memberProperty.HasSet = propertyDeclaration.HasSetRegion;
            memberProperty.Type = ConvType(propertyDeclaration.TypeReference);

            typeDeclarations.Peek().Members.Add(memberProperty);

            // Add Method Parameters
            foreach (ParameterDeclarationExpression parameter in propertyDeclaration.Parameters)
            {
                memberProperty.Parameters.Add((CodeParameterDeclarationExpression)VisitParameterDeclarationExpression(parameter, data));
            }

            if (memberProperty.HasGet)
            {
                codeStack.Push(memberProperty.GetStatements);
                propertyDeclaration.GetRegion.Block.AcceptChildren(this, data);
                codeStack.Pop();
            }

            if (memberProperty.HasSet)
            {
                codeStack.Push(memberProperty.SetStatements);
                propertyDeclaration.SetRegion.Block.AcceptChildren(this, data);
                codeStack.Pop();
            }

            return null;
        }
		
		public override object VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data)
		{
            InitMethodScope();

			CodeConstructor memberMethod = new CodeConstructor();
            memberMethod.Attributes = ConvMemberAttributes(constructorDeclaration.Modifier);

			typeDeclarations.Peek().Members.Add(memberMethod);

            codeStack.Push(NullStmtCollection);
            foreach (ParameterDeclarationExpression parameter in constructorDeclaration.Parameters)
            {
                memberMethod.Parameters.Add((CodeParameterDeclarationExpression)VisitParameterDeclarationExpression(parameter, data));
            }
            
            if (constructorDeclaration.ConstructorInitializer != null)
            {
                if (constructorDeclaration.ConstructorInitializer.ConstructorInitializerType == ConstructorInitializerType.Base)
                {
                    if (constructorDeclaration.ConstructorInitializer.Arguments.Count == 0)
                    {
                        memberMethod.BaseConstructorArgs.Add(new CodeSnippetExpression());
                    }
                    
                    foreach (Expression o in constructorDeclaration.ConstructorInitializer.Arguments)
                    {
                        memberMethod.BaseConstructorArgs.Add((CodeExpression)o.AcceptVisitor(this, data));
                    }
                }

                if (constructorDeclaration.ConstructorInitializer.ConstructorInitializerType == ConstructorInitializerType.This)
                {
                    if (constructorDeclaration.ConstructorInitializer.Arguments.Count == 0)
                    {
                        memberMethod.ChainedConstructorArgs.Add(new CodeSnippetExpression());
                    }

                    foreach (Expression o in constructorDeclaration.ConstructorInitializer.Arguments)
                    {
                        memberMethod.ChainedConstructorArgs.Add((CodeExpression)o.AcceptVisitor(this, data));
                    }
                }
            }
            codeStack.Pop();

            codeStack.Push(memberMethod.Statements);
            constructorDeclaration.Body.AcceptChildren(this, data);
			codeStack.Pop();
			
			return null;
		}

		public override object VisitBlockStatement(BlockStatement blockStatement, object data)
		{
			blockStatement.AcceptChildren(this, data);
			return null;
		}
		
		public override object VisitExpressionStatement(ExpressionStatement expressionStatement, object data)
		{
			object exp = expressionStatement.Expression.AcceptVisitor(this, data);
			if (exp is CodeExpression) {
				AddStmt(new CodeExpressionStatement((CodeExpression)exp));
			}
			return exp;
		}
		
		public override object VisitLocalVariableDeclaration(LocalVariableDeclaration localVariableDeclaration, object data)
		{
			CodeVariableDeclarationStatement declStmt = null;
			
			for (int i = 0; i < localVariableDeclaration.Variables.Count; ++i) {
				CodeTypeReference type = ConvType(localVariableDeclaration.GetTypeForVariable(i) ?? new TypeReference("object"));
				VariableDeclaration var = (VariableDeclaration)localVariableDeclaration.Variables[i];
				if (!var.Initializer.IsNull) {
					declStmt = new CodeVariableDeclarationStatement(type,
					                                                var.Name,
					                                                (CodeExpression)((INode)var.Initializer).AcceptVisitor(this, data));
				} else {
					declStmt = new CodeVariableDeclarationStatement(type,
					                                                var.Name);
				}
				variables.Add(declStmt);
				AddStmt(declStmt);
			}
			
			return declStmt;
		}
		
		public override object VisitEmptyStatement(EmptyStatement emptyStatement, object data)
		{
			CodeSnippetStatement emptyStmt = new CodeSnippetStatement();
			
			AddStmt(emptyStmt);
			
			return emptyStmt;
		}
		
		public override object VisitReturnStatement(ReturnStatement returnStatement, object data)
		{
			CodeMethodReturnStatement returnStmt;
			if (returnStatement.Expression.IsNull)
				returnStmt = new CodeMethodReturnStatement();
			else
				returnStmt = new CodeMethodReturnStatement((CodeExpression)returnStatement.Expression.AcceptVisitor(this,data));
			
			AddStmt(returnStmt);
			
			return returnStmt;
		}
		
		public override object VisitIfElseStatement(IfElseStatement ifElseStatement, object data)
		{
			CodeConditionStatement ifStmt = new CodeConditionStatement();
			
			ifStmt.Condition = (CodeExpression)ifElseStatement.Condition.AcceptVisitor(this, data);
			
			codeStack.Push(ifStmt.TrueStatements);
			foreach (Statement stmt in ifElseStatement.TrueStatement) {
				if (stmt is BlockStatement) {
					stmt.AcceptChildren(this, data);
				} else {
					stmt.AcceptVisitor(this, data);
				}
			}
			codeStack.Pop();
			
			codeStack.Push(ifStmt.FalseStatements);
			foreach (Statement stmt in ifElseStatement.FalseStatement) {
				if (stmt is BlockStatement) {
					stmt.AcceptChildren(this, data);
				} else {
					stmt.AcceptVisitor(this, data);
				}
			}
			codeStack.Pop();
			
			AddStmt(ifStmt);
			
			return ifStmt;
		}

        int foreachId = 0; // in case of nested foreach statments

        public override object VisitForeachStatement(ForeachStatement foreachStatement, object data)
        {
            // RG:
            //  foreach (T t in x)
            //  {
            //      stmts;
            //  }
            //
            // Emulate with
            //
            //  for (System.Collections.IEnumerator _it = x.GetEnumerator(); _it.MoveNext(); )
            //  {
            //      T t = ((T)_it.Current);
            //
            //      stmts;
            //  }

            foreachId++;
            string name = "_it" + foreachId.ToString();

            CodeIterationStatement _for1 = new CodeIterationStatement();
            breakableStack.Push(new Breakable());

            // init
            CodeVariableDeclarationStatement _decl2 = new CodeVariableDeclarationStatement();
            CodeMethodInvokeExpression _invoke1 = new CodeMethodInvokeExpression();
            CodeMethodReferenceExpression _GetEnumerator_method1 = new CodeMethodReferenceExpression();
            _GetEnumerator_method1.MethodName = "GetEnumerator";
            
            //CodeCastExpression _cast1 = new CodeCastExpression();
            //codeStack.Push(NullStmtCollection);
            //_cast1.Expression = (CodeExpression)foreachStatement.Expression.AcceptVisitor(this, data);
            //codeStack.Pop();
            //CodeTypeReference _IEnumerable_type1 = new CodeTypeReference("System.Collections.IEnumerable");
            //_cast1.TargetType = _IEnumerable_type1;

            //_GetEnumerator_method1.TargetObject = _cast1;

            codeStack.Push(NullStmtCollection);
            _GetEnumerator_method1.TargetObject = (CodeExpression)foreachStatement.Expression.AcceptVisitor(this, data);
            codeStack.Pop();

            _invoke1.Method = _GetEnumerator_method1;
            _decl2.InitExpression = _invoke1;
            _decl2.Name = name;
            CodeTypeReference _IEnumerator_type1 = new CodeTypeReference("System.Collections.IEnumerator");
            _decl2.Type = _IEnumerator_type1;
            _for1.InitStatement = _decl2;

            // Condition
            CodeMethodInvokeExpression _invoke2 = new CodeMethodInvokeExpression();
            CodeMethodReferenceExpression _MoveNext_method1 = new CodeMethodReferenceExpression();
            _MoveNext_method1.MethodName = "MoveNext";
            CodeVariableReferenceExpression _arg2 = new CodeVariableReferenceExpression();
            _arg2.VariableName = name;
            _MoveNext_method1.TargetObject = _arg2;
            _invoke2.Method = _MoveNext_method1;
            _for1.TestExpression = _invoke2;

            // Empty Increment
            _for1.IncrementStatement = new CodeExpressionStatement(new CodeSnippetExpression());

            // T t = ((T)_it.Current);
            CodeVariableDeclarationStatement _decl3 = new CodeVariableDeclarationStatement();
            CodeCastExpression _cast2 = new CodeCastExpression();
            CodePropertyReferenceExpression _prop1 = new CodePropertyReferenceExpression();
            _prop1.PropertyName = "Current";
            CodeVariableReferenceExpression _arg3 = new CodeVariableReferenceExpression();
            _arg3.VariableName = name;
            _prop1.TargetObject = _arg3;
            _cast2.Expression = _prop1;
            CodeTypeReference _System_String_type5 = ConvType(foreachStatement.TypeReference);
            _cast2.TargetType = _System_String_type5;
            _decl3.InitExpression = _cast2;
            _decl3.Name = foreachStatement.VariableName;
            CodeTypeReference _System_String_type6 = ConvType(foreachStatement.TypeReference);
            _decl3.Type = _System_String_type6;
            _for1.Statements.Add(_decl3);
            _for1.Statements.Add(new CodeSnippetStatement());

            codeStack.Push(_for1.Statements);
            foreachStatement.EmbeddedStatement.AcceptVisitor(this, data);
            codeStack.Pop();

            Breakable breakable = breakableStack.Pop();

            if (breakable.IsContinue)
            {
                _for1.Statements.Add(new CodeSnippetStatement());
                _for1.Statements.Add(new CodeLabeledStatement("continue" + breakable.Id, new CodeExpressionStatement(new CodeSnippetExpression())));
            }

            AddStmt(_for1);

            if (breakable.IsBreak)
            {
                AddStmt(new CodeLabeledStatement("break" + breakable.Id, new CodeExpressionStatement(new CodeSnippetExpression())));
            }

            return _for1;
        }

        int doId = 0;

        // RG:
        public override object VisitDoLoopStatement(DoLoopStatement doLoopStatement, object data)
        {
            CodeIterationStatement forLoop = new CodeIterationStatement();
            breakableStack.Push(new Breakable());

            codeStack.Push(NullStmtCollection);

            if (doLoopStatement.ConditionPosition == ConditionPosition.End)
            {
                // do { } while (expr);
                //
                // emulate with:
                //  for (bool _do = true; _do; _do = expr) {}
                //
                doId++;
                string name = "_do" + doId;

                forLoop.InitStatement = new CodeVariableDeclarationStatement(typeof(System.Boolean), name, new CodePrimitiveExpression(true));
                forLoop.TestExpression = new CodeVariableReferenceExpression(name);

                forLoop.IncrementStatement = new CodeAssignStatement(new CodeVariableReferenceExpression(name),
                    doLoopStatement.Condition == null ? new CodePrimitiveExpression(true) : (CodeExpression)doLoopStatement.Condition.AcceptVisitor(this, data));
            }
            else
            {
                // while (expr) {}
                //
                // emulate with:
                //  for (; expr;) {}
                //

                // Empty Init and Increment Statements
                forLoop.InitStatement = new CodeExpressionStatement(new CodeSnippetExpression());
                forLoop.IncrementStatement = new CodeExpressionStatement(new CodeSnippetExpression());

                if (doLoopStatement.Condition == null)
                {
                    forLoop.TestExpression = new CodePrimitiveExpression(true);
                }
                else
                {
                    forLoop.TestExpression = (CodeExpression)doLoopStatement.Condition.AcceptVisitor(this, data);
                }
            }

            codeStack.Pop();

            codeStack.Push(forLoop.Statements);