示例#1
0
        public override Object Visit(CatchStatement node, Object obj)
        {
            node.Exception.Accept(this, obj);
            node.Statements.Accept(this, obj);

            return(null);
        }
示例#2
0
        private static Statement DetectStatement(Statement head)
        {
            Statement res;

            if ((res = DoStatement.IsHead(head)) != null)
            {
                return(res);
            }
            if ((res = SwitchStatement.IsHead(head)) != null)
            {
                return(res);
            }
            if ((res = IfStatement.IsHead(head)) != null)
            {
                return(res);
            }
            // synchronized statements will be identified later
            // right now they are recognized as catchall
            if ((res = SequenceStatement.IsHead2Block(head)) != null)
            {
                return(res);
            }
            if ((res = CatchStatement.IsHead(head)) != null)
            {
                return(res);
            }
            if ((res = CatchAllStatement.IsHead(head)) != null)
            {
                return(res);
            }
            return(null);
        }
 public override object Visit(CatchStatement node, object obj)
 {
     if (node.Location == ((AstNode)obj).Location || found)
     {
         found = true;
         return(this.table);
     }
     return(base.Visit(node, obj));
 }
示例#4
0
 private static void TestEquality(CatchStatement expected, CatchStatement actual, string propertyName)
 {
     try {
         ExpressionsAreEqual(expected.Parameter, actual.Parameter, "Parameter");
     } catch (DataAssertionException e) {
         e.Add(propertyName);
         throw e;
     }
     TestEquality((BlockStatement)expected, (BlockStatement)actual, propertyName);
 }
示例#5
0
        public override Object Visit(CatchStatement node, Object obj)
        {
            int indent = Convert.ToInt32(obj);

            this.printIndentation(indent);
            this.output.WriteLine("CatchStatement [{0}:{1}]", node.Location.Line, node.Location.Column);
            node.Exception.Accept(this, indent + 1);
            node.Statements.Accept(this, indent + 1);
            return(null);
        }
        private static void MapClassMethods(ClassesProcessor.ClassNode node, Dictionary <
                                                ClassWrapper, MethodWrapper> map)
        {
            bool noSynthFlag = DecompilerContext.GetOption(IFernflowerPreferences.Synthetic_Not_Set
                                                           );
            ClassWrapper wrapper = node.GetWrapper();

            foreach (MethodWrapper method in wrapper.GetMethods())
            {
                StructMethod mt = method.methodStruct;
                if ((noSynthFlag || mt.IsSynthetic()) && mt.GetDescriptor().Equals("(Ljava/lang/String;)Ljava/lang/Class;"
                                                                                   ) && mt.HasModifier(ICodeConstants.Acc_Static))
                {
                    RootStatement root = method.root;
                    if (root != null && root.GetFirst().type == Statement.Type_Trycatch)
                    {
                        CatchStatement cst = (CatchStatement)root.GetFirst();
                        if (cst.GetStats().Count == 2 && cst.GetFirst().type == Statement.Type_Basicblock &&
                            cst.GetStats()[1].type == Statement.Type_Basicblock && cst.GetVars()[0].GetVarType
                                ().Equals(new VarType(ICodeConstants.Type_Object, 0, "java/lang/ClassNotFoundException"
                                                      )))
                        {
                            BasicBlockStatement body    = (BasicBlockStatement)cst.GetFirst();
                            BasicBlockStatement handler = (BasicBlockStatement)cst.GetStats()[1];
                            if (body.GetExprents().Count == 1 && handler.GetExprents().Count == 1)
                            {
                                if (Body_Expr.Equals(body.GetExprents()[0]) && Handler_Expr.Equals(handler.GetExprents
                                                                                                       ()[0]))
                                {
                                    Sharpen.Collections.Put(map, wrapper, method);
                                    break;
                                }
                            }
                        }
                    }
                }
            }
            // iterate nested classes
            foreach (ClassesProcessor.ClassNode nd in node.nested)
            {
                MapClassMethods(nd, map);
            }
        }
示例#7
0
 public override void WriteTo(TextWriter w)
 {
     w.Write("try");
     TryBody.WriteTo(w);
     if (CatchStatement != null)
     {
         w.Write("catch(");
         w.Write(CaughtErrorIdentifier);
         w.Write("){");
         CatchStatement.WriteTo(w);
         w.Write("}");
     }
     w.Write("finally{");
     foreach (var stmt in FinallyStatements)
     {
         stmt.WriteTo(w);
     }
     w.Write("}");
 }
