Gecko [ fernandoquevedodop.com ]

Name	Size	Permission
csharp	[ DIR ]	drwxr-xr-x
d	[ DIR ]	drwxr-xr-x
go	[ DIR ]	drwxr-xr-x
guile	[ DIR ]	drwxr-xr-x
java	[ DIR ]	drwxr-xr-x
javascript	[ DIR ]	drwxr-xr-x
lua	[ DIR ]	drwxr-xr-x
mzscheme	[ DIR ]	drwxr-xr-x
ocaml	[ DIR ]	drwxr-xr-x
octave	[ DIR ]	drwxr-xr-x
perl5	[ DIR ]	drwxr-xr-x
php	[ DIR ]	drwxr-xr-x
python	[ DIR ]	drwxr-xr-x
r	[ DIR ]	drwxr-xr-x
ruby	[ DIR ]	drwxr-xr-x
scilab	[ DIR ]	drwxr-xr-x
std	[ DIR ]	drwxr-xr-x
tcl	[ DIR ]	drwxr-xr-x
typemaps	[ DIR ]	drwxr-xr-x
xml	[ DIR ]	drwxr-xr-x
allkw.swg	717 B	-rw-r--r--
attribute.i	496 B	-rw-r--r--
carrays.i	2.58 KB	-rw-r--r--
cdata.i	2.71 KB	-rw-r--r--
cmalloc.i	2.3 KB	-rw-r--r--
constraints.i	6.88 KB	-rw-r--r--
cpointer.i	3.47 KB	-rw-r--r--
cstring.i	324 B	-rw-r--r--
cwstring.i	265 B	-rw-r--r--
director_common.swg	512 B	-rw-r--r--
exception.i	8.32 KB	-rw-r--r--
intrusive_ptr.i	2.66 KB	-rw-r--r--
inttypes.i	2.32 KB	-rw-r--r--
math.i	2.04 KB	-rw-r--r--
pointer.i	294 B	-rw-r--r--
runtime.swg	1.21 KB	-rw-r--r--
shared_ptr.i	2.54 KB	-rw-r--r--
std_except.i	2.05 KB	-rw-r--r--
stdint.i	2.31 KB	-rw-r--r--
stl.i	249 B	-rw-r--r--
swig.swg	24.3 KB	-rw-r--r--
swigarch.i	1.54 KB	-rw-r--r--
swigerrors.swg	499 B	-rw-r--r--
swigfragments.swg	2.02 KB	-rw-r--r--
swiginit.swg	7.83 KB	-rw-r--r--
swiglabels.swg	3.71 KB	-rw-r--r--
swigrun.i	256 B	-rw-r--r--
swigrun.swg	16.31 KB	-rw-r--r--
swigwarn.swg	14.62 KB	-rw-r--r--
swigwarnings.swg	6.93 KB	-rw-r--r--
wchar.i	309 B	-rw-r--r--
windows.i	4.08 KB	-rw-r--r--

Code Editor : exception.i

/* -----------------------------------------------------------------------------
 * exception.i
 *
 * SWIG library file providing language independent exception handling
 * ----------------------------------------------------------------------------- */

#if defined(SWIGUTL)
#error "This version of exception.i should not be used"
#endif

%insert("runtime") "swigerrors.swg"

#ifdef SWIGPHP
%{
#include "zend_exceptions.h"
#define SWIG_exception(code, msg) do { zend_throw_exception(NULL, (char*)msg, code); goto thrown; } while (0)
%}
#endif

#ifdef SWIGGUILE
%{
  SWIGINTERN void SWIG_exception_ (int code, const char *msg,
                               const char *subr) {
#define ERROR(scmerr)					\
	scm_error(scm_from_locale_string((char *) (scmerr)),	\
		  (char *) subr, (char *) msg,		\
		  SCM_EOL, SCM_BOOL_F)
#define MAP(swigerr, scmerr)			\
	case swigerr:				\
	  ERROR(scmerr);			\
	  break
    switch (code) {
      MAP(SWIG_MemoryError,	"swig-memory-error");
      MAP(SWIG_IOError,		"swig-io-error");
      MAP(SWIG_RuntimeError,	"swig-runtime-error");
      MAP(SWIG_IndexError,	"swig-index-error");
      MAP(SWIG_TypeError,	"swig-type-error");
      MAP(SWIG_DivisionByZero,	"swig-division-by-zero");
      MAP(SWIG_OverflowError,	"swig-overflow-error");
      MAP(SWIG_SyntaxError,	"swig-syntax-error");
      MAP(SWIG_ValueError,	"swig-value-error");
      MAP(SWIG_SystemError,	"swig-system-error");
    default:
      ERROR("swig-error");
    }
#undef ERROR
#undef MAP
  }

#define SWIG_exception(a,b) SWIG_exception_(a, b, FUNC_NAME)
%}
#endif

