Free c 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.

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.

B::C is Perl compilers C backend.

SYNOPSIS

perl -MO=C[,OPTIONS] foo.pl

This compiler backend takes Perl source and generates C source code corresponding to the internal structures that perl uses to run your program. When the generated C source is compiled and run, it cuts out the time which perl would have taken to load and parse your program into its internal semi-compiled form. That means that compiling with this backend will not help improve the runtime execution speed of your program but may improve the start-up time. Depending on the environment in which your program runs this may be either a help or a hindrance.

OPTIONS

If there are any non-option arguments, they are taken to be names of objects to be saved (probably doesnt work properly yet). Without extra arguments, it saves the main program.

-ofilename

Output to filename instead of STDOUT

-v

Verbose compilation (currently gives a few compilation statistics).

--

Force end of options

-uPackname

Force apparently unused subs from package Packname to be compiled. This allows programs to use eval "foo()" even when sub foo is never seen to be used at compile time. The down side is that any subs which really are never used also have code generated. This option is necessary, for example, if you have a signal handler foo which you initialise with $SIG{BAR} = "foo". A better fix, though, is just to change it to $SIG{BAR} = &foo. You can have multiple -u options. The compiler tries to figure out which packages may possibly have subs in which need compiling but the current version doesnt do it very well. In particular, it is confused by nested packages (i.e. of the form A::B) where package A does not contain any subs.

-D

Debug options (concatenated or separate flags like perl -D).

-Do

OPs, prints each OP as its processed

-Dc

COPs, prints COPs as processed (incl. file & line num)

-DA

prints AV information on saving

-DC

prints CV information on saving

-DM

prints MAGIC information on saving

-f

Force options/optimisations on or off one at a time. You can explicitly disable an option using -fno-option. All options default to disabled.

-fcog

Copy-on-grow: PVs declared and initialised statically.

-fsave-data

Save package::DATA filehandles ( only available with PerlIO ).

-fppaddr

Optimize the initialization of op_ppaddr.

-fwarn-sv

Optimize the initialization of cop_warnings.

-fuse-script-name

Use the script name instead of the program name as $0.

-fsave-sig-hash

Save compile-time modifications to the %SIG hash.

-On

Optimisation level (n = 0, 1, 2, ...). -O means -O1.

-O0

Disable all optimizations.

-O1

Enable -fcog.

-O2

Enable -fppaddr, -fwarn-sv.

-llimit

Some C compilers impose an arbitrary limit on the length of string constants (e.g. 2048 characters for Microsoft Visual C++). The -llimit options tells the C backend not to generate string literals exceeding that limit.

C++ base is a base class suite contains several powerful c++ base classes for basic encapsulation of low level operating system calls and basic library functions.

Further packages you may access from this page require the installation of this base package

C::Scan is a Perl module that can scan C language files for easily recognized constructs.

SYNOPSIS

$c = new C::Scan filename => $filename, filename_filter => $filter,
add_cppflags => $addflags;
$c->set(includeDirs => [$Config::Config{shrpdir}]);

my $fdec = $c->get(parsed_fdecls);

This description is VERY incomplete.

This module uses Data::Flow interface, thus one uses it in the following fashion:

$c = new C::Scan(attr1 => $value1, attr2 => $value2);
$c->set( attr3 => $value3 );

$value4 = $c->get(attr4);

Attributes are depending on some other attributes. The only required attribute, i.e., the attribute which should be set, is filename, which denotes which file to parse.

All other attributes are either optional, or would be calculated basing on values of required and optional attributes.

C-Cramp project is an interface to MySQL for managing information for small radio stations.
C-Cramp (the C-Cramp College Radio Audio Management Program) is a Web-based frontend to MySQL for managing the types of things that small radio stations might need: audio files, data, and "metadata"; DJ and staff information, schedules, live music and program logs, and all sorts of other data.
Currently, a cross-platform PHP application is the focus of the project, but more features and types of programs are planned that will hopefully enable easier playback, storage, loading, and entering for all types of applicable data.
Enhancements:
- doesnt require a faulty cddb-connected program that doesnt exist
- easier manual data entry for albums / tracks
- its possible now to add promoters/traffic events/non-new CDs/users
- A rudimentary Search function is implimented!
- Some preliminary stats functions work alright!
- Viewing of albums by promoter with heavy/medium/light rating
- md5-encrypted passwords for users
- updated a lot of old code
- prepared for eventual "theming" capabilities
- and a whole lot more!

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.