C# SyntaxTree.statement_list类代码示例

        public override void visit(statement_list stmtList)
        {
            var stl = new statements_list(_visitor.get_location(stmtList),
                                          _visitor.get_location_with_check(stmtList.left_logical_bracket),
                                          _visitor.get_location_with_check(stmtList.right_logical_bracket));
            _visitor.convertion_data_and_alghoritms.statement_list_stack_push(stl);

            var newTreeNode = new CapturedVariablesTreeNodeBlockScope(_currentTreeNode, stl.Scope.ScopeNum, stmtList);

            if (_rootNode == null)
            {
                _rootNode = newTreeNode;
            }
            if (_currentTreeNode != null)
            {
                _currentTreeNode.ChildNodes.Add(newTreeNode);
            }
            _currentTreeNode = newTreeNode;

            _scopesCapturedVarsNodesDictionary.Add(stl.Scope.ScopeNum, _currentTreeNode);

            if (stmtList.subnodes != null)
            {
                foreach (var stmt in stmtList.subnodes)
                {
                    ProcessNode(stmt);
                }
            }

            _visitor.convertion_data_and_alghoritms.statement_list_stack.pop();

            _currentTreeNode = _currentTreeNode.ParentNode;
        }

 public static statement_list BuildSimpleAssignList(List<ident> lnames, List<ident> rnames)
 {
     var sl = new statement_list();
     for (int i = 0; i < lnames.Count; i++)
         sl.Add( new assign(lnames[i], rnames[i]));
     return sl;
 }

 public override void visit(statement_list stmtList)
 {
     var stl = new statements_list(syntaxTreeVisitor.get_location(stmtList),
                                   syntaxTreeVisitor.get_location_with_check(stmtList.left_logical_bracket),
                                   syntaxTreeVisitor.get_location_with_check(stmtList.right_logical_bracket));
     syntaxTreeVisitor.convertion_data_and_alghoritms.statement_list_stack_push(stl);
     if (stmtList.subnodes != null)
         foreach (var stmt in stmtList.subnodes)
             ProcessNode(stmt);
     syntaxTreeVisitor.convertion_data_and_alghoritms.statement_list_stack.pop();    
 }

 public override void visit(statement_list _statement_list)
 {
     if (_statement_list == null || _statement_list.source_context == null) return;
     IBaseScope tmp = cur_scope;
     cur_scope = entry_scope.FindScopeByLocation(_statement_list.source_context.begin_position.line_num, _statement_list.source_context.begin_position.column_num);
     if (cur_scope == null)
         cur_scope = tmp;
     foreach (statement stmt in _statement_list.subnodes)
         stmt.visit(this);
     cur_scope = tmp;
 }

 public virtual statement_list GetStatements(object _object)
 {
     statement_list _statement_list;
     if (_object is statement_list)
         _statement_list = _object as statement_list;
     else
     {
         _statement_list = new statement_list();
         if (_object is statement)
             _statement_list.subnodes.Add(_object as statement);
         else
             _statement_list.subnodes.Add(new empty_statement());
     }
     return _statement_list;
 }

        public override void visit(statement_list stlist)
        {
            ++CurrentLevel;

            if (BlockNamesStack.Count <= CurrentLevel)
            {
                // Создаем отображение для имен текущего уровня вложенности мини-пространства имен
                BlockNamesStack.Add(new Dictionary<string, string>());
            }

            //base.visit(stlist);
            for (var i = 0; i < stlist.list.Count; ++i)
                ProcessNode(stlist.list[i]);

            BlockNamesStack.RemoveAt(BlockNamesStack.Count - 1);

            --CurrentLevel;
        }

		public void write_statement_list(statement_list _statement_list)
		{
			write_statement(_statement_list);
			if (_statement_list.subnodes == null)
			{
				bw.Write((byte)0);
			}
			else
			{
				bw.Write((byte)1);
				bw.Write(_statement_list.subnodes.Count);
				for(Int32 ssyy_i = 0; ssyy_i < _statement_list.subnodes.Count; ssyy_i++)
				{
					if (_statement_list.subnodes[ssyy_i] == null)
					{
						bw.Write((byte)0);
					}
					else
					{
						bw.Write((byte)1);
						_statement_list.subnodes[ssyy_i].visit(this);
					}
				}
			}
			if (_statement_list.left_logical_bracket == null)
			{
				bw.Write((byte)0);
			}
			else
			{
				bw.Write((byte)1);
				_statement_list.left_logical_bracket.visit(this);
			}
			if (_statement_list.right_logical_bracket == null)
			{
				bw.Write((byte)0);
			}
			else
			{
				bw.Write((byte)1);
				_statement_list.right_logical_bracket.visit(this);
			}
		}

        /*
         * // Scope Level 0
         * begin 
         *   var x = value; // Name in Scope Level 0
         *   // Scope Level 1
         *   begin
         *     var x = value; // Name in Scope Level 1 <-- REDEFENITION ERROR, x defined at Level 0
         *     
         *     var y = value;
         *     var y = value2; // Name in Scope Level 1 <-- REDEFINITION ERROR, y defined at Level 1
         *     
         *     // Scope Level 2
         *     begin
         *       var z = y; // Name in Scope Level 2
         *     end
         *     // Scope Level 2
         *     begin
         *       var z = value; // Name in Scope Level 2
         *     end
         *   end
         * 
         * end
        */

        public override void visit(statement_list stlist)
        {
            ++CurrentLevel;

            if (BlockNamesStack.Count <= CurrentLevel)
            {
                // Создаем множество имен для текущего уровня вложенности мини-пространства имен
                BlockNamesStack.Add(new HashSet<string>());
            }


            base.visit(stlist);
            //for (var i = 0; i < stlist.list.Count; ++i)
            //    ProcessNode(stlist.list[i]);

            BlockNamesStack.RemoveAt(BlockNamesStack.Count - 1);

            --CurrentLevel;
        }

        public override void visit(while_node wn)
        {
            ProcessNode(wn.statements);
            var gt1 = new goto_statement(newLabelName());
            var gt2 = new goto_statement(newLabelName());
            var gt3 = new goto_statement(newLabelName());

            var if0 = new if_node(wn.expr, gt1, null);
            var lb3 = new labeled_statement(gt3.label, if0);
            var lb1 = new labeled_statement(gt1.label, wn.statements);
            var lb2 = new labeled_statement(gt2.label, new empty_statement());

            var stl = new statement_list(lb3, gt2, lb1, gt3, lb2);

            Replace(wn, stl);
            // в declarations ближайшего блока добавить описание labels
            block bl = listNodes.FindLast(x => x is block) as block;

            var ld = new label_definitions(gt1.label, gt2.label, gt3.label);
            bl.defs.Add(ld);
        }

        public override void Exit(syntax_tree_node st)
        {
            var sts = st as statement;

            if (sts != null && !(sts is statement_list) && !(sts is case_variant) && !(UpperNode() is statement_list))
            {
                // Одиночный оператор
                var stl = new statement_list(sts, st.source_context);
                Replace(sts, stl);
            }

            
            var lst = st as labeled_statement;

            if (lst != null && !(lst.to_statement is statement_list) && !(lst.to_statement is case_variant))
            {
                // Одиночный оператор
                var stl = new statement_list(sts, st.source_context);
                Replace(lst.to_statement, stl);
            }
            
            base.Exit(st);
        }

		///<summary>
		///Конструктор с параметрами.
		///</summary>
		public program_body(uses_list _used_units,declarations _program_definitions,statement_list _program_code,using_list _using_list)
		{
			this._used_units=_used_units;
			this._program_definitions=_program_definitions;
			this._program_code=_program_code;
			this._using_list=_using_list;
		}

        /*public override void Enter(syntax_tree_node st)
        {
            base.Enter(st);
            countNodesVisited++;

            // сокращение обходимых узлов. Как сделать фильтр по тем узлам, которые необходимо обходить? Например, все операторы (без выражений и описаний), все описания (без операторов)
            if (st.GetType()==typeof(assign) || st.GetType()==typeof(var_def_statement) || st is procedure_call || st is procedure_header || st is expression)
            {
                visitNode = false; // фильтр - куда не заходить 
            }
        }*/

        /*public override void visit(class_members cm)
        {
            foreach (var decl in cm.members)
            {
                if (decl is procedure_header || decl is procedure_definition)
                    decl.visit(this);
            }
            base.visit(cm);
        }*/

        type_declarations GenClassesForYield(procedure_definition pd,
            IEnumerable<var_def_statement> fields, // локальные переменные
            IDictionary<string, string> localsMap, // отображение для захваченных имен локальных переменных
            IDictionary<string, string> formalParamsMap//, // отображение для захваченных имен формальных параметров
            //IDictionary<var_def_statement, var_def_statement> localsCloneMap // отображение для оберток локальных переменных 
            ) 
        {
            var fh = (pd.proc_header as function_header);
            if (fh == null)
                throw new SyntaxError("Only functions can contain yields", "", pd.proc_header.source_context, pd.proc_header);
            var seqt = fh.return_type as sequence_type;
            if (seqt == null)
                throw new SyntaxError("Functions with yields must return sequences", "", fh.return_type.source_context, fh.return_type);

            // Теперь на месте функции генерируем класс

            // Захваченные локальные переменные
            var cm = class_members.Public;
            var capturedFields = fields.Select(vds =>
                                    {
                                        ident_list ids = new ident_list(vds.vars.idents.Select(id => new ident(localsMap[id.name])).ToArray());
                                        if (vds.vars_type == null) //&& vds.inital_value != null)
                                        {
                                            if (vds.inital_value != null)
                                            {
                                                //return new var_def_statement(ids, new yield_unknown_expression_type(localsCloneMap[vds], varsTypeDetectorHelper), null);
                                                return new var_def_statement(ids, new yield_unknown_expression_type(vds), null); // SSM - убрал localsCloneMap[vds] - заменил на vds - не знаю, зачем вообще это отображение делалось - всё равно оно было тождественным!!!
                                            }
                                            else
                                            {
                                                throw new SyntaxVisitorError("Variable defenition without type and value!",vds.source_context); // SSM - быть такого не может - грамматика не пропустит
                                            }
                                        }
                                        else
                                        {
                                            return new var_def_statement(ids, vds.vars_type, null);
                                        }
                                        
                                        //return new var_def_statement(ids, vds.vars_type, vds.inital_value);
                                    });

            foreach (var m in capturedFields)
                cm.Add(m);

            // Параметры функции
            List<ident> lid = new List<ident>();
            var pars = fh.parameters;
            if (pars != null)
                foreach (var ps in pars.params_list)
                {
                    if (ps.param_kind != parametr_kind.none)
                        throw new SyntaxVisitorError("FUNCTIONS_WITH_YIELDS_CANNOT_CONTAIN_VAR_CONST_PARAMS_MODIFIERS", pars.source_context);
                    if (ps.inital_value != null)
                        throw new SyntaxVisitorError("FUNCTIONS_WITH_YIELDS_CANNOT_CONTAIN_DEFAULT_PARAMETERS", pars.source_context);
                    //var_def_statement vds = new var_def_statement(ps.idents, ps.vars_type);
                    ident_list ids = new ident_list(ps.idents.list.Select(id => new ident(formalParamsMap[id.name])).ToArray());
                    var_def_statement vds = new var_def_statement(ids, ps.vars_type);
                    cm.Add(vds); // все параметры функции делаем полями класса
                    //lid.AddRange(vds.vars.idents);
                    lid.AddRange(ps.idents.list);
                }

            var stels = seqt.elements_type;

            var iteratorClassName = GetClassName(pd);

            // frninja 08/18/15 - Для захвата self
            if (iteratorClassName != null)
            {
                // frninja 20/04/16 - поддержка шаблонных классов
                var iteratorClassRef = CreateClassReference(iteratorClassName);

                cm.Add(new var_def_statement(YieldConsts.Self, iteratorClassRef));
            }

            var GetEnumeratorBody = new statement_list();

            // Системные поля и методы для реализации интерфейса IEnumerable
//.........这里部分代码省略.........

        public static procedure_definition BuildShortProcFuncDefinitionNoSC(procedure_header header, statement st)
        {
            var stlist = new statement_list(st, st.source_context);
            var b = new block(null, stlist, st.source_context);

            return new procedure_definition(header, b, true, BuildGenSC);
        }

		///<summary>
		///Конструктор с параметрами.
		///</summary>
		public try_stmt(statement_list _stmt_list,try_handler _handler)
		{
			this._stmt_list=_stmt_list;
			this._handler=_handler;
		}

		///<summary>
		///Конструктор с параметрами.
		///</summary>
		public pair_type_stlist(type_definition _tn,statement_list _exprs)
		{
			this._tn=_tn;
			this._exprs=_exprs;
		}