Free tablelayoutpanel c software for linux

Mail::Box::Parser::C is a Perl module that can parse folders for MailBox with C routines.

This is an optional module for MailBox, and will (once installed) automatically be used by MailBox to parse e-mail message content when the message is supplied as file-handle. In all other cases, MailBox will use Mail::Box::Parser::Perl.

Mail::Box::Parser::C - reading messages from file using C (XS)

SYNOPSIS

The Mail::Box::Parser::C implements parsing of messages in ANSI C, using Perls XS extension facility.

C++ Portable Components project are a collection of open-source class libraries that simplify and accelerate the development of network-centric, portable applications in C++.
The libraries integrate perfectly with the C++ Standard Library and fill many of the functional gaps left open by it.
Their modular and efficient design and implementation makes the C++ Portable Components extremely well suited for embedded development, an area where the C++ programming language is becoming increasingly popular, due to its suitability for both low-level (device I/O, interrupt handlers, etc.) and high-level object-oriented development.
The C++ Portable Components help developers to focus on the unique core features of the product they are developing ? the features that will ultimately sell the product. By reusing the tried and tested components provided by the C++ Portable Components, developers do not need to waste valuable time and resources re-inventing the wheel.
C++ Portable Components Layers
The classes provided by the Applied Informatics C++ Portable Components provide support for:
- threads, thread synchronization and advanced abstractions for multithreaded programming
- streams and filesystem access
- shared libraries and class loading
- powerful logging and error reporting
- security
- network programming (TCP/IP sockets, HTTP, FTP, SMTP, etc.)
- XML parsing (SAX2 and DOM) and generation
- configuration file and options handling
- an embeddable, lightweight SQL database
Todays highly complex software systems often outlive the hardware platforms they have originally been built on. Applications based on the C++ Portable Components can be easily ported to a new platform, thus helping to save and increase the return on investments made in software.
Enhancements:
- This release contains major bugfixes and performance improvements in the HTTP classes.

Java for C++ is a tool to generate C++-wrapper-classes for existing Java-classes. This tool reads a list of Java class names and creates source code for C++-classes to wrap them.
The implementation of the wrapper classes uses JNI (Java Native Interface) to call the "real" Java classes.
The C++-API to use these wrapper classes is very close to the API of the original Java classes. So developers of C++-software can use Java-classes as if they have been implemented in C++.
Enhancements:
- A problem where null values for method arguments, method return values, or field values caused some generated code to crash was fixed.
- Updating is strongly encouraged.

ResourcePool is a C++ library which can be used to pool resources of every kind. One very interesting side effect is that it can also be used of abstraction layer by providing a unique API for different resources of similar resource types.
Most prominent example are SQL databases. The ResourcePool does currently include a convenient way to access MySQL and Oracle databases in the same way, so that changing for MySQL to Oracle or vice-versa does not need big code changes.
Enhancements:
- Corrected handling of NoFailoverExceptions. Previously it did just not work.
- Fixed a bug which could cause undefined behavior in MultiThreadedModel when a caller had to wait for resources (when the Max limit is reached).
- The argument validation of the bindout() and isnull() methods of SQLSelect(Row) commands has been corrected.
- Fixed a bug in the Cache class which caused an unreasonable exception in case an already cached value is put again.
- The isnull() method has been added to the Runtime selectable SQL driver (fatalmind::ResourceType::SQL).
- The NoFailoverExceptions thrown in the mysql driver do now include the correct message. The messages were lost due to a missing explicit constructor call to the virtual base class.
- The getFactory() method in ResourcePool is now public and returns a const reference.
- Implemented some rudimentary statistics. See ResourcePool.getStats() for details.
- Building improvement: -lrt is used (and not used) more correctly.
- The testing framework has been extended to optionally perform testing in multiple threads. The default behavior has not been changed (make check does not use multiple threads). However when running the test programs manually you can add "-m" as argument. Each "m" does add an additional thread for testing. However, the test programs itself need also to provide such test cases.
- The test cases (used with make check) do now use the complete library. This has the drawback that building must always be done in the top level directory before performing tests. However, the tests use the real library now (and not just a subset) so that the overall testing quality is a little improved.

Obfuscated Tiny C Compiler (OTCC) is a very small C compiler I wrote in order to win the International Obfuscated C Code Contest (IOCCC) in 2002.

My goal was to write the smallest C compiler which is able to compile itself. I choose a subset of C which was general enough to write a small C compiler. Then I extended the C subset until I reached the maximum size authorized by the contest: 2048 bytes of C source excluding the ;, {, } and space characters.

I choose to generate i386 code. The original OTCC code could only run on i386 Linux because it relied on endianness and unaligned access. It generated the program in memory and launched it directly. External symbols were resolved with dlsym().

In order to have a portable version of OTCC, I made a variant called OTCCELF. It is only a little larger than OTCC, but it generates directly a dynamically linked i386 ELF executable from a C source without relying on any binutils tools! OTCCELF was tested succesfully on i386 Linux and on Sparc Solaris.

NOTE: My other project TinyCC which is a fully featured ISOC99 C compiler was written by starting from the source code of OTCC !

Compilation:

gcc -O2 otcc.c -o otcc -ldl
gcc -O2 otccelf.c -o otccelf

Self-compilation:

./otccelf otccelf.c otccelf1

Lightweight C++ is a programming language that looks like C++ (a lightweight C++ dialect) and is directly translated to readable C by the lwc preprocessor.
Its more "K&R" and, well, more lightweight. Important thing about lightweight C++ is that by studying the generated C code it is easy to understand how OOP features are implemented and what is the cost of everything.
Adding new features and extensions is also very easy (much easier than adding new C++ extensions to gcc at least), and this is one of lwc goals: To keep evolving.
Main features:
- function overloading,
- member functions,
- inheritance,
- virtual functions (polymorphism),
- multiple inheritance,
- virtual inheritance and pure virtual functions,
- constructors, destructors,
- new and delete,
- default function arguments,
- simple exceptions (no auto destruction of locals)
- and a mechanism of simplistic templates (implemented as high-level multi-line macros).
- operator overloading (works with ptrs when it can)
- +other
Enhancements:
- Changed the generated code for the gcc cleanup attribute so that if a constructor throws, the destructor is not invoked. As in the simple case where we dont have the cleanup attribute and like C++.

C to C++ is a Python script that converts C code to C++ code.

The main program is ctocpp.py that performs successive stages for converting C to C++. A script, ctocpp gives it as parameter to the python interpreter with options you add.

The archive also includes scripts that may help you:

- mover.py changes the location of a project.
- search.py performs searches and replacements.
- mkheader.py corrects a header file.

The C to C++ program with all the python sources is under the GNU GPL license,
that minds you may use it and distribute it freely, providing the copyright is unchanged.

See at the COPYING file for details. This doesnt mean GNU encourages you to convert your C sources to C++. In fact, most of the tools here included may help C programmers outside C++ conversion.

Installing:

Type:
./configure
./setup
mkdoc ...this will generate an html and info manuals.