Markus Gerwinski proudly presents:
GNU Application Libraries for Pascal, in short GNUALP, pre-release 0.1.4.
The current status of the package contains units for
- exception handling,
- standard collection types (lists, hashtables etc.),
- system time and calendar functions,
- and last but not least: multithreading.
You can download a tarball with the current sources from
http://www.markus.gerwinski.de/gnualp/gnualp-0.1.4.tar.gz.
The library is tested on SuSE Linux 8.0, 9.1, and Windows XP with MinGW.
You can install the tarball just the usual way, i.e. unpack it into your source
directory, then run "./configure", "make", "make install", and everything will
be in place. The API units will then be installed to a directory named
/usr/local/units/gnualp-0.1. This also generates a shared library,
libgnualp.so, which you'll have to link against. E.g. to compile a program
foo.pas which uses the GNUALP library units, your gpc compiler call will have
to look like this:
gpc --automake --unit-path=/usr/local/units/gnualp-0.1 foo.pas -o foo -lgnualp
This library is work under development and far from being complete, so it is
all undocumented up to now. However, since several folks seemed to have a
pressing urge for multithreading, I'll give a short introduction here on how to
use the resp. features of the library:
- Include `AlpThreads' into the uses clause of your program. Declare any threads
you want to start as vars of type `pThread'.
- To run some simple procedure as a thread, give it a parameter list like this:
Procedure doingSomething ( thread: pThread; data: pointer );
You can then from anywhere in the program create a thread object for this
procedure with the following statement:
someThread:= new ( pSimpleThread, start ( doingSomething, nil ) );
The thread then starts running immediately and will automatically dispose
itself after it is ready. It can be stopped from within the doingSomething
procedure using the command `thread^.stop'. In this case, it will also
dispose itself.
For more sophisticated thread handling, derive an object type from the
abstract tThread type and override the `work' method to do whatever the
thread is supposed to do; if need be, you can also override the `cleanup'
method. This one's always executed at the end of the thread, no matter if it
was regularly ended or `stop'ped in-between.
- Mutexes and semaphores are represented by the tMutex and tSemaphore object
types. To create e.g. a mutex, just call
mutex:= new ( pMutex, init );
To lock the mutex, call `mutex^.lock'; to unlock it, call `mutex^.unlock'.
To dispose it after use, call `dispose ( mutex, fini )'. Just as simple. :-)
Semaphores work in an analogous way; they only require an integer parameter
in their constructor to determine the maximum count of threads they may be
accessed by.
For usage examples, see the files simplethreads.pas, mutexes.pas, and
semaphores.pas in the demos/pas subdirectory of the gnualp package. They aren't
documented or commented either, since I've only set them up as a test for
myself, but I hope the code isn't too difficult to read. :-}
Regards,
Markus
