예제 #1
0
 public object VisitTryCatchStatement(TryCatchStatement tryCatchStatement, object data)
 {
     B.TryStatement t = new B.TryStatement(GetLexicalInfo(tryCatchStatement));
     t.EndSourceLocation = GetLocation(tryCatchStatement.EndLocation);
     t.ProtectedBlock    = ConvertBlock(tryCatchStatement.StatementBlock);
     t.EnsureBlock       = ConvertBlock(tryCatchStatement.FinallyBlock);
     foreach (CatchClause clause in tryCatchStatement.CatchClauses)
     {
         B.ExceptionHandler handler = new B.ExceptionHandler(GetLexicalInfo(clause));
         handler.Block = ConvertBlock(clause.StatementBlock);
         B.TypeReference typeRef = ConvertTypeReference(clause.TypeReference);
         string          name    = clause.VariableName;
         if (typeRef != null)
         {
             if (name == null || name.Length == 0)
             {
                 name = GenerateName();
             }
             handler.Declaration = new B.Declaration(name, typeRef);
         }
         else
         {
             if (name != null && name.Length > 0)
             {
                 handler.Declaration = new B.Declaration(name, null);
             }
         }
         t.ExceptionHandlers.Add(handler);
     }
     return(t);
 }
예제 #2
0
        public override void OnExceptionHandler(ExceptionHandler node)
        {
            bool untypedException = (node.Flags & ExceptionHandlerFlags.Untyped) == ExceptionHandlerFlags.Untyped;
            bool anonymousException = (node.Flags & ExceptionHandlerFlags.Anonymous) == ExceptionHandlerFlags.Anonymous;
            bool filterHandler = (node.Flags & ExceptionHandlerFlags.Filter) == ExceptionHandlerFlags.Filter;

            if (untypedException)
            {
                // If untyped, set the handler to except System.Exception
                node.Declaration.Type = CodeBuilder.CreateTypeReference(TypeSystemServices.ExceptionType);
            }
            else
            {
                Visit(node.Declaration.Type);

                // Require typed exception handlers to except only
                // exceptions at least as derived as System.Exception
                if(!TypeSystemServices.IsValidException(GetType(node.Declaration.Type)))
                {
                    Errors.Add(CompilerErrorFactory.InvalidExceptArgument(node.Declaration.Type, GetType(node.Declaration.Type)));
                }
            }

            if(!anonymousException)
            {
                // If the exception is not anonymous, place it into a
                // local variable and enter a new namespace
                DeclareLocal(node.Declaration, true);
                EnterNamespace(new DeclarationsNamespace(CurrentNamespace, node.Declaration));
            }

            try
            {
                // The filter handler has access to the exception if it
                // is not anonymous, so it is protected to ensure
                // any exception in the filter condition (a big no-no)
                // will still clean up the namespace if necessary
                if (filterHandler)
                {
                    Visit(node.FilterCondition);
                }

                Visit(node.Block);
            }
            finally
            {
                // Clean up the namespace if necessary
                if(!anonymousException)
                {
                    LeaveNamespace();
                }
            }
        }
