| /** \file dllfile.hpp . |
| ----------------------------------------------------------------------------- |
| |
| * 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. |
| |
| ----------------------------------------------------------------------------- |
| |
| \brief the class DllProcLoaderFile is used to maintain dynamic link libraries |
| |
| -------------------------------------------------------------------------- */ |
| |
| #ifndef __UIMA_DLLFILE_HPP |
| #define __UIMA_DLLFILE_HPP |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Interface dependencies */ |
| /* ----------------------------------------------------------------------- */ |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Implementation dependencies */ |
| /* ----------------------------------------------------------------------- */ |
| |
| #include "apr_pools.h" |
| #include "apr_dso.h" |
| #include "uima/filename.hpp" |
| |
| #include "uima/exceptions.hpp" |
| #include "uima/msg.h" |
| #include "uima/envvar.hpp" |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Constants */ |
| /* ----------------------------------------------------------------------- */ |
| |
| #define DSOBUFLEN 256 |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Types */ |
| /* ----------------------------------------------------------------------- */ |
| |
| namespace uima { |
| |
| typedef apr_dso_handle_sym_t TyProcedure; |
| |
| } |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Classes */ |
| /* ----------------------------------------------------------------------- */ |
| namespace uima { |
| |
| namespace util { |
| |
| /** |
| * The class <tt> DllProcLoaderFile</tt> is used to load specific procedures |
| * from a DLL (shared library) by their name. |
| * \code |
| typedef void (*MYPROC)(const char *); |
| |
| foo(const uima::util::Filename & crclFilename) |
| { |
| uima::util::DllProcLoaderFile clDll(crclFilename); |
| |
| if(clDll.isValid()) |
| { |
| MYPROC utProc = (MYPROC) clDll.getProcedure("myFunction"); |
| |
| if(utProc) |
| (utProc)("My message"); // call my procedure in DLL |
| else |
| // error handling |
| } |
| } |
| \endcode |
| * The loaded functions may be called as long as the DLL is loaded. Calling |
| * a loaded function after the destructor of <tt> DllProcLoaderFile</tt> has |
| * unloaded the DLL will cause unexpected results. (An application crash |
| * is very likely to happen.) |
| * |
| * <b> NOTE: dropped the Cos Special Requirements for AIX 4.2 and below </b> |
| * |
| */ |
| class DllProcLoaderFile { |
| public: |
| /** @name Constructors */ |
| /*@{*/ |
| /** instantiate a DLL object and load the specified DLL */ |
| DllProcLoaderFile(const Filename & crclFilename); |
| /*@}*/ |
| ~DllProcLoaderFile(void); |
| /** @name Properties */ |
| /*@{*/ |
| /** return TRUE if the DLL was loaded successfully */ |
| bool isValid(void) const { |
| return isLoaded; |
| } |
| /** return a pointer to the specified DLL function or NULL if the specified |
| function cannot be found in this DLL */ |
| TyProcedure getProcedure(const char * cpszProcName); |
| /** map APR error code (status) of last call to a UIMACPP error code. */ |
| TyErrorId getErrorId(void) const; |
| /** map APR error code to a UIMACPP message id */ |
| TyMessageId getErrorMsgId(void) const; |
| |
| /** return a pointer to the error msg (if any) */ |
| const char * getErrorMsg(void) const; |
| /** return the file's filename */ |
| const Filename & getFilename(void) const { |
| return(iv_clFilename); |
| } |
| /** determine whether a file exists for filename on file system */ |
| bool isExistent(void) const { |
| return iv_clFilename.isExistent(); |
| } |
| |
| /*@}*/ |
| protected: |
| /* --- functions --- */ |
| private: |
| apr_dso_handle_t * dsoHandle; |
| apr_pool_t * dsoPool; |
| bool isLoaded; |
| apr_status_t aprError; |
| Filename iv_clFilename; |
| char * dsoBuffer; |
| #ifdef WIN32 |
| apr_status_t aprError2; |
| #endif |
| /* --- functions --- */ |
| /* BASE CONSTRUCTOR NOT SUPPORTED */ |
| DllProcLoaderFile(void); //lint !e1704 |
| /* COPY CONSTRUCTOR NOT SUPPORTED */ |
| DllProcLoaderFile(const DllProcLoaderFile & ); //lint !e1704 |
| /* ASSIGNMENT OPERATOR NOT SUPPORTED */ |
| DllProcLoaderFile & operator=(const DllProcLoaderFile & crclObject); |
| } |
| ; /* DllProcLoaderFile */ |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Globals */ |
| /* ----------------------------------------------------------------------- */ |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Function declarations */ |
| /* ----------------------------------------------------------------------- */ |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Macro definitions */ |
| /* ----------------------------------------------------------------------- */ |
| |
| #ifdef _MSC_VER |
| # define DSO_EXTN ".dll" |
| #else |
| # ifdef __APPLE__ |
| # define DSO_EXTN ".dylib" |
| # else |
| # define DSO_EXTN ".so" |
| # endif |
| #endif |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Implementation */ |
| /* ----------------------------------------------------------------------- */ |
| |
| inline DllProcLoaderFile::DllProcLoaderFile(const Filename & crclFilename) |
| : iv_clFilename(crclFilename) |
| /* ----------------------------------------------------------------------- */ |
| { |
| isLoaded = FALSE; |
| dsoHandle = NULL; |
| dsoPool = NULL; |
| |
| aprError = apr_pool_create(&dsoPool, NULL); |
| if ( aprError == APR_SUCCESS ) { |
| // Always allocate error buffer as if done in getErrorMsg it loses it's const |
| // and that is expected back in ResourceManager::requestAnnotatorFile |
| dsoBuffer = (char*) apr_palloc ( dsoPool, DSOBUFLEN ); |
| |
| #ifdef _DEBUG |
| #ifdef _WINDOWS |
| // Add "D" to library name |
| char libName[128]; |
| strcpy(libName, iv_clFilename.getName()); |
| strcat(libName, "D"); |
| iv_clFilename.setNewName(libName); |
| #endif |
| #endif |
| // Add the appropriate extension if missing |
| if (! iv_clFilename.isAbsolute() && *iv_clFilename.getExtension() == '\0' ) |
| iv_clFilename.setNewExtension(DSO_EXTN); |
| aprError = apr_dso_load(&dsoHandle, iv_clFilename.getAsCString(), dsoPool); |
| isLoaded = ( aprError == APR_SUCCESS ); |
| |
| #ifdef WIN32 |
| // WIN32: LoadLibraryEx falsely reports ERROR_MOD_NOT_FOUND when the dll cannot be loaded. |
| // APR should use DONT_RESOLVE_DLL_REFERENCES to check if ERROR_INVALID_DLL is a better rc. |
| // Can check for missing case but not for damaged vs. missing library. |
| aprError2 = APR_SUCCESS; |
| if ( !isLoaded ) { |
| if ( APR_TO_OS_ERROR(aprError) == ERROR_MOD_NOT_FOUND ) { |
| if ( ! iv_clFilename.isExistent() ) { // Not in cur dir |
| util::EnvironmentVariableQueryOnly clEnvVarSearchPaths("PATH"); |
| if ( !iv_clFilename.determinePath( clEnvVarSearchPaths.getValue() ) ) { |
| return; // Definitely missing |
| } |
| } |
| // Exists, so must be damaged ... change error code |
| aprError = APR_FROM_OS_ERROR(ERROR_INVALID_DLL); |
| aprError2 = aprError; |
| } |
| } |
| #endif |
| } else { |
| UIMA_EXC_THROW_NEW(ExcOutOfMemory, |
| UIMA_ERR_ENGINE_OUT_OF_MEMORY, |
| UIMA_MSG_ID_EXC_OUT_OF_MEMORY, |
| ErrorMessage(UIMA_MSG_ID_EXCON_CREATING_POOL_FOR_CLASS, |
| "uima::util::DllProcLoaderFile"), |
| ErrorInfo::unrecoverable); |
| } |
| |
| } |
| |
| inline DllProcLoaderFile::~DllProcLoaderFile(void) |
| /* ----------------------------------------------------------------------- */ |
| { |
| if ( dsoHandle != NULL ) { |
| apr_dso_unload ( dsoHandle ); |
| dsoHandle = NULL; |
| } |
| if ( dsoPool != NULL ) |
| apr_pool_destroy ( dsoPool ); |
| isLoaded = FALSE; |
| } |
| |
| inline TyProcedure DllProcLoaderFile::getProcedure(const char * cpszProcName) |
| /* ----------------------------------------------------------------------- */ |
| { |
| apr_dso_handle_sym_t procAddr = NULL; |
| if (isLoaded) { |
| aprError = apr_dso_sym(&procAddr, dsoHandle, cpszProcName); |
| if (aprError == APR_SUCCESS) |
| return (TyProcedure) procAddr; |
| } |
| return NULL; |
| } |
| |
| inline const char * DllProcLoaderFile::getErrorMsg(void) const |
| /* ----------------------------------------------------------------------- */ |
| { |
| if ( dsoHandle == NULL ) |
| return NULL; |
| else { |
| #ifdef WIN32 |
| if ( aprError == aprError2 ) |
| return apr_strerror ( aprError2, dsoBuffer, DSOBUFLEN ); |
| #endif |
| return apr_dso_error ( dsoHandle, dsoBuffer, DSOBUFLEN ); |
| } |
| |
| } |
| |
| inline TyErrorId DllProcLoaderFile::getErrorId(void) const |
| /* ----------------------------------------------------------------------- */ |
| { |
| if (aprError == APR_SUCCESS) { |
| return UIMA_ERR_NONE; |
| } |
| #ifdef WIN32 |
| if (APR_TO_OS_ERROR(aprError) == ERROR_MOD_NOT_FOUND) { |
| return UIMA_ERR_ANNOTATOR_COULD_NOT_FIND; |
| } |
| #else |
| if (APR_TO_OS_ERROR(aprError) == ENOENT) { |
| return UIMA_ERR_ANNOTATOR_COULD_NOT_FIND; |
| } |
| #endif |
| return UIMA_ERR_ANNOTATOR_COULD_NOT_LOAD; |
| } |
| |
| inline TyMessageId DllProcLoaderFile::getErrorMsgId(void) const |
| /* ----------------------------------------------------------------------- */ |
| { |
| if (aprError == APR_SUCCESS) { |
| return UIMA_ERR_NONE; |
| } |
| #ifdef WIN32 |
| if (APR_TO_OS_ERROR(aprError) == ERROR_MOD_NOT_FOUND) { |
| return UIMA_MSG_ID_ANNOTATOR_COULD_NOT_FIND; |
| } |
| #endif |
| return UIMA_MSG_ID_ANNOTATOR_COULD_NOT_LOAD; |
| } |
| |
| } // namespace util |
| } // namespace uima |
| |
| #endif /* __UIMA_DLLFILE_HPP */ |
| |
| /* <EOF> */ |
