summaryrefslogtreecommitdiff
path: root/qmake/tools/qlibrary.cpp
authorkergoth <kergoth>2002-11-01 00:10:42 (UTC)
committer kergoth <kergoth>2002-11-01 00:10:42 (UTC)
commit5042e3cf0d3514552769e441f5aad590c8eaf967 (patch) (side-by-side diff)
tree4a5ea45f3519d981a172ab5275bf38c6fa778dec /qmake/tools/qlibrary.cpp
parent108c1c753e74e989cc13923086996791428c9af4 (diff)
downloadopie-5042e3cf0d3514552769e441f5aad590c8eaf967.zip
opie-5042e3cf0d3514552769e441f5aad590c8eaf967.tar.gz
opie-5042e3cf0d3514552769e441f5aad590c8eaf967.tar.bz2
Adding qmake in preperation for new build system
Diffstat (limited to 'qmake/tools/qlibrary.cpp') (more/less context) (ignore whitespace changes)
-rw-r--r--qmake/tools/qlibrary.cpp343
1 files changed, 343 insertions, 0 deletions
diff --git a/qmake/tools/qlibrary.cpp b/qmake/tools/qlibrary.cpp
new file mode 100644
index 0000000..564db30
--- a/dev/null
+++ b/qmake/tools/qlibrary.cpp
@@ -0,0 +1,343 @@
+/****************************************************************************
+** $Id$
+**
+** Implementation of QLibrary class
+**
+** Created : 2000-01-01
+**
+** Copyright (C) 2000-2002 Trolltech AS. All rights reserved.
+**
+** This file is part of the tools module of the Qt GUI Toolkit.
+**
+** This file may be distributed under the terms of the Q Public License
+** as defined by Trolltech AS of Norway and appearing in the file
+** LICENSE.QPL included in the packaging of this file.
+**
+** This file may be distributed and/or modified under the terms of the
+** GNU General Public License version 2 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.
+**
+** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
+** licenses may use this file in accordance with the Qt Commercial License
+** Agreement provided with the Software.
+**
+** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+**
+** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
+** information about Qt Commercial License Agreements.
+** See http://www.trolltech.com/qpl/ for QPL licensing information.
+** See http://www.trolltech.com/gpl/ for GPL licensing information.
+**
+** Contact info@trolltech.com if any conditions of this licensing are
+** not clear to you.
+**
+**********************************************************************/
+
+#include "qplatformdefs.h"
+#include <private/qlibrary_p.h>
+
+#ifndef QT_NO_LIBRARY
+
+// uncomment this to get error messages
+//#define QT_DEBUG_COMPONENT 1
+// uncomment this to get error and success messages
+//#define QT_DEBUG_COMPONENT 2
+
+#ifndef QT_DEBUG_COMPONENT
+# if defined(QT_DEBUG)
+# define QT_DEBUG_COMPONENT 1
+# endif
+#endif
+
+#if defined(QT_DEBUG_COMPONENT)
+#include <qfile.h>
+#endif
+
+#if defined(Q_WS_WIN) && !defined(QT_MAKEDLL)
+#define QT_NO_LIBRARY_UNLOAD
+#endif
+
+QLibraryPrivate::QLibraryPrivate( QLibrary *lib )
+ : pHnd( 0 ), library( lib )
+{
+}
+
+
+/*!
+ \class QLibrary qlibrary.h
+ \reentrant
+ \brief The QLibrary class provides a wrapper for handling shared libraries.
+
+ \mainclass
+ \group plugins
+
+ An instance of a QLibrary object can handle a single shared
+ library and provide access to the functionality in the library in
+ a platform independent way. If the library is a component server,
+ QLibrary provides access to the exported component and can
+ directly query this component for interfaces.
+
+ QLibrary ensures that the shared library is loaded and stays in
+ memory whilst it is in use. QLibrary can also unload the library
+ on destruction and release unused resources.
+
+ A typical use of QLibrary is to resolve an exported symbol in a
+ shared object, and to call the function that this symbol
+ represents. This is called "explicit linking" in contrast to
+ "implicit linking", which is done by the link step in the build
+ process when linking an executable against a library.
+
+ The following code snippet loads a library, resolves the symbol
+ "mysymbol", and calls the function if everything succeeded. If
+ something went wrong, e.g. the library file does not exist or the
+ symbol is not defined, the function pointer will be 0 and won't be
+ called. When the QLibrary object is destroyed the library will be
+ unloaded, making all references to memory allocated in the library
+ invalid.
+
+ \code
+ typedef void (*MyPrototype)();
+ MyPrototype myFunction;
+
+ QLibrary myLib( "mylib" );
+ myFunction = (MyProtoype) myLib.resolve( "mysymbol" );
+ if ( myFunction ) {
+ myFunction();
+ }
+ \endcode
+*/
+
+/*!
+ Creates a QLibrary object for the shared library \a filename. The
+ library will be unloaded in the destructor.
+
+ Note that \a filename does not need to include the (platform specific)
+ file extension, so calling
+ \code
+ QLibrary lib( "mylib" );
+ \endcode
+ is equivalent to calling
+ \code
+ QLibrary lib( "mylib.dll" );
+ \endcode
+ on Windows, and
+ \code
+ QLibrary lib( "libmylib.so" );
+ \endcode
+ on Unix. Specifying the extension is not recommended, since
+ doing so introduces a platform dependency.
+
+ If \a filename does not include a path, the library loader will
+ look for the file in the platform specific search paths.
+
+ \sa load() unload(), setAutoUnload()
+*/
+QLibrary::QLibrary( const QString& filename )
+ : libfile( filename ), aunload( TRUE )
+{
+ libfile.replace( '\\', '/' );
+ d = new QLibraryPrivate( this );
+}
+
+/*!
+ Deletes the QLibrary object.
+
+ The library will be unloaded if autoUnload() is TRUE (the
+ default), otherwise it stays in memory until the application
+ exits.
+
+ \sa unload(), setAutoUnload()
+*/
+QLibrary::~QLibrary()
+{
+ if ( autoUnload() )
+ unload();
+
+ delete d;
+}
+
+/*!
+ Returns the address of the exported symbol \a symb. The library is
+ loaded if necessary. The function returns 0 if the symbol could
+ not be resolved or the library could not be loaded.
+
+ \code
+ typedef int (*avgProc)( int, int );
+
+ avgProc avg = (avgProc) library->resolve( "avg" );
+ if ( avg )
+ return avg( 5, 8 );
+ else
+ return -1;
+ \endcode
+
+*/
+void *QLibrary::resolve( const char* symb )
+{
+ if ( !d->pHnd )
+ load();
+ if ( !d->pHnd )
+ return 0;
+
+ void *address = d->resolveSymbol( symb );
+
+ return address;
+}
+
+/*!
+ \overload
+
+ Loads the library \a filename and returns the address of the
+ exported symbol \a symb. Note that like the constructor, \a
+ filename does not need to include the (platform specific) file
+ extension. The library remains loaded until the process exits.
+
+ The function returns 0 if the symbol could not be resolved or the
+ library could not be loaded.
+
+ This function is useful only if you want to resolve a single
+ symbol, e.g. a function pointer from a specific library once:
+
+ \code
+ typedef void (*FunctionType)();
+ static FunctionType *ptrFunction = 0;
+ static bool triedResolve = FALSE;
+ if ( !ptrFunction && !triedResolve )
+ ptrFunction = QLibrary::resolve( "mylib", "mysymb" );
+
+ if ( ptrFunction )
+ ptrFunction();
+ else
+ ...
+ \endcode
+
+ If you want to resolve multiple symbols, use a QLibrary object and
+ call the non-static version of resolve().
+
+ \sa resolve()
+*/
+void *QLibrary::resolve( const QString &filename, const char *symb )
+{
+ QLibrary lib( filename );
+ lib.setAutoUnload( FALSE );
+ return lib.resolve( symb );
+}
+
+/*!
+ Returns TRUE if the library is loaded; otherwise returns FALSE.
+
+ \sa unload()
+*/
+bool QLibrary::isLoaded() const
+{
+ return d->pHnd != 0;
+}
+
+/*!
+ Loads the library. Since resolve() always calls this function
+ before resolving any symbols it is not necessary to call it
+ explicitly. In some situations you might want the library loaded
+ in advance, in which case you would use this function.
+*/
+bool QLibrary::load()
+{
+ return d->loadLibrary();
+}
+
+/*!
+ Unloads the library and returns TRUE if the library could be
+ unloaded; otherwise returns FALSE.
+
+ This function is called by the destructor if autoUnload() is
+ enabled.
+
+ \sa resolve()
+*/
+bool QLibrary::unload()
+{
+ if ( !d->pHnd )
+ return TRUE;
+
+#if !defined(QT_NO_LIBRARY_UNLOAD)
+ if ( !d->freeLibrary() ) {
+# if defined(QT_DEBUG_COMPONENT)
+ qWarning( "%s could not be unloaded", (const char*) QFile::encodeName(library()) );
+# endif
+ return FALSE;
+ }
+
+# if defined(QT_DEBUG_COMPONENT) && QT_DEBUG_COMPONENT == 2
+ qWarning( "%s has been unloaded", (const char*) QFile::encodeName(library()) );
+# endif
+ d->pHnd = 0;
+#endif
+ return TRUE;
+}
+
+/*!
+ Returns TRUE if the library will be automatically unloaded when
+ this wrapper object is destructed; otherwise returns FALSE. The
+ default is TRUE.
+
+ \sa setAutoUnload()
+*/
+bool QLibrary::autoUnload() const
+{
+ return (bool)aunload;
+}
+
+/*!
+ If \a enabled is TRUE (the default), the wrapper object is set to
+ automatically unload the library upon destruction. If \a enabled
+ is FALSE, the wrapper object is not unloaded unless you explicitly
+ call unload().
+
+ \sa autoUnload()
+*/
+void QLibrary::setAutoUnload( bool enabled )
+{
+ aunload = enabled;
+}
+
+/*!
+ Returns the filename of the shared library this QLibrary object
+ handles, including the platform specific file extension.
+
+ For example:
+ \code
+ QLibrary lib( "mylib" );
+ QString str = lib.library();
+ \endcode
+ will set \e str to "mylib.dll" on Windows, and "libmylib.so" on Linux.
+*/
+QString QLibrary::library() const
+{
+ if ( libfile.isEmpty() )
+ return libfile;
+
+ QString filename = libfile;
+
+#if defined(Q_WS_WIN)
+ if ( filename.findRev( '.' ) <= filename.findRev( '/' ) )
+ filename += ".dll";
+#elif defined(Q_OS_MACX)
+ if ( filename.find( ".dylib" ) == -1 )
+ filename += ".dylib";
+#else
+ if ( filename.find( ".so" ) == -1 ) {
+ const int x = filename.findRev( "/" );
+ if ( x != -1 ) {
+ QString path = filename.left( x + 1 );
+ QString file = filename.right( filename.length() - x - 1 );
+ filename = QString( "%1lib%2.so" ).arg( path ).arg( file );
+ } else {
+ filename = QString( "lib%1.so" ).arg( filename );
+ }
+ }
+#endif
+
+ return filename;
+}
+#endif //QT_NO_LIBRARY