Free ansi c software for linux

hash.c is a C hash table with quadratic probing. hash.c is very small and easy to use.
Compile: gcc -c hash.c
This hashtable uses C-strings for keys and quadratic probing instead of linked-list chains. It depends only on ANSI C and so should work anywhere.
API
hash * hash_new ( unsigned int size ) Create new hashtable.
void hash_destroy ( hash *h ) Free hashtable.
int hash_add ( hash *h , const char *key , void *value ) Add key/value pair.
void * hash_get ( hash *h , const char *key ) Return value matching given key.
void * hash_remove ( hash *h , const char *key ) Remove key from table, returing value.
unsigned int hash_size ( hash *h ) Returns total number of keys.
Enhancements:
- This release uses exponentiation instead of xor in hashing.
- It adds a hash_destroy function.

AspeCt-oriented C project implements an aspect-oriented extension to C and offers one possible language design for an aspect-oriented C language.
Main features:
- an aspect-oriented extension to C, aspect-oriented software development for C, and an ACC language design option
- full ANSI-C compliance and gcc source-compatibility;
- compiler and generated code portability;
- seamless Linux, Solaris and Windows support;
- simple integration in existing builds and code transparency through source-to-source transformations;
- an open source license and compiler.
AspeCt-oriented C enables:
- modularization of crosscutting concerns for C-based software;
- research on concern separation tailored to C and imperative programming;
- research on aspect-orientation on C-based systems;
- development of highly customizable and easily configurable software in C;
- development of feature-rich software product lines in C.
Enhancements:
- set()/get() join point and pointcut support was added for global variables, and compiler options were added for manipulating join points.

DParser project is an simple but powerful tool for parsing. You can specify the form of the text to be parsed using a combination of regular expressions and grammar productions.
Because of the parsing technique (technically a scannerless GLR parser based on the Tomita algorithm) there are no restrictions.
The grammar can be ambiguous, right or left recursive, have any number of null productions, and because there is no seperate tokenizer, can include whitespace in terminals and have terminals which are prefixes of other terminals.
DParser handles not just well formed computer languages and data files, but just about any wacky situation that occurs in the real world.
Main features:
- Powerful GLR parsing
- Simple EBNF-style grammars and regular expression terminals
- Priorities and associativities for token and rules
- Built-in error recovery
- Speculative actions (for semantic disambiguation)
- Auto-building of parse tree (optionally)
- Final actions as you go, or on the complete parse tree
- Tree walkers and default actions (multi-pass compilation support)
- Symbol table built for ambiguous parsing
- Partial parses, recursive parsing, parsing starting with any non-terminal
- Whitespace can be specified as a subgrammar
- External (C call interface) tokenizers and external terminal scanners
- Good asymptotically efficiency
- Comes with ANSI-C, Python and Verilog grammars
- Comes with full source
- Portable C for easy compilation and linking
- BSD licence, so you can included it in your application without worrying about licensing
Enhancements:
- Removed call to exec in python interface (Brian Sabbey)
- Fix binary_op_left in python interface (Brian Sabbey)

nobel is a small ANSI C boolean expression parsing library and program for projects that need boolean expression parsing support built in, but bigger tools are overkill in size or options.

OpenSC consists of tools and libraries and a PKCS#11 module to use smart cards and initialize blank smart cards.
OpenSC project supports many commercial smart cards with filesystems, many national ID cards (read only), and some Java Card cards with specific Java Card applets. OpenSC implements the PKCS#15 standard.
Cards initialized with OpenSC can be used (read-only) with other software implementing PKCS#15 standard and vice versa.
National ID Cards
Finnish ID Card FINEID
Swedish Posten eID
Estonian ID Card EstEID
Italian Infocamere
Italian Postecert
Belgian eID
Spanish Ceres
German ID Cards, eHBA, eGK
Taiwan
Smart Cards
Schlumberger/Axalto Cryptoflex
Schlumberger/Axalto Cyberflex
Gemplus GPK
EMV
Siemens CardOS M4
IBM JCOP
Micardo
Oberthur
OpenPGP
Setec Setcos
Giesecke & Devrient Starcos
TCOS based cards (NetKey E4, SignTrust, Smartkey)
USB Tokens
Aladdin eToken Pro
Eutron CryptoIdendity IT-SEC
Schlumberger/Axalto e-gate
Rainbow iKey 3000
Enhancements:
- The wiki export script was updated.
- The configure script now looks for ncurses and termcap.
- Lots of internal functions and variables were made static.
- 0 vs NULL issues were fixed in many places.
- ANSI C style (void) was fixed.
- Variable names used also as glibc functions (such as random) were fixed.
- New code was provided for deleting objects.
- A special hack was added for Firefox.
- Support for Athena APCOS cards was added.
- The piv driver now supports bigger RSA keys too.

