Free preprocessor conditionals software for linux

ippfp is an easy-to-use library which provides oo-methods for creating and rendering user interfaces in PHP independently from output format. It features HTML, GTK, PDF and ncurses.
You can create input masks such as forms for databases or other user interfaces. ippfp features abstraction, elements can be accessed like data structures, they have values and various attributes.
For me ippfp is a construction kit to build software quickly.
Another purpose could be the automatically generation by software.
You can select one of these packages to display:
- HTML
- PDF
- GTK
- ncurses
Available elements:
- button
- checkbox
- choice
- fopen (file open)
- grid
- image
- label (readonly text)
- link
- multiplechoice
- password
- radio
- text
- textarea
- table
The library puts the elements together in a frame. For HTML a HTML page will be created which contains the elements, GTK and ncurses have appropriate windows. The data of elements will be stored in session variables.
One does not need to care for details of formats like HTML-tags or GTK-classes. For navigating within a program the button element should be used. To arrange elements the elements "grid" or rather "table" are the right choices.
Elements are created with the "create"-functions which are members of the ippfp main instance and returns objects respective to the goal. To make them visible they will be grouped in a "view" which will be given to the ippfp main instance for processing.
This is a flexible way because an existing element can be used in several views. Thus, elements will be included by reference, not by copy. The advantages are: if an element is in a state, it is independent from the current view and related informations are available globally.
For example: create a text element:
$myText = $ippfp->createText("default", 20, "my_text");
...
echo $myText->getValue();
Your code should be organised into php functions. For example if a button is used, it calls the function given as attribute. It is expedient to integrate your views into this functions.
Enhancements:
- switched from html to xhtml, format identifier is XHTML
- a simple debug function added, for internal debugging, writes messages into a file (usefull for ncurses)
- pdf passes the "tabellentest", tables and grids can extend over a big number of pages, and can contain big text
- some bugfixes in xhtml and pdf

sp_preproc is a SystemPerl Preprocessor.

SYNOPSIS

sp_preproc

sp_preproc takes a .sp (systemperl) file and creates the SystemC header and C files.

It is generally only executed from the standard build scripts.

ARGUMENTS

--help

Displays this message and program version and exits.

--hier-only

Read only hierarchy information, ignore all signal information. Useful for faster generation of sp_lib files.

--inline

Edit the existing source code "inline". Similar to the Verilog-mode AUTOs. Use --inline --noautos to remove the expanded automatics.

--libfile

Filename to write a list of sp_cells into, for later use as a --libcell to another sp_preproc run.

--libcell

Files listed before --libcell will be preprocessed or inlined as appropriate. Files after noexpand will only be used for resolving references, they will not be linked, linted, or otherwise checked. --nolibcell can be used to re-enable checking of subsequent files.

--ncsc

Create output files compatible with Cadence NC-SystemC.

--nolint

Disable lint style error checks, such as required to run doxygen on the SystemPerl output.

--preproc

Preprocess the code, writing to separate header and cpp files.

--trace-duplicates

Include code to trace submodule signals connected directly to a parent signal, generally for debugging interconnect. Without this switch such signals will be presumed to have the value of their parent modules signal, speeding and compressing traces.

--tree filename

Write a report showing the design hierarchy tree to the specified filename. This format may change, it should not be parsed by tools.

--noautos

With --inline, remove any expanded automatics.

--verbose

Shows which files are being written, or are the same.

--write-verilog filename

Write the SystemC interconnections in Verilog format to the specified filename. Note this does not include logic, it only contains module ports and cells.

-M

Makes the dependency listing (similar to cpp -M).

-Dvar=value

Sets a define to the given value (similar to cpp -D).

-f file

Parse parameters from the given file.