예제 #3
0
	protected void exception_handler(
		TryStatement t
	) //throws RecognitionException, TokenStreamException
{
		
		IToken  c = null;
		IToken  x = null;
		IToken  u = null;
		
				ExceptionHandler eh = null;		
				TypeReference tr = null;
				Expression e = null;
			
		
		try {      // for error handling
			c = LT(1);
			match(EXCEPT);
			{
				switch ( LA(1) )
				{
				case ID:
				{
					x = LT(1);
					match(ID);
					break;
				}
				case AS:
				case IF:
				case UNLESS:
				case COLON:
				{
					break;
				}
				default:
				{
					throw new NoViableAltException(LT(1), getFilename());
				}
				 }
			}
			{
				switch ( LA(1) )
				{
				case AS:
				{
					match(AS);
					tr=type_reference();
					break;
				}
				case IF:
				case UNLESS:
				case COLON:
				{
					break;
				}
				default:
				{
					throw new NoViableAltException(LT(1), getFilename());
				}
				 }
			}
			{
				switch ( LA(1) )
				{
				case IF:
				case UNLESS:
				{
					{
						switch ( LA(1) )
						{
						case IF:
						{
							match(IF);
							break;
						}
						case UNLESS:
						{
							u = LT(1);
							match(UNLESS);
							break;
						}
						default:
						{
							throw new NoViableAltException(LT(1), getFilename());
						}
						 }
					}
					e=boolean_expression();
					break;
				}
				case COLON:
				{
					break;
				}
				default:
				{
					throw new NoViableAltException(LT(1), getFilename());
				}
				 }
			}
			if (0==inputState.guessing)
			{
				
						eh = new ExceptionHandler(ToLexicalInfo(c));
						
						eh.Declaration = new Declaration();
						eh.Declaration.Type = tr;
						
						if (x != null)
						{
							eh.Declaration.LexicalInfo = ToLexicalInfo(x);
							eh.Declaration.Name = x.getText();		
						}
						else
						{
							eh.Declaration.Name = null;
							eh.Flags |= ExceptionHandlerFlags.Anonymous;
						}
						if (tr != null)
						{
							eh.Declaration.LexicalInfo = tr.LexicalInfo;
						}
						else if (x != null)
						{
							eh.Declaration.LexicalInfo = eh.LexicalInfo;
						}
						if(tr == null)
						{
							eh.Flags |= ExceptionHandlerFlags.Untyped;
						}
						if (e != null)
						{
							if(u != null)
							{
								UnaryExpression not = new UnaryExpression(ToLexicalInfo(u));
								not.Operator = UnaryOperatorType.LogicalNot;
								not.Operand = e;
								e = not;
							}
							eh.FilterCondition = e;
							eh.Flags |= ExceptionHandlerFlags.Filter;
						}
					
			}
			compound_stmt(eh.Block);
			if (0==inputState.guessing)
			{
				
						t.ExceptionHandlers.Add(eh);
					
			}
		}
		catch (RecognitionException ex)
		{
			if (0 == inputState.guessing)
			{
				reportError(ex, "exception_handler");
				recover(ex,tokenSet_106_);
			}
			else
			{
				throw ex;
			}
		}
	}
예제 #4
0
        //throws RecognitionException, TokenStreamException
        protected Block exception_handler(
            TryStatement t
            )
        {
            Block lastBlock;

            IToken  c = null;
            IToken  x = null;
            IToken  u = null;

                ExceptionHandler eh = null;
                TypeReference tr = null;
                Expression e = null;
                lastBlock = null;

            try {      // for error handling
            c = LT(1);
            match(EXCEPT);
            {
                switch ( LA(1) )
                {
                case ID:
                {
                    x = LT(1);
                    match(ID);
                    break;
                }
                case AS:
                case IF:
                case UNLESS:
                case COLON:
                {
                    break;
                }
                default:
                {
                    throw new NoViableAltException(LT(1), getFilename());
                }
                 }
            }
            {
                switch ( LA(1) )
                {
                case AS:
                {
                    match(AS);
                    tr=type_reference();
                    break;
                }
                case IF:
                case UNLESS:
                case COLON:
                {
                    break;
                }
                default:
                {
                    throw new NoViableAltException(LT(1), getFilename());
                }
                 }
            }
            {
                switch ( LA(1) )
                {
                case IF:
                case UNLESS:
                {
                    {
                        switch ( LA(1) )
                        {
                        case IF:
                        {
                            match(IF);
                            break;
                        }
                        case UNLESS:
                        {
                            u = LT(1);
                            match(UNLESS);
                            break;
                        }
                        default:
                        {
                            throw new NoViableAltException(LT(1), getFilename());
                        }
                         }
                    }
                    e=expression();
                    break;
                }
                case COLON:
                {
                    break;
                }
                default:
                {
                    throw new NoViableAltException(LT(1), getFilename());
                }
                 }
            }
            begin();
            if (0==inputState.guessing)
            {

                        eh = new ExceptionHandler(SourceLocationFactory.ToLexicalInfo(c));

                        eh.Declaration = new Declaration();
                        eh.Declaration.Type = tr;

                        if (x != null)
                        {
                            eh.Declaration.LexicalInfo = SourceLocationFactory.ToLexicalInfo(x);
                            eh.Declaration.Name = x.getText();
                        }
                        else
                        {
                            eh.Declaration.Name = null;
                            eh.Flags |= ExceptionHandlerFlags.Anonymous;
                        }
                        if (tr != null)
                        {
                            eh.Declaration.LexicalInfo = tr.LexicalInfo;
                        }
                        else if (x != null)
                        {
                            eh.Declaration.LexicalInfo = eh.LexicalInfo;
                        }
                        if(tr == null)
                        {
                            eh.Flags |= ExceptionHandlerFlags.Untyped;
                        }
                        if (e != null)
                        {
                            if(u != null)
                            {
                                UnaryExpression not = new UnaryExpression(SourceLocationFactory.ToLexicalInfo(u));
                                not.Operator = UnaryOperatorType.LogicalNot;
                                not.Operand = e;
                                e = not;
                            }
                            eh.FilterCondition = e;
                            eh.Flags |= ExceptionHandlerFlags.Filter;
                        }
                        eh.Block = new Block(SourceLocationFactory.ToLexicalInfo(c));

            }
            block(eh.Block.Statements);
            if (0==inputState.guessing)
            {

                        lastBlock = eh.Block;
                        t.ExceptionHandlers.Add(eh);

            }
            }
            catch (RecognitionException ex)
            {
            if (0 == inputState.guessing)
            {
                reportError(ex);
                recover(ex,tokenSet_95_);
            }
            else
            {
                throw ex;
            }
            }
            return lastBlock;
        }