#ifdef SWIGMZSCHEME

%{
SWIGINTERN void SWIG_exception_ (int code, const char *msg) {
#define ERROR(errname)				\
	scheme_signal_error(errname " (%s)", msg);
#define MAP(swigerr, errname)			\
	case swigerr:				\
	  ERROR(errname);			\
	  break
    switch (code) {
      MAP(SWIG_MemoryError,	"swig-memory-error");
      MAP(SWIG_IOError,		"swig-io-error");
      MAP(SWIG_RuntimeError,	"swig-runtime-error");
      MAP(SWIG_IndexError,	"swig-index-error");
      MAP(SWIG_TypeError,	"swig-type-error");
      MAP(SWIG_DivisionByZero,	"swig-division-by-zero");
      MAP(SWIG_OverflowError,	"swig-overflow-error");
      MAP(SWIG_SyntaxError,	"swig-syntax-error");
      MAP(SWIG_ValueError,	"swig-value-error");
      MAP(SWIG_SystemError,	"swig-system-error");
    default:
      ERROR("swig-error");
    }
#undef ERROR
#undef MAP
  }

#define SWIG_exception(a,b) SWIG_exception_(a, b)
%}
#endif

#ifdef SWIGJAVA
%{
SWIGINTERN void SWIG_JavaException(JNIEnv *jenv, int code, const char *msg) {
  SWIG_JavaExceptionCodes exception_code = SWIG_JavaUnknownError;
  switch(code) {
  case SWIG_MemoryError:
    exception_code = SWIG_JavaOutOfMemoryError;
    break;
  case SWIG_IOError:
    exception_code = SWIG_JavaIOException;
    break;
  case SWIG_SystemError:
  case SWIG_RuntimeError:
    exception_code = SWIG_JavaRuntimeException;
    break;
  case SWIG_OverflowError:
  case SWIG_IndexError:
    exception_code = SWIG_JavaIndexOutOfBoundsException;
    break;
  case SWIG_DivisionByZero:
    exception_code = SWIG_JavaArithmeticException;
    break;
  case SWIG_SyntaxError:
  case SWIG_ValueError:
  case SWIG_TypeError:
    exception_code = SWIG_JavaIllegalArgumentException;
    break;
  case SWIG_UnknownError:
  default:
    exception_code = SWIG_JavaUnknownError;
    break;
  }
  SWIG_JavaThrowException(jenv, exception_code, msg);
}
%}

#define SWIG_exception(code, msg)\
{ SWIG_JavaException(jenv, code, msg); return $null; }
#endif // SWIGJAVA

#ifdef SWIGOCAML
%{
SWIGINTERN void SWIG_OCamlException(int code, const char *msg) {
  CAMLparam0();

SWIG_OCamlExceptionCodes exception_code = SWIG_OCamlUnknownError;
  switch (code) {
  case SWIG_DivisionByZero:
    exception_code = SWIG_OCamlArithmeticException;
    break;
  case SWIG_IndexError:
    exception_code = SWIG_OCamlIndexOutOfBoundsException;
    break;
  case SWIG_IOError:
  case SWIG_SystemError:
    exception_code = SWIG_OCamlSystemException;
    break;
  case SWIG_MemoryError:
    exception_code = SWIG_OCamlOutOfMemoryError;
    break;
  case SWIG_OverflowError:
    exception_code = SWIG_OCamlOverflowException;
    break;
  case SWIG_RuntimeError:
    exception_code = SWIG_OCamlRuntimeException;
    break;
  case SWIG_SyntaxError:
  case SWIG_TypeError:
  case SWIG_ValueError:
    exception_code = SWIG_OCamlIllegalArgumentException;
    break;
  case SWIG_UnknownError:
  default:
    exception_code = SWIG_OCamlUnknownError;
    break;
  }
  SWIG_OCamlThrowException(exception_code, msg);
  CAMLreturn0;
}
#define SWIG_exception(code, msg) SWIG_OCamlException(code, msg)
%}
#endif

