Free library software for linux

lib5600x is a library implementing Motorola DSP5600x disassembler. Its an ANSI C link library that should be useful for people writing debuggers, memory monitors etc for DSP5600x chips.

Usage

1. First you call two initialization functions in the library. This step is mandatory:

make_masks();
make_masks2();

You pass nothing and check for no results -- these functions are guaranteed to succeed.

2. Now you have to allocate memory for a structure that will be used for passing data to/from the library. You may do that on the stack

struct disasm_data dis, *d = &dis;

Yes, the pointer will be useful, too. The disasm_data structure is defined in 5600x_disasm.h file. Lets take a closer look:


#define LINE_SIZE 256

struct disasm_data
{
unsigned char *memory;
char line_buf[LINE_SIZE];
char *line_ptr;
char words;
};

First member -- "memory" -- should point to the opcode you want disassembled. IMPORTANT! The library expects it to be a 24-bit word, so if your assembler creates 32-bit words, youll have to make a simple conversion. Take a look at test.c to see how it is done. Whats more, the library may wish to evaluate two words at a time, so you have to account for that -- this is also demonstrated in the example source.

3. After properly setting up disasm_data struct (i.e. "memory" pointer), you call following function:

int disassemble_opcode(struct disasm_data *);

This function takes pointer to the struct youve just prepared as an argument. When it returns, disasm_data structs "line_buf" member contains the disassembled opcode as a string of ASCII characters. "line_ptr" should be of no interest to you (it is merely a internal variable) and "words" holds the number of 24-bit words you should advance your memory pointer by. This variable is also available as a return value of above function. Again, I
shall refer you to the example source.

4. Repeat step 3 until you run out of code to disassemble.

Testing

First, check out the makefile and make sure it contains proper flags and defines for your architecture. Big endian users should add -DBIGENDIAN to CFLAGS (Id appreciate if someone created Autoconf script to avoid such tricks). Following that, type

make
./test example_dsp_binary

and compare the output (visually) with example.a56 which is a source code I used to create example_dsp_binary and which contains all instructions and addressing modes described in DSP56000/DSP56001 Digital Signal Processor Users Manual. You can also diff your output and supplied example.out file to check if there are any differences (there should be none).

FireFoot is library that provides an easy way for C language programmers to connect to Firebird database servers (and provably Interbase). It uses the Firebird/Interbase API.
Library supports:
- Create, delete, connect to Firebird database servers.
- Single transaction management.
- Common or parametrized SQL statement support.
- Support for basic data types and BLOBs.
- User management support.
- Support the backup and restore of databases.
This library exists as an alternative of Firebird/Interbase C language API. It is made in C language, using GLib object model.
- It is planned to be multiplatform, working at least on Linux and Windows. Until now it is only tested on Linux, but shouldnt be a problem to port it to Windows.
FireFoot libary is released under the GNU/GPL version 2 licence.

Multi-Agent Grid Engine library is an experiment aimed to make a programming tool for creation of autonomic systems.

The Linux QoS Library (LQL) provides a GPL licensed, GObject based C API to manipulate the network queueing disciplines, classes and classifiers in the Linux kernel.

LQL does not use the TC command as a back-end. Instead, LQL communicates with the Linux kernel via Netlink sockets the same way TC does.
At the present time, LQL implements a subset of the Linux network QoS features exposed by the TC command.

Hopefully, this will change as the library matures.
In an ideal world TC would be implemented with a high(er) level API like LQL so that new kernel network QoS features would be immediately available to third party applications using the high level library.

Who knows what interesting innovations would have been created around the Linux network QoS features over the last few years if there was an easier API to manipulate them. LQL is an attempt to fill this need.

Queueing disciplines currently supported by LQL:

HTB
PFIFO
SFQ
PFIFOFast
Priomap
DSMark
Netem

Classifiers currently supported by LQL:

U32
Fwmark
TCIndex

The Python Imaging Library (PIL) adds image processing capabilities to your Python interpreter.

This library supports many file formats, and provides powerful image processing and graphics capabilities.

The current free version is PIL 1.1.5, which has been tested with Python 1.5.2 and newer, including 2.3 and 2.5.

Library Accounting System is a Web-based library system for cataloging books, journals, magazines, and newspapers.
Unlike the majority of Web-based systems, it is intended for individual users rather than for institutional use.
Library Accounting System supports loaning and viewing of records, automatic downloading of book information, and call number creation.
Enhancements:
- This release adds the ability to store movie details.

Java GetOpt library implements option parsing and a common online help behaviour, including an XML format for topics, command, and options (which can be queried with --help --xml) and support for online browsing with --help --browse.

Whats New in This Release:

ï¿1⁄2 The getopt library can now choose the pluggable look and feel of an application with a standard option "--plaf".
ï¿1⁄2 A new file of default options (.prefs/default.options) can specify a set of common default options for all programs using the getopt library, such as the PLAF.

Portable Coroutine Library (PCL) implements the low level functionality for coroutines. For a definition of the term coroutine see The Art of Computer Programming by Donald E. Knuth.
Coroutines are a very simple cooperative multitasking environment where the switch from one task to another is done explicitly by a function call. Coroutines are a lot faster than processes or threads switch, since there is no OS kernel involvement for the operation.
Also coroutines require much less OS resources than processes of threads. The idea of writing this library started when I was testing Linux epoll functionality and performance.
I initially started using the coro library by E. Toernig and I found the library very interesting. It was simple and yet powerful. The limitations of the coro library were both non portability and crashes when not used together with certain versions of gcc.
So I decided to write a new library to address the problems aforementioned by also taking portable context switching ideas from the GNU Pth library. This library is easily portable on almost every Unix system and on Windows.
It can use either the ucontext.h functionalities ( getcontext()/makecontest()/swapcontext() ) or the standard longjmp()/setjmp().
Enhancements:
- This release fixes a shared library soname generation error that was missing the library version information.