예제 #5
0
 public override void OnExceptionHandler(ExceptionHandler node)
 {
     _state.EnterExceptionHandler();
     Visit(node.Block);
     _state.LeaveExceptionHandler();
 }
예제 #6
0
 public static CompilerError ExceptionAlreadyHandled(ExceptionHandler dupe, ExceptionHandler previous)
 {
     return Instantiate("BCE0165",
         dupe.Declaration, dupe.Declaration.Type, previous.Declaration.Type,
         AstUtil.SafePositionOnlyLexicalInfo(previous.Declaration), LanguageAmbiance.ExceptKeyword);
 }
예제 #7
0
파일: EmitAssembly.cs 프로젝트: hlizard/boo
		private void EmitStoreOrPopException(ExceptionHandler node)
		{
			if((node.Flags & ExceptionHandlerFlags.Anonymous) == ExceptionHandlerFlags.None)
			{
				_il.Emit(OpCodes.Stloc, GetLocalBuilder(node.Declaration));
			}
			else
			{
				_il.Emit(OpCodes.Pop);
			}
		}
예제 #8
0
파일: EmitAssembly.cs 프로젝트: hlizard/boo
		override public void OnExceptionHandler(ExceptionHandler node)
		{
			if((node.Flags & ExceptionHandlerFlags.Filter) == ExceptionHandlerFlags.Filter)
			{
				_il.BeginExceptFilterBlock();

				Label endLabel = _il.DefineLabel();

				// If the filter is not untyped, then test the exception type
				// before testing the filter condition
				if((node.Flags & ExceptionHandlerFlags.Untyped) == ExceptionHandlerFlags.None)
				{
					Label filterCondition = _il.DefineLabel();

					// Test the type of the exception.
					_il.Emit(OpCodes.Isinst, GetSystemType(node.Declaration.Type));

					// Duplicate it.  If it is null, then it will be used to
					// skip the filter.
					Dup();

					// If the exception is of the right type, branch
					// to test the filter condition.
					_il.Emit(OpCodes.Brtrue_S, filterCondition);

					// Otherwise, clean up the stack and prepare the stack
					// to skip the filter.
					EmitStoreOrPopException(node);

					_il.Emit(OpCodes.Ldc_I4_0);
					_il.Emit(OpCodes.Br, endLabel);
					_il.MarkLabel(filterCondition);

				}
				else if((node.Flags & ExceptionHandlerFlags.Anonymous) == ExceptionHandlerFlags.None)
				{
					// Cast the exception to the default except type
					_il.Emit(OpCodes.Isinst, GetSystemType(node.Declaration.Type));
				}

				EmitStoreOrPopException(node);

				// Test the condition and convert to boolean if needed.
				node.FilterCondition.Accept(this);
				PopType();
				EmitToBoolIfNeeded(node.FilterCondition);

				// If the type is right and the condition is true,
				// proceed with the handler.
				_il.MarkLabel(endLabel);
				_il.Emit(OpCodes.Ldc_I4_0);
				_il.Emit(OpCodes.Cgt_Un);

				_il.BeginCatchBlock(null);
			}
			else
			{
				// Begin a normal catch block of the appropriate type.
				_il.BeginCatchBlock(GetSystemType(node.Declaration.Type));

				// Clean up the stack or store the exception if not anonymous.
				EmitStoreOrPopException(node);
			}

			Visit(node.Block);
		}
		public override void OnExceptionHandler(ExceptionHandler node)
		{
			if (node.Declaration != null) {
				if (node.LexicalInfo.Line <= resolver.CaretLine && GetEndSourceLocation(node).Line >= resolver.CaretLine) {
					DeclarationFound(node.Declaration.Name, node.Declaration.Type ?? new SimpleTypeReference("System.Exception"), null, node.Declaration.LexicalInfo);
				}
			}
			base.OnExceptionHandler(node);
		}
