| /* |
| ------------------------------------------------------------------------------- |
| |
| * 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. |
| |
| ------------------------------------------------------------------------------- |
| |
| |
| ------------------------------------------------------------------------------- |
| */ |
| |
| #if defined(_MSC_VER) |
| #include <stdio.h> |
| #include <eh.h> |
| #include <windows.h> |
| #include <winbase.h> |
| #endif |
| |
| #include "uima/pragmas.hpp" //must be included first to disable warnings |
| #include "uima/msg.h" |
| #include <string> |
| #include <sstream> |
| |
| #include "uima/macros.h" |
| #include "uima/trace.hpp" |
| |
| #include "uima/strconvert.hpp" |
| #include "uima/unistrref.hpp" |
| #include "uima/comp_ids.h" |
| #include "uima/exceptions.hpp" |
| #include "uima/msgstrtab.h" |
| |
| using namespace std; |
| |
| namespace uima { |
| |
| ///Constructor with just the message id |
| ErrorMessage::ErrorMessage( |
| TyMessageId utMsgId |
| ) : |
| iv_utMsgId(utMsgId) { |
| if ( iv_utMsgId == 0) { |
| iv_utMsgId = UIMA_MSG_ID_NO_MESSAGE_AVAILABLE; |
| } |
| } |
| ///Constructor with a single char * parameter |
| ErrorMessage::ErrorMessage( |
| TyMessageId utMsgId, |
| const char * cpszParam1 |
| ) : |
| iv_utMsgId(utMsgId) { |
| assert( iv_utMsgId != 0 ); |
| iv_vecParams.push_back((string)cpszParam1); |
| } |
| |
| ///Constructor with a single string parameter |
| ErrorMessage::ErrorMessage( |
| TyMessageId utMsgId, |
| const string & crstrParam1 |
| ) : |
| iv_utMsgId(utMsgId) { |
| assert( iv_utMsgId != 0 ); |
| iv_vecParams.push_back(crstrParam1); |
| } |
| |
| ///Constructor with a single UChar * parameter |
| ErrorMessage::ErrorMessage( |
| TyMessageId utMsgId, |
| const UChar * cpuszParam1 |
| ) : |
| iv_utMsgId(utMsgId) { |
| assert( iv_utMsgId != 0 ); |
| string s; |
| UnicodeStringRef(cpuszParam1).extract(s); // Convert to default encoding for platform |
| iv_vecParams.push_back(s); |
| } |
| |
| ///Constructor with a single UnicodeString parameter |
| ErrorMessage::ErrorMessage( |
| TyMessageId utMsgId, |
| const icu::UnicodeString & crustrParam1 |
| ) : |
| iv_utMsgId(utMsgId) { |
| assert( iv_utMsgId != 0 ); |
| string s; |
| UnicodeStringRef(crustrParam1).extract(s); // Convert to default encoding for platform |
| iv_vecParams.push_back(s); |
| } |
| |
| ///Constructor with a single int parameter |
| ErrorMessage::ErrorMessage( |
| TyMessageId utMsgId, |
| int iParam1 |
| ) : |
| iv_utMsgId(utMsgId) { |
| assert( iv_utMsgId != 0 ); |
| string s; |
| iv_vecParams.push_back(long2String(iParam1, s)); |
| } |
| |
| ///Constructor with a single unsigned int parameter |
| ErrorMessage::ErrorMessage( |
| TyMessageId utMsgId, |
| unsigned int uiParam1 |
| ) : |
| iv_utMsgId(utMsgId) { |
| assert( iv_utMsgId != 0 ); |
| string s; |
| iv_vecParams.push_back(long2String((int) uiParam1, s)); |
| } |
| |
| |
| ///Constructor with a single long parameter |
| ErrorMessage::ErrorMessage( |
| TyMessageId utMsgId, |
| long lParam1 |
| ) : |
| iv_utMsgId(utMsgId) { |
| assert( iv_utMsgId != 0 ); |
| string s; |
| iv_vecParams.push_back(long2String(lParam1, s)); |
| } |
| |
| ///Constructor with a single unsigned long parameter |
| ErrorMessage::ErrorMessage( |
| TyMessageId utMsgId, |
| unsigned long ulParam1 |
| ) : |
| iv_utMsgId(utMsgId) { |
| assert( iv_utMsgId != 0 ); |
| string s; |
| iv_vecParams.push_back(long2String((long) ulParam1, s)); |
| } |
| |
| ///Constructor with a single double parameter |
| ErrorMessage::ErrorMessage( |
| TyMessageId utMsgId, |
| const double dParam1 |
| ) : |
| iv_utMsgId(utMsgId) { |
| assert( iv_utMsgId != 0 ); |
| string s; |
| iv_vecParams.push_back(double2String(dParam1, s)); |
| } |
| |
| ///Constructor with a full parameter vector |
| ErrorMessage::ErrorMessage( |
| TyMessageId utMsgId, |
| const vector<string> & crvecParams |
| ) : |
| iv_utMsgId(utMsgId), |
| iv_vecParams(crvecParams) { |
| assert( iv_utMsgId != 0 ); |
| } |
| |
| |
| /*------------------------------- Constructors -------------------------------*/ |
| |
| ErrorContext::ErrorContext( |
| const ErrorMessage & crclMessage, |
| const char* pszFilename, |
| const char* pszFunction, |
| unsigned long ulLineNumber |
| ): |
| iv_clMessage(crclMessage), |
| iv_pszFilename(pszFilename), |
| iv_pszFunction(pszFunction), |
| iv_ulLineNo(ulLineNumber) {} |
| |
| #ifdef OS_STL |
| Exception::~Exception() |
| #else |
| Exception::~Exception() UIMA_THROW0() |
| #endif |
| {} |
| |
| /*------------------------------ Output Support ------------------------------*/ |
| |
| string |
| ErrorMessage::asString() const { |
| |
| size_t numparams = getMessageParams().size(); |
| |
| // Check for unknown message id |
| if (iv_utMsgId < 0 || iv_utMsgId > UIMA_MSG_ID_SIGNATURE_END) { |
| return string("Unknown message id " + iv_utMsgId); |
| } |
| |
| //parameter substitution |
| |
| //locate message in message table |
| const TCHAR ** messages = gs_aszMessageStringTable; |
| const TCHAR * msg = messages[iv_utMsgId]; |
| |
| TCHAR * buf = new TCHAR[UIMA_MSG_MAX_STR_LEN]; |
| memset(buf,'\0',UIMA_MSG_MAX_STR_LEN); |
| |
| int numwritten=0; |
| |
| TCHAR * trg = buf; |
| while (*msg) { |
| if (numwritten > UIMA_MSG_MAX_STR_LEN) { |
| break; |
| } |
| if (*msg == UIMA_MSG_REPLACE_CHAR) { |
| msg = msg+1; |
| if (*msg == UIMA_MSG_REPLACE_CHAR) { |
| *trg = *msg; |
| trg = trg +1; |
| ; |
| msg = msg+1; |
| numwritten++; |
| } else { //replace %n with the corresponding param |
| unsigned long index; |
| int len; |
| string arg; |
| // determine the number of the specified argument ... |
| index = (unsigned long) atol(msg); |
| if (index > numparams) // param not defined |
| { |
| arg = "???"; // replace it by "dont-know" |
| } else { |
| // ... the indexed argument ... |
| arg = iv_vecParams[index - 1]; // zero-based array! |
| //assert(arg.length() > 0); |
| } |
| len = arg.length(); |
| // ... and then copy the argument |
| if (UIMA_MSG_MAX_STR_LEN-numwritten < len) { |
| len = UIMA_MSG_MAX_STR_LEN - numwritten; |
| } |
| if (len > 0) { |
| strncpy(trg, arg.c_str(), len); |
| trg = trg+len; |
| } |
| msg = msg+1; |
| while ( isdigit(*msg) ) { //handle arg number 10 or more |
| msg = msg+1; |
| } |
| } |
| } else { |
| *trg = *msg; |
| trg = trg+1; |
| msg = msg+1; |
| } |
| } |
| //cout << buf << endl; |
| string target(buf); |
| delete[] buf ; |
| return target; |
| //string target; |
| //target.assign(buf, UIMA_MSG_MAX_STR_LEN); // Copy the result to the string |
| //delete buf; |
| //return target; |
| } |
| |
| ostream & |
| operator << ( |
| ostream & os, |
| const ErrorMessage & errorMsg |
| ) { |
| os << errorMsg.asString(); |
| return(os); |
| } |
| |
| string |
| ErrorContext::asString() const { |
| string s; |
| s += getMessage().asString(); |
| if (getFileName() != NULL) { |
| s += string("\n") + ErrorInfo::getGlobalErrorInfoIndent() + " File : " + getFileName(); |
| } |
| if (getFunctionName() != NULL) { |
| s += string("\n") + ErrorInfo::getGlobalErrorInfoIndent() + " Function : " + getFunctionName(); |
| } |
| if (getLineNumber() != 0) { |
| string sNum; |
| long2String(getLineNumber(), sNum); |
| s += string("\n") + ErrorInfo::getGlobalErrorInfoIndent() + " Line : " + sNum; |
| } |
| |
| return(s); |
| } |
| |
| ostream & |
| operator << ( |
| ostream & os, |
| const ErrorContext & errContext |
| ) { |
| os << errContext.asString(); |
| return (os); |
| } |
| |
| void ErrorMessage::reset(void) { |
| iv_utMsgId = UIMA_MSG_ID_NO_MESSAGE_AVAILABLE; |
| iv_vecParams.clear(); |
| } |
| |
| /* ----------------------------------------------------------------------- */ |
| /* ErrorInfo */ |
| /* ----------------------------------------------------------------------- */ |
| |
| /*------------------------------- Statics -----------------------------------*/ |
| //initialize static member var to an initial value |
| |
| const char * ErrorInfo::cv_cpszContextPrefix = " While : "; |
| const char * ErrorInfo::cv_cpszIndent = ""; |
| |
| |
| /*------------------------------- Constructors -------------------------------*/ |
| |
| ErrorInfo::ErrorInfo( |
| const ErrorMessage & rclMessage, |
| TyErrorId ulErrorId, |
| ErrorInfo::EnSeverity enSeverity |
| ) : |
| iv_clErrorMsg(rclMessage), |
| iv_ulErrorId(ulErrorId), |
| iv_enSeverity(enSeverity), |
| iv_vecContexts() {} |
| |
| ErrorInfo::ErrorInfo( void ) : |
| iv_clErrorMsg(), |
| iv_ulErrorId(UIMA_ERR_NONE), |
| iv_enSeverity(recoverable), |
| iv_vecContexts() {} |
| |
| ErrorInfo::~ErrorInfo() {} |
| |
| //constructor (copy) |
| //? Exception::Exception( |
| //? const Exception& rclException |
| //? ) |
| //? { |
| //? } |
| |
| /*---------------------------- Exception Context ----------------------------*/ |
| void |
| ErrorInfo::addContext( const ErrorContext & crclContext ) { |
| iv_vecContexts.push_back(crclContext); |
| } |
| |
| const ErrorContext * |
| ErrorInfo::contextPtrAtIndex( size_t uiContextIndex ) const { |
| if (uiContextIndex >= iv_vecContexts.size()) { |
| return(NULL); |
| } |
| return(&iv_vecContexts[uiContextIndex]); |
| } |
| |
| /*------------------------------ Output Support ------------------------------*/ |
| string |
| ErrorInfo::asString() const { |
| string s; |
| if (getErrorId() == UIMA_ERR_NONE) { |
| s += string("No Error\n"); |
| return (s); |
| } |
| if (getErrorId() != UIMA_ERR_NONE) { |
| s += string("\n") + ErrorInfo::getGlobalErrorInfoIndent() + "Error number : "; |
| string sErr; |
| long2String( getErrorId(), sErr); |
| s += sErr; |
| } |
| s += string("\n") + ErrorInfo::getGlobalErrorInfoIndent() + "Recoverable : " + (isRecoverable() ? "Yes" : "No"); |
| s += string("\n") + ErrorInfo::getGlobalErrorInfoIndent() + "Error : " + getMessage().asString(); |
| for (size_t i = 0; i < contextCount(); ++i) { |
| s += string("\n") + ErrorInfo::getGlobalErrorInfoIndent() + ErrorInfo::getGlobalErrorInfoContextPrefix(); |
| assert(EXISTS(contextPtrAtIndex(i))); //lint !e666: Expression with side effects passed to repeated parameter 1 in macro EXISTS |
| s += contextPtrAtIndex(i)->asString(); |
| } |
| s += string("\n"); |
| |
| return (s); |
| } |
| |
| ///output support for streams |
| ostream & |
| operator << ( |
| ostream & os, |
| const ErrorInfo & errInfo |
| ) { |
| os << errInfo.asString(); |
| return(os); |
| } |
| |
| void ErrorInfo::reset(void) { |
| iv_clErrorMsg.reset(); |
| iv_ulErrorId = UIMA_ERR_NONE; |
| iv_enSeverity = recoverable; |
| iv_vecContexts.clear(); |
| } |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Exception */ |
| /* ----------------------------------------------------------------------- */ |
| |
| Exception::Exception( |
| const ErrorMessage & rclMessage, |
| TyErrorId ulErrorId, |
| ErrorInfo::EnSeverity enSeverity |
| ) : |
| EXCEPTION_BASE_CLASS(), |
| iv_clErrorInfo(rclMessage, ulErrorId, enSeverity) {} |
| |
| Exception::Exception( |
| const ErrorInfo & crclErrorInfo |
| ) : |
| EXCEPTION_BASE_CLASS(), |
| iv_clErrorInfo(crclErrorInfo) {} |
| |
| /*------------------------------ Exception Type ------------------------------*/ |
| |
| const char * Exception::getName() const { |
| return(_TEXT("unspecified exception")); |
| } |
| |
| /*------------------------- Application Termination --------------------------*/ |
| void Exception::terminate() { |
| exit(iv_clErrorInfo.getErrorId()); //lint !e713: Loss of precision (arg. no. 1) (unsigned long to int) |
| } |
| |
| /*------------------------------ Throw Support -------------------------------*/ |
| void Exception::assertParameter( |
| const char* /*exceptionText*/, |
| ErrorContext /*context*/ ) { |
| assert(false); |
| //not tested yet (and not used anywhere!) |
| } |
| |
| /*------------------------- Logging Support ----------------------------------*/ |
| |
| void Exception::logExceptionData() { |
| util::Trace clTrace(util::enTraceDetailLow, UIMA_TRACE_ORIGIN, UIMA_TRACE_COMPID_EXCEPTIONS); |
| |
| clTrace.dump(_TEXT("Exception occured"), asString().c_str()); |
| //not implemented yet |
| } |
| |
| /*------------------------------ Output Support ------------------------------*/ |
| string |
| Exception::asString() const { |
| //output the (class) name of the exception and its error info after it. |
| return string("\n") + |
| ErrorInfo::getGlobalErrorInfoIndent() + |
| "Exception : " + |
| getName() + |
| "\n" + |
| getErrorInfo().asString() + |
| "\n"; |
| } |
| |
| |
| |
| ostream & |
| operator << ( |
| ostream & os, |
| const Exception & exception |
| ) { |
| //output the (class) name of the exception and its error info after it. |
| os << exception.asString(); |
| return(os); |
| } |
| |
| /*------------------------------ Static Method -------------------------------*/ |
| |
| // Release contents of string container allocated by asString method |
| |
| void |
| Exception::release(std::string & msg) { |
| msg.clear(); // Empty string |
| msg.reserve(1); // Reduce capacity so will use internal buffer & free external one |
| } |
| |
| //private: |
| /*----------------------------- Hidden Functions -----------------------------*/ |
| Exception& Exception::operator=( const Exception& /*exc*/ ) { |
| assert(false); |
| return(*this); //lint !e527 unreachable |
| } //lint !e1745: member not assigned by private assignment operator |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Implementations of predefined exceptions */ |
| /* ----------------------------------------------------------------------- */ |
| |
| |
| /* |
| The following classes reimplement the ANSI standard exception hierarchy from |
| stdexcept.h as UIMACPP exceptions with context and message id support |
| */ |
| UIMA_EXC_CLASSIMPLEMENT(Uima_logic_error ,Exception); |
| UIMA_EXC_CLASSIMPLEMENT(Uima_runtime_error ,Exception); |
| |
| UIMA_EXC_CLASSIMPLEMENT(Uima_domain_error ,Uima_logic_error); |
| UIMA_EXC_CLASSIMPLEMENT(Uima_invalid_argument ,Uima_logic_error); |
| UIMA_EXC_CLASSIMPLEMENT(Uima_length_error ,Uima_logic_error); |
| UIMA_EXC_CLASSIMPLEMENT(Uima_out_of_range ,Uima_logic_error); |
| |
| UIMA_EXC_CLASSIMPLEMENT(Uima_range_error ,Uima_runtime_error); |
| UIMA_EXC_CLASSIMPLEMENT(Uima_overflow_error ,Uima_runtime_error); |
| UIMA_EXC_CLASSIMPLEMENT(Uima_underflow_error ,Uima_runtime_error); |
| |
| |
| /** |
| The following exceptions are used by helper test classes that are no longer in the UIMACPP library: |
| CommandLineDriver DocBuffer ParseHandlers |
| */ |
| UIMA_EXC_CLASSIMPLEMENT(ConsoleAbortExc ,Exception); |
| UIMA_EXC_CLASSIMPLEMENT(ParseHandlerExc ,Exception); |
| UIMA_EXC_CLASSIMPLEMENT(ExcDocBuffer ,Uima_out_of_range); |
| |
| /** code page conversion errors */ |
| UIMA_EXC_CLASSIMPLEMENT(CodePageConversionException, uima::Exception); |
| /** |
| The following exception is used to report failures from APR functions |
| */ |
| UIMA_EXC_CLASSIMPLEMENT(AprFailureException, Exception); |
| |
| /* |
| The following classes provide a starting point for an exception hierarchy |
| */ |
| //? UIMA_EXC_CLASSIMPLEMENT(ExcAssertionFailure, Exception); |
| UIMA_EXC_CLASSIMPLEMENT(ExcIllFormedInputError , Uima_runtime_error); |
| UIMA_EXC_CLASSIMPLEMENT(ExcInvalidParameter , Uima_invalid_argument); |
| UIMA_EXC_CLASSIMPLEMENT(ExcIndexOutOfRange , Uima_out_of_range); |
| //? UIMA_EXC_CLASSIMPLEMENT(ExcDeviceError ,Uima_runtime_error); |
| UIMA_EXC_CLASSIMPLEMENT(ExcInvalidRequest , Uima_runtime_error); |
| UIMA_EXC_CLASSIMPLEMENT(ExcResourceExhausted , Uima_runtime_error); |
| UIMA_EXC_CLASSIMPLEMENT(ExcOutOfMemory , ExcResourceExhausted); |
| //? UIMA_EXC_CLASSIMPLEMENT(ExcOutOfSystemResource, ResourceExhausted); |
| //? UIMA_EXC_CLASSIMPLEMENT(ExcOutOfWindowResource, ResourceExhausted); |
| UIMA_EXC_CLASSIMPLEMENT(ExcFileNotFoundError , Uima_runtime_error); |
| |
| // Windows specific CException |
| ExcWinCException::ExcWinCException( |
| ErrorMessage clMessage, |
| TyErrorId ulErrorId, |
| ErrorInfo::EnSeverity enSeverity |
| ) |
| : Uima_runtime_error (clMessage, ulErrorId, enSeverity) { |
| ; |
| } |
| |
| const char* |
| ExcWinCException :: getName() const { |
| return( "ExcWinCException" ); |
| } |
| |
| ExcWinCException::~ExcWinCException () CHILD_DESTRUCT_THROW0() { |
| ; |
| } |
| |
| ExcWinCException::ExcWinCException (const ExcWinCException & a) : Uima_runtime_error (a) { |
| ; |
| } |
| |
| |
| // Windows exceptions can be mapped only when compiled with MS VC++ |
| #if defined(_MSC_VER) |
| |
| void translation_func( unsigned int u, _EXCEPTION_POINTERS* pExp ) { |
| const char * cpszMsg = NULL; |
| switch (u) { |
| case EXCEPTION_ACCESS_VIOLATION: |
| cpszMsg ="\"ACCESS VIOLATION\""; |
| break; |
| case EXCEPTION_DATATYPE_MISALIGNMENT: |
| cpszMsg ="\"DATATYPE MISALIGNMENT\""; |
| break; |
| case EXCEPTION_BREAKPOINT: |
| cpszMsg ="\"BREAKPOINT\""; |
| break; |
| case EXCEPTION_SINGLE_STEP: |
| cpszMsg ="\"SINGLE STEP\""; |
| break; |
| case EXCEPTION_ARRAY_BOUNDS_EXCEEDED: |
| cpszMsg ="\"ARRAY BOUNDS EXCEEDED\""; |
| break; |
| case EXCEPTION_FLT_DENORMAL_OPERAND: |
| cpszMsg ="\"FLT DENORMAL OPERAND\""; |
| break; |
| case EXCEPTION_FLT_DIVIDE_BY_ZERO: |
| cpszMsg ="\"FLT DIVIDE_BY ZERO\""; |
| break; |
| case EXCEPTION_FLT_INEXACT_RESULT: |
| cpszMsg ="\"FLT INEXACT_RESULT\""; |
| break; |
| case EXCEPTION_FLT_INVALID_OPERATION: |
| cpszMsg ="\"FLT INVALID OPERATION\""; |
| break; |
| case EXCEPTION_FLT_OVERFLOW: |
| cpszMsg ="\"FLT OVERFLOW\""; |
| break; |
| case EXCEPTION_FLT_STACK_CHECK: |
| cpszMsg ="\"FLT STACK_CHECK\""; |
| break; |
| case EXCEPTION_FLT_UNDERFLOW: |
| cpszMsg ="\"FLT UNDERFLOW\""; |
| break; |
| case EXCEPTION_INT_DIVIDE_BY_ZERO: |
| cpszMsg ="\"INT DIVIDE BY ZERO\""; |
| break; |
| case EXCEPTION_INT_OVERFLOW: |
| cpszMsg ="\"INT OVERFLOW\""; |
| break; |
| case EXCEPTION_PRIV_INSTRUCTION: |
| cpszMsg ="\"PRIV INSTRUCTION\""; |
| break; |
| case EXCEPTION_IN_PAGE_ERROR: |
| cpszMsg ="\"IN PAGE_ERROR\""; |
| break; |
| case EXCEPTION_ILLEGAL_INSTRUCTION: |
| cpszMsg ="\"ILLEGAL INSTRUCTION\""; |
| break; |
| case EXCEPTION_NONCONTINUABLE_EXCEPTION: |
| cpszMsg ="\"NONCONTINUABLE EXCEPTION\""; |
| break; |
| case EXCEPTION_STACK_OVERFLOW: |
| cpszMsg ="\"STACK OVERFLOW\""; |
| break; |
| case EXCEPTION_INVALID_DISPOSITION: |
| cpszMsg ="\"INVALID DISPOSITION\""; |
| break; |
| case EXCEPTION_GUARD_PAGE: |
| cpszMsg ="\"GUARD PAGE\""; |
| break; |
| case EXCEPTION_INVALID_HANDLE: |
| cpszMsg ="\"INVALID HANDLE\""; |
| break; |
| case CONTROL_C_EXIT: |
| cpszMsg ="\"CONTROL C EXIT\""; |
| break; |
| default: |
| cpszMsg = "Unknows Windows C Exception"; |
| break; |
| } |
| // throw our own type of exception so we know at least what was going on |
| // instead of just getting an unknown ... C++ excepition |
| throw ExcWinCException( ErrorMessage(UIMA_MSG_ID_EXC_WINDOWS_EXCEPTION, cpszMsg), |
| (TyErrorId)UIMA_ERR_ENGINE_WINDOWS_EXCEPTION, |
| ErrorInfo::unrecoverable); |
| } |
| |
| #define UIMA_ENVVAR_DONT_MAP_WINDOWS_EXCEPTIONS "UIMA_DONT_MAP_WINDOWS_EXCEPTIONS" |
| |
| // _set_se_translator should be called at the beginning of main |
| // since we have no access to main here, we declare a static var of a dummy |
| // type which does the _set_se_translator call in it's constructor |
| // Note: this only works if the compiler properly executes the ctors of |
| // such static vars in DLLs |
| class Dummy { |
| public: |
| Dummy( void ) { |
| if ( getenv(UIMA_ENVVAR_DONT_MAP_WINDOWS_EXCEPTIONS) == NULL) { |
| _set_se_translator( translation_func ); |
| } |
| } |
| }; |
| // static var of our dummy type |
| Dummy clDummy; |
| #endif |
| |
| } |