text: /*
   *  Licensed to the Apache Software Foundation (ASF) under one or more
   *  contributor license agreements.  See the NOTICE file distributed with
   *  this work for additional information regarding copyright ownership.
   *  The ASF licenses this file to You under the Apache License, Version 2.0
   *  (the "License"); you may not use this file except in compliance with
   *  the License.  You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
   *  Unless required by applicable law or agreed to in writing, software
   *  distributed under the License is distributed on an "AS IS" BASIS,
   *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   *  See the License for the specific language governing permissions and
   *  limitations under the License.
   */
  /** 
   * @author Intel, Pavel Afremov
   */  
  #ifndef _EXCEPTIONS_H_
  #define _EXCEPTIONS_H_
  
  #include "open/types.h"
  #include "exceptions_type.h"
  #include "jni.h"
  
  /**
  @file
  \ref exceptions
  */
  
  /**
  @page exceptions Exceptions subsystem
  
  \section exn_introduction Introduction
  The functions to work with exceptions are described in exceptions.h.
  
  \section exn_issues Issues
  
  \li Interaction with JIT and runtime helpers? -salikh
  \li Interaction with JIT is implemented via rth_wrap_exn_throw stubs. -pavel.n.afremov
  \li Existing interface is currently included.
  
  */
  
  /**
   * Returns the thread-local exception object
   * or NULL if no exception occured.
   */
  VMEXPORT jthrowable exn_get();
  
  VMEXPORT Class* exn_get_class();
  VMEXPORT const char* exn_get_name();
  
  
  /**
   * Returns true if the thread-local exception object is set.
   */
  VMEXPORT bool exn_raised();
  
  /**
   * Clears the thread-local exception object.
   *
   * @note rename of clear_current_thread_exception(). It may be eliminated if
   * exn_catch() will be used and will clean thread exception.
   */
  VMEXPORT void exn_clear();
  
  /**
   * Creates exception object.
   */
  //FIXME LAZY EXCEPTION (2006.05.06)
  // Maybe change to exn_object_create (whole 7)
  jthrowable exn_create(Exception* exception);
  
  jthrowable exn_create(Class* exc_class);
  jthrowable exn_create(Class* exc_class, jthrowable cause);
  jthrowable exn_create(Class* exc_class, const char* message);
  jthrowable exn_create(Class* exc_class, const char* message, jthrowable cause);
  
  /**
   * Creates exception object.
   */
  VMEXPORT jthrowable exn_create(const char* exc_name);
  
  /**
   * Creates exception object.
   */
  VMEXPORT jthrowable exn_create(const char* exc_name, jthrowable cause);
  
  /**
   * Creates exception object.
   */
  VMEXPORT jthrowable exn_create(const char* exc_name, const char* message);
  
  /**
   * Creates exception object.
   */
  VMEXPORT jthrowable exn_create(const char* exc_name, const char* message, jthrowable cause);
  
  /**
   * Returns true if frame is unwindable and false if isn't. 
   */
  VMEXPORT bool is_unwindable();
  
  /**
   * Sets unwindable property of frame. If frame is unwindable property
   * should be true and should be false if frame isn't unwindable.
   * Returns previous value of unwindable property.
   */
  bool set_unwindable(bool unwindable);
  
  /**
   * Throws an exception object
   *
   * @note internal convenience function, may not be exposed to VMI interface.
   */
  void exn_throw_object(jthrowable exc_object);
  
  /**
   * Throws an exceptionas lazy.
   * Does not return in case of destructive exception propagation.
   *
   * @note internal convenience function, may not be exposed to VMI interface.
   */
  void exn_throw_by_class(Class* exc_class);
  void exn_throw_by_class(Class* exc_class, jthrowable exc_cause);
  void exn_throw_by_class(Class* exc_class, const char* exc_message);
  void exn_throw_by_class(Class* exc_class, const char* exc_message,
      jthrowable exc_cause);
  
  /**
   * Throws an exceptionas lazy.
   * Does not return in case of destructive exception propagation.
   */
  VMEXPORT void exn_throw_by_name(const char* exception_name);
  
  /**
   * Throws an exceptionas lazy.
   * Does not return in case of destructive exception propagation.
   */
  VMEXPORT void exn_throw_by_name(const char* exception_name, jthrowable cause);
  
  /**
   * Throws an exceptionas lazy.
   * Does not return in case of destructive exception propagation.
   */
  VMEXPORT void exn_throw_by_name(const char* exception_name, const char* message);
  
  /**
   * Throws an exceptionas lazy.
   * Does not return in case of destructive exception propagation.
   */
  VMEXPORT void exn_throw_by_name(const char* exception_name, const char* message, jthrowable cause);
  
  /**
   * Sets exceptions as a thread local exception.
   *
   * @note explicit non-destructive semantics should be deduced from context.
   */
  VMEXPORT void exn_raise_object(jthrowable exc_object);
  
  /**
   * Sets exception lazy as a thread local exception.
   *
   * @note internal convenience function, may not be exposed to VMI interface.
   * @note explicit non-destructive semantics should be deduced from context.
   */
  void exn_raise_by_class(Class* exc_class);
  void exn_raise_by_class(Class* exc_class, jthrowable exc_cause);
  void exn_raise_by_class(Class* exc_class, const char* exc_message);
  void exn_raise_by_class(Class* exc_class, const char* exc_message,
      jthrowable exc_cause);
  
  /**
   * Sets exception lazy as a thread local exception.
   *
   * @note explicit non-destructive semantics should be deduced from context.
   */
  VMEXPORT void exn_raise_by_name(const char* exception_name);
  
  /**
   * Sets exception lazy as a thread local exception.
   *
   * @note explicit non-destructive semantics should be deduced from context.
   */
  VMEXPORT void exn_raise_by_name(const char* exception_name, jthrowable exc_cause);
  
  /**
   * Sets exception lazy as a thread local exception.
   *
   * @note explicit non-destructive semantics should be deduced from context.
   */
  VMEXPORT void exn_raise_by_name(const char* exception_name, const char* message);
  
  /**
   * Sets exception lazy as a thread local exception.
   *
   * @note explicit non-destructive semantics should be deduced from context.
   */
  VMEXPORT void exn_raise_by_name(const char* exception_name, const char* message,
      jthrowable exc_cause);
  
  /**
   * Pushes dummy non-unwindable stack frame in order to prevent stack unwinding.
   * After this returns true. If unwinding is happnened control coming back into
   * this function, and after this it returns false.
   *
   * @note experimental
   */
  bool exn_function_try();
  
  /**
   * pops dummy non-unwindable stack frame
   *
   * returns the current thread exception object
   * or NULL if no exception occured.
   *
   * @note experimental
   */
  jthrowable exn_function_catch();
  
  /**
   * Wrapper for exn_function_try.
   */
  #define exn_try (if (exn_function_try()))
  
  /**
   * Wrapper for exn_function_catch.
   */
  #define exn_catch (th) (if ( th = exn_function_catch()))
  
  #define ASSERT_THROW_AREA \
  assert(is_unwindable());
  
  #define ASSERT_RAISE_AREA \
  assert(!is_unwindable());
  
  #define BEGIN_RAISE_AREA \
  { \
  bool unwindable = set_unwindable(false);\
  if (unwindable) exn_rethrow_if_pending();
  
  #define END_RAISE_AREA \
  if (unwindable) exn_rethrow_if_pending();\
  set_unwindable(unwindable);\
  }
  
  
  ////////////////////////////////////////////////////////////////////////
  // FUNCTIONS below are from old VM implementation //////////////////////
  ////////////////////////////////////////////////////////////////////////
  
  #include "open/vm_util.h"
  
  struct ManagedObject;
  
  //**** Stack Trace support
  
  // Print the stack trace stored in the exception object to the given file.
  void exn_print_stack_trace(FILE* f, jthrowable exc);
  
  void print_uncaught_exception_message(FILE *f, const char* context_message, jthrowable exc);
  
  
  //**** Native code exception support
  
  void exn_rethrow();
  void exn_rethrow_if_pending();
  
  typedef struct VM_thread * vm_thread_t;
  void* get_exception_catch_stack_addr(void* curr_ip);
  VMEXPORT size_t get_available_stack_size();
  VMEXPORT bool check_available_stack_size(size_t required_size);
  bool check_stack_size_enough_for_exception_catch(void* sp);
  
  #endif // _EXCEPTIONS_H_
  