예제 #10
0
 public static CompilerWarning AmbiguousExceptionName(ExceptionHandler node)
 {
     return new CompilerWarning("BCW0019", AstUtil.SafeLexicalInfo(node), node.Declaration.Name);
 }
예제 #11
0
 public override void LeaveExceptionHandler(ExceptionHandler node)
 {
     if (null != node.Declaration.Type.Entity
         && ((IType)node.Declaration.Type.Entity).FullName == "System.Exception"
         && !string.IsNullOrEmpty(node.Declaration.Name))
     {
         if (null != NameResolutionService.ResolveTypeName(new SimpleTypeReference(node.Declaration.Name)))
             Warnings.Add(CompilerWarningFactory.AmbiguousExceptionName(node));
     }
 }
예제 #12
0
        protected override Statement ExpandImpl(MacroStatement macro){
            if (macro.Arguments.Count == 0){
                throw new Exception("need at least one IEnumerable parameter");
            }

            var result = new Block();
            Expression src = macro.Arguments[0];

            var idx = new ReferenceExpression("_idx");
            Expression item = new ReferenceExpression("i");
            var col = new ReferenceExpression("current_collection");
            if (src is BinaryExpression){
                item = ((BinaryExpression) src).Left;
                src = ((BinaryExpression) src).Right;
            }

            if (macro.Arguments.Count > 1){
                idx = (ReferenceExpression) macro.Arguments[1];
            }

            string prefix = macro.get<string>("_prefix") ?? "";
            string suffix = macro.get<string>("_suffix") ?? "";


            Func<string, MacroStatement> findmacro = s =>{
                                                         var r = macro.get<Node>(s);
                                                         if (null == r){
                                                             return null;
                                                         }
                                                         if (!(r is MacroStatement)){
                                                             var m = new MacroStatement("stub");
                                                             m.Body = new Block().add(r);
                                                             r = m;
                                                         }

                                                         return (MacroStatement) r;
                                                     };
            Func<MacroStatement, Block> extract = m =>{
                                                      if (null == m){
                                                          return null;
                                                      }
                                                      if (m.Body != null && !m.Body.IsEmpty){
                                                          if (m.Body.Statements.Count == 1){
                                                              if (m.Body.Statements[0] is ExpressionStatement){
                                                                  Expression _ex =
                                                                      ((ExpressionStatement) m.Body.Statements[0]).
                                                                          Expression;
                                                                  if (_ex is LiteralExpression ||
                                                                      !_ex.ToCodeString().ToLower().StartsWith("out")){
                                                                      return new Block().add(_ex.writeOut());
                                                                  }
                                                              }
                                                          }
                                                          return m.Body;
                                                      }
                                                      if (m.Arguments.Count == 0){
                                                          return null;
                                                      }
                                                      var r = new Block();
                                                      if (!(m.Arguments[0] is MethodInvocationExpression)){
                                                          r.Add(BrailBuildingHelper.WriteOut(m.Arguments[0]));
                                                      }
                                                      else{
                                                          r.Add(m.Arguments[0]);
                                                      }

                                                      return r;
                                                  };

            MacroStatement beforeall_macro = findmacro("beforeall");
            MacroStatement onitem_macro = findmacro("onitem") ?? macro;
            MacroStatement onerror_macro = findmacro("onerror");
            ;
            MacroStatement between_macro = findmacro("between");
            ;
            MacroStatement afterall_macro = findmacro("afterall");
            ;
            MacroStatement onempty_macro = findmacro("onempty");
            ;
            MacroStatement beforeeach_macro = findmacro("beforeeach");
            ;
            MacroStatement aftereach_macro = findmacro("aftereach");

            MacroStatement prepare_macro = findmacro("prepare");
            ;

            Block beforeall = extract(beforeall_macro);
            Block onitem = extractMainItemBlock(macro, extract, onitem_macro, item, prefix, suffix);
            Block onerror = extract(onerror_macro);
            Block between = extract(between_macro);
            Block afterall = extract(afterall_macro);
            Block onempty = null;

            bool proceed_on_empty = false;
            if (onempty_macro != null && onempty_macro.Arguments.Count != 0 &&
                onempty_macro.Arguments[0].ToCodeString() == "proceed"){
                proceed_on_empty = true;
            }
            else{
                onempty = extract(onempty_macro);
            }
            Block beforeeach = extract(beforeeach_macro);
            Block aftereach = extract(aftereach_macro);


//          _idx = 0

            Statement betweener = getBetweener(idx, between);
            result.Add(col.assign(new MethodInvocationExpression(new ReferenceExpression("_wrapcollection"), src)));
            result.Add(new ReferenceExpression("___proceed").assign(new BoolLiteralExpression(proceed_on_empty)));
            var mainblock = new Block();
            mainblock.Add(idx.assign(0));
            mainblock.Add(new IfStatement(
                              new BinaryExpression(BinaryOperatorType.Equality, new NullLiteralExpression(), col),
                              new Block().add(new BinaryExpression(BinaryOperatorType.Assign, col,
                                                                   new MethodInvocationExpression(
                                                                       new ReferenceExpression("_wrapcollection"),
                                                                       new ArrayLiteralExpression()))),
                              null
                              ));
            if (beforeall != null){
                mainblock.Add(beforeall);
            }
            var maincycle = new ForStatement();
            maincycle.Iterator = col;
            string declname = item.ToCodeString();
            TypeReference decltype = null;
            if (item is TryCastExpression){
                declname = ((TryCastExpression) item).Target.ToCodeString();
                decltype = ((TryCastExpression) item).Type;
            }
            maincycle.Declarations.Add(new Declaration(maincycle.LexicalInfo, declname, decltype));
            maincycle.Block = new Block();
            maincycle.ThenBlock = afterall;

            if (betweener != null){
                maincycle.Block.Add(betweener);
            }
            if (null != prepare_macro){
                maincycle.Block.Add(prepare_macro.Body);
            }
            if (null != beforeeach){
                maincycle.Block.Add(beforeeach);
            }
            if (onerror == null){
                maincycle.Block.Add(onitem);
            }
            else{
                var trycatch = new TryStatement();
                var exchandler = new ExceptionHandler();
                exchandler.Block = onerror;
                exchandler.Declaration = new Declaration("_ex", new SimpleTypeReference("System.Exception"));
                trycatch.ProtectedBlock = onitem;
                trycatch.ExceptionHandlers.Add(exchandler);
                maincycle.Block.Add(trycatch);
            }
            if (null != aftereach){
                maincycle.Block.Add(aftereach);
            }
            maincycle.Block.Add(new UnaryExpression(UnaryOperatorType.Increment, idx));

            mainblock.Add(maincycle);

            result.Add(
                new IfStatement(
                    getMainCondition(col),
                    mainblock,
                    onempty
                    )
                );

//          if null!=items and (items as IEnumerable).Cast[of System.Object]().Count() != 0:

            return result;
        }
