Free c s software for linux

C is pronounced large-C and is a pseudo-interpreter of the C programming language.
Without the need of manual compilation, developers can rapidly create cross-platform scripts or write one-liners using the C/C++ programming language that run at native code speed.
Enhancements:
- The -S option was added to show disassembly.

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.

JXTA-C/C++ project is an open source cross-platform C/C++ implementation of the JXTA platform.
The community is committed to a quarterly release cycle. For each release, it is currently built and tested on Solaris/Linux/Windows, MacOS X and BSD are reported to work.
The JXTA platform is an open network computing platform designed for peer-to-peer (P2P) computing. The JXTA platform standardizes the manner in which peers:
- Advertise and discover resources (Peer, PeerGroup, Service and Pipe Advertisements)
- Communicate with each other (Pipes)
- Cooperate with each other to dynamically form peer groups
Enhancements:
- Thread pool support for lower resource usage.
- The jxta_log_callback function prototype has been changed.
- JPR is built as a static library as an integral part of libjxta on Unix platforms.

C++ Sockets is a C++ wrapper for BSD-style sockets.
Main features:
- SSL support
- IPv6 support
- tcp and udp sockets
- encrypted tcp
- http protocol
- highly customizable error handling
Enhancements:
- A fatal bug in LineProtocol/Online when a CRLF happened over a read buffer boundary has been fixed.
- New output buffer logic.
- OnWriteComplete callback has been added, which fires after the output buffer has been transferred.

Env::C is a Get/Set/Unset Environment Variables on the C level.

SYNOPSIS

use Env::C;

my $key = "USER";
$val = Env::C::getenv($key) || ;

Env::C::setenv($key, "foobar", [$override]);
$new_val = Env::C::getenv($key) || ;

Env::C::unsetenv($key);

my $ar_env = Env::C::getallenv();
print join "n", @$ar_env;

This module provides a Perl API for getenv(3), setenv(3) and unsetenv(3). It also can return all the environ variables.

Sometimes Perl invokes modules with underlaying C APIs which rely on certain environment variables to be set, if these variables are set in Perl and the glue code doesnt worry to set them on the C level, these variables might not be seen by the C level. This module shows what really the C level sees.

The Coyotl library defies easy classification much like its namesake. Coyotl collects several C++ tools that have proven useful in many of my programs, but which arent "big enough" to warrant an individual library.
Some of the most significant classes have standalone presentations:
The Twisted Road to Randomness
Genetic algorithms, games, statistical tests, and simulations all rely on "random" numbers. Unfortunately, the built-in "random number" function is inadequate in algorithms where lots, and lots (and lots!) of random values need to be generated. Some of my applications use billions of random numbers in their calculations. In such circumstances, a random number "generator" that produces repetitive or cyclical values is unlikely to produce satisfactory results. This article presents concepts, requirements, and algorithms for generating "random numbers", with a focus on linear congruential and Mersenne Twister algorithms. (Note: This article is undergoing a major revision to reflect new algorithms recently added to libcoyotl.)
Beyond Assert: Validation Tools for Design by Contract
I dont use the assert macro in professional C++ code; instead, I prefer something akin to Bertrand Meyers Design by Contract, albeit with a strong C++ flavor. This article introduces an exception-based validation systems Ive developed for my own projects.
A Maze of Concepts
I began with an idea for an experiment: Use genetic algorithms to evolve searching skills in software organisms; such research is applicable to many applications, including web searching and data mining. Ive puttered about with several such algorithms, and wanted to move to a more complicated environment. This article describes classes for creating, drawing, and persisting 2D mazes in C++.
Enhancements:
- A polymorphic collection of the best psuedorandom number generators, including the Mersenne Twister and Marsaglias favorites.
- Utilities for floating-point numbers, including additional functions for trigonometry, least common multiple, greatest common denominator, rounding, and other purposes.
- A simple cross-platform command-line parser.
- A framework for generating random rectangular mazes.
- A template for fixed-point math based on different integer sizes and decimal point locations.
- Templatized sorting utilities (designed before Std. C++s , but still useful)
- Validation tools for "Design by Contract" programming.
Complete API documentation can be generated with a simple "make docs" command.
A few of the included classes (the array template, for example) could be considered obsolete. I began writing C++ when it was still called "C with Classes", long before the Standard Template Library or projects like Boost. I hesitate to throw away old code, and dont see the sense in replacing working code with something "newer" if the "newer" code isnt also "better".
I have quite a bit of C++ code, from my books and various consulting projects; as time permits, Ill migrate more code into Coyotl.
And one final note: The name of this library changed recently, from "coyote" to "coyotl". The former is a Spanish and English translation of the original Nahuatl word "coyotl". The revised name honors both my favorite song dog and my wifes Central American heritage.