TagReport is a nifty little project Ive been working on which is mostly a giant C++ exploration exercise. The program is very simple at this stage; the indexer part is really an HTML output function right now, that mimics the "Winamp Generated Playlist" format commonly seen on the Internet.
Currently it supports 4 libraries with which it can process audio files; libFLAC for FLAC files, libvorbisfile for Ogg Vorbis audio, libid3tag for MP3 audio, and TagLib, an all-in-one library that supports both Ogg Vorbis and MP3 reading.
Enhancements:
- Many many many new things, hence the version leap
- FLAC support: started with forking metaflac, now uses libFLAC
- Support for using libvorbisfile and libid3tag to process MP3s when TagLib is not available
- Piles of code cleanups
- Fix a giant configure bug involving when we search for where the preprocessor is
- Add a man page in SGML. Should not have to be built by normal users, though.
- Move all tag/comment-retrieving code to ftfuncs.{cc,h}
- Move all HTML-related code to html.cc

Convert::Binary::C is a Binary Data Conversion using C Types.

SYNOPSIS

Simple
use Convert::Binary::C;

#---------------------------------------------
# Create a new object and parse embedded code
#---------------------------------------------
my $c = Convert::Binary::C->new->parse( DEC, day => 24 };

my $packed = $c->pack( Date, $date );
Advanced
use Convert::Binary::C;
use Data::Dumper;

#---------------------
# Create a new object
#---------------------
my $c = new Convert::Binary::C ByteOrder => BigEndian;

#---------------------------------------------------
# Add include paths and global preprocessor defines
#---------------------------------------------------
$c->Include( /usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include,
/usr/include )
->Define( qw( __USE_POSIX __USE_ISOC99=1 ) );

#----------------------------------
# Parse the time.h header file
#----------------------------------
$c->parse_file( time.h );

#---------------------------------------
# See which files the object depends on
#---------------------------------------
print Dumper( [$c->dependencies] );

#-----------------------------------------------------------
# See if struct timespec is defined and dump its definition
#-----------------------------------------------------------
if( $c->def( struct timespec ) ) {
print Dumper( $c->struct( timespec ) );
}

#-------------------------------
# Create some binary dummy data
#-------------------------------
my $data = "binaryteststring";

#--------------------------------------------------------
# Unpack $data according to struct timespec definition
#--------------------------------------------------------
if( length($data) >= $c->sizeof( timespec ) ) {
my $perl = $c->unpack( timespec, $data );
print Dumper( $perl );
}

#--------------------------------------------------------
# See which member lies at offset 5 of struct timespec
#--------------------------------------------------------
my $member = $c->member( timespec, 5 );
print "member( timespec, 5 ) = $membern";

Convert::Binary::C is a preprocessor and parser for C type definitions. It is highly configurable and should support arbitrarily complex data structures. Its object-oriented interface has pack and unpack methods that act as replacements for Perls pack and unpack and allow to use the C types instead of a string representation of the data structure for conversion of binary data from and to Perls complex data structures.

Actually, what Convert::Binary::C does is not very different from what a C compiler does, just that it doesnt compile the source code into an object file or executable, but only parses the code and allows Perl to use the enumerations, structs, unions and typedefs that have been defined within your C source for binary data conversion, similar to Perls pack and unpack.

Beyond that, the module offers a lot of convenience methods to retrieve information about the C types that have been parsed.

Xplore is a powerful and highly configurable Motif file manager with an Explorer-like user interface.
Main features:
- customizable four-pane layout, which includes a directory tree view, file view with different display styles, the "shelf," a kind of clipboard inspired by the NeXT file manager, and a "log" pane which captures the output of launched programs
- files can be moved, copied, executed etc. with simple mouse operations, including drag and drop between different xplore windows
- full keyboard navigation support, including an incremental filename search facility
- builtin automounting facility for special file systems like floppies, cdroms, etc.
- comprehensive session management features, with full support for the X11R5 and R6 session management protocols
- includes man page and many XPM icons
- offers extensive configuration options. In particular, file types are fully configurable, including separate push and drop actions a la xfm, and type-specific popup menus. A free-format configuration language featuring C preprocessor commands allows you to set up rather complex configurations with moderate effort, and a configuration dialog allows you to quickly add new and change existing file types at runtime.