示例#8
0
        public Statement GetStatement()
        {
            var catchStatement = new CatchStatement();

            catchStatement.Block  = statementInterpreterHandler.GetStatement(catchClauseSyntax.Block);
            catchStatement.Filter = catchClauseSyntax.Filter == null ?
                                    null : statementInterpreterHandler.GetStatement(catchClauseSyntax.Filter.FilterExpression);

            if (catchClauseSyntax.Declaration != null)
            {
                catchStatement.Type = semanticModel.GetTypeInfo(catchClauseSyntax.Declaration.Type).GetClassType();

                if (!catchClauseSyntax.Declaration.Identifier.IsKind(Microsoft.CodeAnalysis.CSharp.SyntaxKind.None))
                {
                    catchStatement.Variable = new LocalVariableDeclaration
                    {
                        Type = catchStatement.Type,
                        Name = catchClauseSyntax.Declaration.Identifier.ValueText
                    };
                }
            }
            return(catchStatement);
        }
示例#9
0
 public abstract Object Visit(CatchStatement node, Object obj);
示例#10
0
 public override Object Visit(CatchStatement node, Object obj)
 {
     return(new CatchStatement((IdDeclaration)node.Exception.Accept(this, obj), (Block)node.Statements.Accept(this, obj), node.Location));
 }
 public ReadOnlyCatchStatement(CatchStatement catchStatement)
 {
     statements   = ReadOnlyStatement.Create(catchStatement.Statements);
     type         = new ReadOnlyTypeReference(catchStatement.Type);
     variableName = catchStatement.Name;
 }
        private void CheckStatementCurlyBracketPlacement(Element element, Statement statement)
        {
            Param.AssertNotNull(element, "element");
            Param.AssertNotNull(statement, "statement");

            switch (statement.StatementType)
            {
            case StatementType.Else:
                // Check that there is nothing between the starting else keyword and the opening bracket.
                this.CheckChainedStatementCurlyBracketPlacement(element, statement);
                this.CheckBlockStatementsCurlyBracketPlacement(element, statement);

                // Check that there is nothing between the closing bracket and the else keyword of the attached else statement.
                ElseStatement elseStatement = (ElseStatement)statement;
                if (elseStatement.AttachedElseStatement != null)
                {
                    this.CheckTrailingStatementCurlyBracketPlacement(element, statement);
                }

                break;

            case StatementType.Catch:
            case StatementType.Finally:
                // Check that there is nothing between the starting catch or finally keyword and the opening bracket.
                this.CheckChainedStatementCurlyBracketPlacement(element, statement);
                this.CheckBlockStatementsCurlyBracketPlacement(element, statement);
                break;

            case StatementType.If:
                this.CheckBlockStatementsCurlyBracketPlacement(element, statement);

                // Check that there is nothing between the closing bracket and the else keyword of the attached else statement.
                IfStatement ifStatement = (IfStatement)statement;
                if (ifStatement.AttachedElseStatement != null)
                {
                    this.CheckTrailingStatementCurlyBracketPlacement(element, statement);
                }

                break;

            case StatementType.Try:
                // Check that there is nothing between the starting try keyword and the opening bracket.
                this.CheckBlockStatementsCurlyBracketPlacement(element, statement);

                TryStatement tryStatement = (TryStatement)statement;
                if (tryStatement.FinallyStatement != null || (tryStatement.CatchStatements != null && tryStatement.CatchStatements.Count > 0))
                {
                    // There is something attached to the end of this try statement. Check that there is nothing between
                    // the closing bracket of the try statement and the start of the attached statement.
                    this.CheckTrailingStatementCurlyBracketPlacement(element, tryStatement);
                }

                if (tryStatement.CatchStatements != null && tryStatement.CatchStatements.Count > 0)
                {
                    CatchStatement[] catchStatementArray = new CatchStatement[tryStatement.CatchStatements.Count];
                    tryStatement.CatchStatements.CopyTo(catchStatementArray, 0);

                    for (int i = 0; i < catchStatementArray.Length; ++i)
                    {
                        if (catchStatementArray.Length > i + 1 || tryStatement.FinallyStatement != null)
                        {
                            // There is something attached to the end of this catch statement, either another catch or a finally.
                            // Check that there is nothing between the closing bracket of this catch statement and the start of the attached
                            // statement.
                            this.CheckTrailingStatementCurlyBracketPlacement(element, catchStatementArray[i]);
                        }
                    }
                }

                break;

            case StatementType.Checked:
            case StatementType.Fixed:
            case StatementType.For:
            case StatementType.Foreach:
            case StatementType.Lock:
            case StatementType.Switch:
            case StatementType.Unchecked:
            case StatementType.Unsafe:
            case StatementType.Using:
            case StatementType.While:
                // Check that there is nothing between the starting keyword and the opening bracket.
                this.CheckBlockStatementsCurlyBracketPlacement(element, statement);
                break;

            case StatementType.DoWhile:
                this.CheckBlockStatementsCurlyBracketPlacement(element, statement);
                this.CheckTrailingStatementCurlyBracketPlacement(element, statement);
                break;

            default:
                break;
            }
        }