예제 #13
0
        public override void OnExceptionHandler(ExceptionHandler node)
        {
            WriteIndented();
            WriteKeyword("except");
            if ((node.Flags & ExceptionHandlerFlags.Untyped) == ExceptionHandlerFlags.None)
            {
               if((node.Flags & ExceptionHandlerFlags.Anonymous) == ExceptionHandlerFlags.None)
                {
                    Write(" ");
                    Visit(node.Declaration);
                }
                else
                {
                    WriteTypeReference(node.Declaration.Type);
                }
            }
            else if((node.Flags & ExceptionHandlerFlags.Anonymous) == ExceptionHandlerFlags.None)
            {
                Write(" ");
                Write(node.Declaration.Name);
            }

            if((node.Flags & ExceptionHandlerFlags.Filter) == ExceptionHandlerFlags.Filter)
            {
                UnaryExpression unless = node.FilterCondition as UnaryExpression;
                if(unless != null && unless.Operator == UnaryOperatorType.LogicalNot)
                {
                    WriteKeyword(" unless ");
                    Visit(unless.Operand);
                }
                else
                {
                    WriteKeyword(" if ");
                    Visit(node.FilterCondition);
                }
            }
            WriteLine(":");
            Indent();
            WriteBlockStatements(node.Block);
            Dedent();
        }