MetaC language extends C in a 100% backward compatible way with reflective features and techniques for refactoring, reconfiguring and modifying arbitrary C source code.
Therefore, the extensions provide special metadata types for working with source code information, syntactical structures for the definiton of code templates, and metafunctions to gather information about source code and refactor, modify, delete, or insert code.
Some of the modifications that can be done with MetaC, are also realizable with the C preprocessor. But the C preprocessor suffers certain limitations that can be overcome using MetaC.
The area of applications for MetaC is not limited to specific domains. But its concepts and its motivation has been derived from problems of CASE tools for embedded real-time systems (e.g. Mathworks Matlab, Telelogics Tau, Aonixs STP).
- Source code reconfiguration and refactoring in general.
- Abstraction of APIs and hardware-specific or vendor-specific implementations of well-defined functionallity (ever got locked to a specfic API by a RTOS vendor?).
- Source code instrumentation for WCET-analysis
- Adaption of source code to multiple embedded targets (especially differing native platform APIs) based upon an abstract machine model
- Application specific debug support (e.g. control-flow or data-flow tracing)
- Verification of domain- and application-specific constraints (e.g. MISRAs rules set for C based programs in automotive applicaitons)
Advantages of the Metaprogramming Approach:
- Source code modification is done based upon syntax. In consequence invalid modifications can be detected at the moment they are executed.
- Decision for code modifications can be made upon user parameters and information derived from the source code
- Crosscutting reconfigurations (i.e. reconfigurations concerning multiple functions or modules) of source code are possible.
Enhancements:
- Support for Win32 hosts was added.
- Support for initializer lists was added.
- Some C99 issues were fixed.
- Several more enhancements were made.
- A whole bunch of bugs were fixed.

Tiny C compiles so fast that even for big projects Makefiles may not be necessary.
TinyCC (aka TCC) is a small but hyper fast C compiler. Unlike other C compilers, it is meant to be self-relying: you do not need an external assembler or linker because TCC does that for you.
TCC not only supports ANSI C, but also most of the new ISO C99 standard and many GNUC extensions including inline assembly.
TCC can also be used to make C scripts, i.e. pieces of C source that you run as a Perl or Python script. Compilation is so fast that your script will be as fast as if it was an executable. TCC can also automatically generate memory and bound checks while allowing all C pointers operations. TCC can do these checks even if non patched libraries are used.
With libtcc, you can use TCC as a backend for dynamic code generation
TCC mainly supports the i386 target on Linux and Windows. There are alpha ports for the ARM (arm-tcc) and the TMS320C67xx targets (c67-tcc).
Main features:
- SMALL! You can compile and execute C code everywhere, for example on rescue disks (about 100KB for x86 TCC executable, including C preprocessor, C compiler, assembler and linker).
- FAST! tcc generates optimized x86 code. No byte code overhead. Compile, assemble and link several times faster than GCC.
- UNLIMITED! Any C dynamic library can be used directly. TCC is heading torward full ISOC99 compliance. TCC can of course compile itself.
- SAFE! tcc includes an optional memory and bound checker. Bound checked code can be mixed freely with standard code.
- Compile and execute C source directly. No linking or assembly necessary. Full C preprocessor and GNU-like assembler included.
- C script supported : just add #!/usr/local/bin/tcc -run at the first line of your C source, and execute it directly from the command line.
- With libtcc, you can use TCC as a backend for dynamic code generation.
Enhancements:
- initial PE executable format for windows version (grischka)
- #pragma pack support (grischka)
- #include_next support (Bernhard Fischer)
- ignore -pipe option
- added -f[no-]leading-underscore
- preprocessor function macro parsing fix (grischka)

HTML Sucks Completely is a developer tool for HTML projects. HTML Sucks Completely is mainly intended for creating and maintaining larger Web sites, with a focus on compact and standards-conforming code.
Its source texts are HTML files that use an extended syntax allowing for macros, conditionals, variables, expressions, etc. These sources are transformed into static (X)HTML pages. HSC checks the result for many common errors such as missing end tags and nesting mistakes, both in the markup and, to a limited extent, in CSS.
As a commandline tool, it can be used together with "make", and a dependency generator is included. The macro library features things like navigation menus, LaTeX-style sections, footnotes and bibliographies, semiautomatic table-based layout, and database/scripting interfaces.
Enhancements:
- Various compilation problems on the Win32 platform were fixed, and the build environment was changed to MinGW.
- Current Win32 binaries are available from the homepage again.