#ifdef SWIGCSHARP
%{
SWIGINTERN void SWIG_CSharpException(int code, const char *msg) {
  if (code == SWIG_ValueError) {
    SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
    SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
  } else {
    SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
    switch(code) {
    case SWIG_MemoryError:
      exception_code = SWIG_CSharpOutOfMemoryException;
      break;
    case SWIG_IndexError:
      exception_code = SWIG_CSharpIndexOutOfRangeException;
      break;
    case SWIG_DivisionByZero:
      exception_code = SWIG_CSharpDivideByZeroException;
      break;
    case SWIG_IOError:
      exception_code = SWIG_CSharpIOException;
      break;
    case SWIG_OverflowError:
      exception_code = SWIG_CSharpOverflowException;
      break;
    case SWIG_RuntimeError:
    case SWIG_TypeError:
    case SWIG_SyntaxError:
    case SWIG_SystemError:
    case SWIG_UnknownError:
    default:
      exception_code = SWIG_CSharpApplicationException;
      break;
    }
    SWIG_CSharpSetPendingException(exception_code, msg);
  }
}
%}

#define SWIG_exception(code, msg)\
{ SWIG_CSharpException(code, msg); return $null; }
#endif // SWIGCSHARP

#ifdef SWIGLUA

%{
#define SWIG_exception(a,b)\
{ lua_pushfstring(L,"%s:%s",#a,b);SWIG_fail; }
%}

#endif // SWIGLUA

#ifdef SWIGD
%{
SWIGINTERN void SWIG_DThrowException(int code, const char *msg) {
  SWIG_DExceptionCodes exception_code;
  switch(code) {
  case SWIG_IndexError:
    exception_code = SWIG_DNoSuchElementException;
    break;
  case SWIG_IOError:
    exception_code = SWIG_DIOException;
    break;
  case SWIG_ValueError:
    exception_code = SWIG_DIllegalArgumentException;
    break;
  case SWIG_DivisionByZero:
  case SWIG_MemoryError:
  case SWIG_OverflowError:
  case SWIG_RuntimeError:
  case SWIG_TypeError:
  case SWIG_SyntaxError:
  case SWIG_SystemError:
  case SWIG_UnknownError:
  default:
    exception_code = SWIG_DException;
    break;
  }
  SWIG_DSetPendingException(exception_code, msg);
}
%}

#define SWIG_exception(code, msg)\
{ SWIG_DThrowException(code, msg); return $null; }
#endif // SWIGD

#ifdef __cplusplus
/*
  You can use the SWIG_CATCH_STDEXCEPT macro with the %exception
  directive as follows:

%exception {
    try {
      $action
    }
    catch (my_except& e) {
      ...
    }
    SWIG_CATCH_STDEXCEPT // catch std::exception
    catch (...) {
     SWIG_exception(SWIG_UnknownError, "Unknown exception");
    }
  }
*/
%{
#include <typeinfo>
#include <stdexcept>
%}
%define SWIG_CATCH_STDEXCEPT
  /* catching std::exception  */
  catch (std::invalid_argument& e) {
    SWIG_exception(SWIG_ValueError, e.what() );
  } catch (std::domain_error& e) {
    SWIG_exception(SWIG_ValueError, e.what() );
  } catch (std::overflow_error& e) {
    SWIG_exception(SWIG_OverflowError, e.what() );
  } catch (std::out_of_range& e) {
    SWIG_exception(SWIG_IndexError, e.what() );
  } catch (std::length_error& e) {
    SWIG_exception(SWIG_IndexError, e.what() );
  } catch (std::runtime_error& e) {
    SWIG_exception(SWIG_RuntimeError, e.what() );
  } catch (std::bad_cast& e) {
    SWIG_exception(SWIG_TypeError, e.what() );
  } catch (std::exception& e) {
    SWIG_exception(SWIG_SystemError, e.what() );
  }
%enddef
%define SWIG_CATCH_UNKNOWN
  catch (std::exception& e) {
    SWIG_exception(SWIG_SystemError, e.what() );
  }
  catch (...) {
    SWIG_exception(SWIG_UnknownError, "unknown exception");
  }
%enddef

/* rethrow the unknown exception */

#if defined(SWIGCSHARP) || defined(SWIGD)
%typemap(throws,noblock=1, canthrow=1) (...) {
  SWIG_exception(SWIG_RuntimeError,"unknown exception");
}
#else
%typemap(throws,noblock=1) (...) {
  SWIG_exception(SWIG_RuntimeError,"unknown exception");
}
#endif

#endif /* __cplusplus */

/* exception.i ends here */

${this.title}

Code Editor : exception.i