예제 #14
0
		override public object Clone()
		{
		
			ExceptionHandler clone = new ExceptionHandler();
			clone._lexicalInfo = _lexicalInfo;
			clone._endSourceLocation = _endSourceLocation;
			clone._documentation = _documentation;
			clone._isSynthetic = _isSynthetic;
			clone._entity = _entity;
			if (_annotations != null) clone._annotations = (Hashtable)_annotations.Clone();
			if (null != _declaration)
			{
				clone._declaration = _declaration.Clone() as Declaration;
				clone._declaration.InitializeParent(clone);
			}
			if (null != _filterCondition)
			{
				clone._filterCondition = _filterCondition.Clone() as Expression;
				clone._filterCondition.InitializeParent(clone);
			}
			clone._flags = _flags;
			if (null != _block)
			{
				clone._block = _block.Clone() as Block;
				clone._block.InitializeParent(clone);
			}
			return clone;


		}
		public object VisitTryCatchStatement(TryCatchStatement tryCatchStatement, object data)
		{
			B.TryStatement t = new B.TryStatement(GetLexicalInfo(tryCatchStatement));
			t.EndSourceLocation = GetLocation(tryCatchStatement.EndLocation);
			t.ProtectedBlock = ConvertBlock(tryCatchStatement.StatementBlock);
			t.EnsureBlock = ConvertBlock(tryCatchStatement.FinallyBlock);
			foreach (CatchClause clause in tryCatchStatement.CatchClauses) {
				B.ExceptionHandler handler = new B.ExceptionHandler(GetLexicalInfo(clause));
				handler.Block = ConvertBlock(clause.StatementBlock);
				B.TypeReference typeRef = ConvertTypeReference(clause.TypeReference);
				string name = clause.VariableName;
				if (typeRef != null) {
					if (name == null || name.Length == 0)
						name = GenerateName();
					handler.Declaration = new B.Declaration(name, typeRef);
				} else {
					if (name != null && name.Length > 0)
						handler.Declaration = new B.Declaration(name, null);
				}
				t.ExceptionHandlers.Add(handler);
			}
			return t;
		}
예제 #16
0
        public void try_statement(Block container)
        {
            IToken token = null;
            IToken token2 = null;
            IToken token3 = null;
            try
            {
                TryStatement statement;
                Block block;
                token = this.LT(1);
                this.match(0x2b);
                if (base.inputState.guessing == 0)
                {
                    statement = new TryStatement(ToLexicalInfo(token));
                    block = statement.get_ProtectedBlock();
                    container.Add(statement);
                }
                this.compound_or_single_stmt(block);
                while (true)
                {
                    TypeReference reference;
                    if ((this.LA(1) != 7) || (this.LA(2) != 0x3f))
                    {
                        break;
                    }
                    token2 = this.LT(1);
                    this.match(7);
                    this.match(0x3f);
                    token3 = this.LT(1);
                    this.match(0x3b);
                    switch (this.LA(1))
                    {
                        case 0x42:
                            this.match(0x42);
                            reference = this.type_reference();
                            break;

                        case 0x40:
                            break;

                        default:
                            throw new NoViableAltException(this.LT(1), this.getFilename());
                    }
                    this.match(0x40);
                    if (base.inputState.guessing == 0)
                    {
                        Declaration declaration;
                        ExceptionHandler handler;
                        if (reference == null)
                        {
                            reference = new SimpleTypeReference(ToLexicalInfo(token3), "System.Exception");
                        }
                        ExceptionHandler handler1 = handler = new ExceptionHandler(ToLexicalInfo(token2));
                        Declaration declaration1 = declaration = new Declaration(ToLexicalInfo(token3));
                        declaration.set_Name(token3.getText());
                        declaration.set_Type(reference);
                        handler.set_Declaration(declaration);
                        ExceptionHandler handler2 = handler;
                        statement.get_ExceptionHandlers().Add(handler2);
                        block = handler2.get_Block();
                        reference = null;
                    }
                    this.compound_or_single_stmt(block);
                }
                if ((this.LA(1) != 0x11) || !tokenSet_2_.member(this.LA(2)))
                {
                    if (!tokenSet_15_.member(this.LA(1)) || !tokenSet_20_.member(this.LA(2)))
                    {
                        throw new NoViableAltException(this.LT(1), this.getFilename());
                    }
                }
                else
                {
                    this.finally_block(statement);
                }
            }
            catch (RecognitionException exception)
            {
                if (base.inputState.guessing != 0)
                {
                    throw;
                }
                this.reportError(exception);
                this.recover(exception, tokenSet_15_);
            }
        }