GNU libxmi is a C/C++ function library for rasterizing 2-D vector graphics. GNU libxmi can draw 2-D graphical primitives, including wide polygonal lines and circular and elliptical arcs, into a user-supplied matrix of pixels. Sophisticated line styles, such as multicolored dashing patterns, can be specified. There is also support for filling and texturing polygons.

The current version of the libxmi package is version 1.2, released in June 2000. It can be installed on GNU/Linux, FreeBSD, and Unix systems. Since libxmi is written in ANSI C, it should be easy to compile and install on almost any system with a C compiler.

What is libxmi good for?

It can be used as a drop-in rendering module in any application that needs to scan-convert 2-D vector graphics. It is highly customizable. For example, the `pixel datatype can be redefined at compile time. The algorithm used for compositing pixels can be redefined too. By default, libxmi uses the Painters Algorithm (a new pixel value replaces an old one). But it would be trivial to install it so that it uses alpha compositing instead. The package, and its header file xmi.h, include full documentation.

hamsterdb is a database engine written in ANSI C. hamsterdb supports a B+Tree index structure, uses memory mapped I/O (if available), and can create in-memory databases.
Main features:
- B+Tree index with variable length keys
- Configurable page size and cache size
- ANSI-C implementation, should be portable on all platforms, also embedded
- Uses memory mapped I/O for fast disk access (but falls back to read/write if mmap is not available)
- Uses 64bit file pointers
- Endian-independent (not tested, though)
- Support for in-memory-databases
Enhancements:
- This release implements "record number" databases; these databases behave like "auto-increment" tables in SQL.
- The keys of new records are automatically assigned and incremented with each insert.
- Also, a few minor bugs were fixed, and some optimizations took place; the generated database files are much smaller now.

XFA library implements an API that can be used to create NFA (either programmatically or from regular expressions) and to convert them in the minimal equivalent DFA.

XFA library requires an ANSI C compiler, and this makes it portable virtually over every system.

The complexity of the graphs that are treatable with XFA is only limited by the amount of memory available on the machine.

SYNOPSIS:

#include < xfa.h >

xfa_trans_t *xfa_alloc_trans(xfa_system_t *sys, unsigned long const *map, unsigned long flags, xfa_state_t *from, xfa_state_t *to );
void xfa_free_trans(xfa_system_t *sys, xfa_trans_t *trn);
xfa_state_t *xfa_alloc_state(xfa_system_t *sys, int phsize);
void xfa_free_state(xfa_system_t *sys, xfa_state_t *stt, int recurse);
void xfa_free_attr(xfa_system_t *sys, xfa_attr_t *attr);
int xfa_do_once(xfa_system_t *sys, xfa_state_t *stt, int (*dproc) (void *, xfa_system_t *, xfa_state_t *), void *priv);
xfa_state_t *xfa_nfa2dfa(xfa_system_t *sys, xfa_state_t *stt);
int xfa_label_states(xfa_system_t *sys, xfa_state_t *stt, unsigned long *label);
int xfa_dfa_minimize(xfa_system_t *sys, xfa_state_t *stt);
int xfa_re2nfa(xfa_system_t *sys, xfa_state_t **csts, xfa_state_t **cste, unsigned char const **ptr);