private static void WriteThrowException(LanguageWriter w, IThrowExceptionStatement state)
 {
     w.WriteKeyword("throw");
     if (state.Expression != null)
     {
         w.Write(" ");
         ExpressionWriter.WriteExpression(w, state.Expression, false);
     }
     w.Write(";");
     w.WriteLine();
 }
Beispiel #2
0
        public override bool Equals(object obj)
        {
            if (this == obj)
            {
                return(true);
            }

            IThrowExceptionStatement stmt = obj as IThrowExceptionStatement;

            if (stmt == null)
            {
                return(false);
            }

            return(Expression.Equals(stmt.Expression));
        }
 public virtual void VisitThrowExceptionStatement(IThrowExceptionStatement value)
 {
     VisitExpression(value.Expression);
 }
        public static bool IsCatchAllClause(ref IStatementCollection statements)
        {
            if (statements == null || statements.Count != 3)
            {
                return(false);
            }

            /* uint num1=0;*/ {
                IAssignExpression exp_assign = GetAssignExpression(statements[0]);
                if (exp_assign == null || null == GetVariableName(exp_assign.Target, "System", "UInt32"))
                {
                    return(false);
                }
                ILiteralExpression exp_lit = exp_assign.Expression as ILiteralExpression;
                if (exp_lit == null || (uint)exp_lit.Value != 0u)
                {
                    return(false);
                }
            }

            // 以下の二通りの場合がある (他にもあるかも知れない)
            // (1) int num2=::__CxxRegisterExceptionObject((void*)Marshal::GetExceptionPointers(),(void*)num0);
            // (2) ::__CxxRegisterExceptionObject((void*)Marshal::GetExceptionPointers(),(void*)num0);
            // 更に __Cxx の部分は ___Cxx だったりもする
            {
                IExpressionStatement exp_state = statements[1] as IExpressionStatement;
                if (exp_state == null)
                {
                    return(false);
                }

                IMethodInvokeExpression exp_inv;
                IAssignExpression       exp_assign = exp_state.Expression as IAssignExpression;
                if (exp_assign != null)
                {
                    // (1) に挑戦
                    if (null == GetVariableName(exp_assign.Target, "System", "Int32"))
                    {
                        return(false);
                    }
                    exp_inv = exp_assign.Expression as IMethodInvokeExpression;
                }
                else
                {
                    // (2) に挑戦
                    exp_inv = exp_state.Expression as IMethodInvokeExpression;
                }

                if (exp_inv == null || exp_inv.Arguments.Count != 2)
                {
                    return(false);
                }
                IMethodReferenceExpression exp_mref = exp_inv.Method as IMethodReferenceExpression;
                if (exp_mref == null || exp_mref.Method == null || exp_mref.Method.Name.TrimStart('_') != "CxxRegisterExceptionObject")
                {
                    return(false);
                }
            }

            //	try{
            //		try{
            //		}catch when{}
            //		break;
            //		if(num!=0u)throw;
            //	}finally{
            //		::__CxxUnregisterExceptionObject(esp0,num);
            //	}
            ITryCatchFinallyStatement state_tcf = statements[2] as ITryCatchFinallyStatement;
            {
                // try{
                if (state_tcf == null ||
                    state_tcf.Try == null || state_tcf.Try.Statements.Count != 3 ||
                    state_tcf.Finally == null || state_tcf.Finally.Statements.Count != 1
                    )
                {
                    return(false);
                }

                //     try{
                //	       <statements>
                //	   }catch when{}
                ITryCatchFinallyStatement state_tcf2 = state_tcf.Try.Statements[0] as ITryCatchFinallyStatement;
                if (state_tcf2 == null || state_tcf2.Try == null)
                {
                    return(false);
                }

                //     <break;goto;continue;return; 等>

                //     if(**!=**)throw;
                IConditionStatement state_cond = state_tcf.Try.Statements[state_tcf.Try.Statements.Count - 1] as IConditionStatement;
                if (state_cond == null || state_cond.Then.Statements.Count != 1)
                {
                    return(false);
                }
                IBinaryExpression exp_bin = state_cond.Condition as IBinaryExpression;
                if (exp_bin == null || exp_bin.Operator != BinaryOperator.ValueInequality)
                {
                    return(false);
                }
                IThrowExceptionStatement state_exc = state_cond.Then.Statements[0] as IThrowExceptionStatement;
                if (state_exc == null)
                {
                    return(false);
                }

                // } finally {
                //     ::__CxxUnregisterExceptionObject((void*)num2,(int)num);
                // }
                IMethodInvokeExpression exp_inv = GetInvokeExpression(state_tcf.Finally.Statements[0]);
                if (exp_inv == null || exp_inv.Arguments.Count != 2)
                {
                    return(false);
                }
                IMethodReferenceExpression exp_mref = exp_inv.Method as IMethodReferenceExpression;
                if (exp_mref == null || exp_mref.Method == null || exp_mref.Method.Name.TrimStart('_') != "CxxUnregisterExceptionObject")
                {
                    return(false);
                }

                // <statements>
                statements = state_tcf2.Try.Statements;
                return(true);
            }
        }
 private void WriteThrowExceptionStatement(IThrowExceptionStatement statement, IFormatter formatter)
 {
     this.WriteStatementSeparator(formatter);
     formatter.WriteKeyword("raise");
     formatter.Write(" ");
     if (statement.Expression != null)
         this.WriteExpression(statement.Expression, formatter);
     else
     {
         this.WriteDeclaration("Exception", formatter);
         formatter.Write(".");
         formatter.WriteKeyword("Create");
     }
 }
Beispiel #6
0
 public override void VisitThrowExceptionStatement(IThrowExceptionStatement value)
 {
     _formatter.WriteKeyword("throw");
     WriteWhitespace();
     VisitExpression(value.Expression);
 }
 public virtual void VisitThrowExceptionStatement(IThrowExceptionStatement value)
 {
     this.VisitExpression(value.Expression);
 }
 public virtual IStatement TransformThrowExceptionStatement(IThrowExceptionStatement value)
 {
     value.Expression = this.TransformExpression(value.Expression);
     return value;
 }