aifc2wav is an aifc (ima4, sowt or sdx2) to wav translator.

I made this little piece of software, because I wanted to listen to some khoomei music (23 Jul 2005: link appears to be dead), and some of those AIFC files were not handled by sox, nor xmms, nor mplayer. Those files were in AIFC IMA4 format.

How to use it?

Unzip the C file with gunzip.

You will need a C compiler (gcc is fine). Simply compile it (for instance gcc -o aifc2wav aifc2wav-4.c), and you are done.

It handles AIFC IMA4 files, AIFC SOWT files and AIFC SDX2 files, both mono and stereo (not sure for SDX2). The SOWT scheme has not been widely tested, if your file sounds strange, contact me. (Same for SDX2.)

It will produce a WAV file. Why WAV? Because WAV files are handled by almost everyone. If you want raw data, you can skip the 44 bytes long header (something like dd if=INPUT_FILE of=OUTPUT_FILE bs=44 skip=1 under unix). Or use sox, which is a good program.

It is supposed to work on any machine, little/big endian. The only problem that might appear is because of this silly 80 bits extended float used by those silly coders. Who needs that much precision for a frequency? Well, so they did, so they did. I dont know if I handle this correctly or not.

C/Invoke is a library for connecting to C libraries at runtime. This differs from the typical method of interfacing with C, which involves writing static definitions which are then compiled to a machine-dependant format. C/Invoke provides a runtime facility to build descriptions of C functions and to call them, passing them appropriate data and retrieving results.
C/Invoke provides a central repository of code to handle the platform-dependant details of marshaling C parameters and return values. Currently C/Invoke has been ported to GCC (GNU/Linux, *BSD) on the x86 and amd64 architectures, Microsoft Windows on x86, and Mac OS X on PowerPC. The development team is interested in adding more ports as they gain access to more diverse hardware.
Audience
The main audience of C/Invoke are users of high-level programming languages who wish to interface with C. At the moment, most languages can be extended with C libraries only by authoring modules in C using language-specific APIs. There are many problems with this approach; writing extension modules requires knowledge of the C language instead of the language the application is being written in, the APIs needed to implement the modules are often involved and complex, and the resulting libraries must be built and maintained on many different platforms.
However, once C/Invoke is integrated into a language, the situation changes dramatically; users of Lua (for example) can interface to C by writing Lua code alone. This means that the advantages of Lua (or other high-level languages) such as portability and ease of use can be combined with the low-level power of C. To call a C function, one merely declares a C prototype in the high-level code, similar to the P/Invoke functionality of Microsofts .NET Framework. A subroutine is then created in the high-level environment which hooks into a proxy generated to correctly call the given C function.
There are two ways to integrate C/Invoke into a language. One is to use the existing extension module interface of the language in the normal manner. This is the preferred method to integrate with a language which is already established and which would be hard to modify, such as Perl, Python, Ruby, Tcl, etc. The other way would be to link C/Invoke directly into the language runtime and make the declarative C services part of the syntax of the language.
The C/Invoke developers are always looking for volunteers to integrate with an existing language, or programming language authors who are interested in using C/Invoke directly.
Enhancements:
- Support for the SPARC architecure was added, and many bugs were fixed in the Lua language binding.