Free compound software for linux

GMP compiler tool simplifies the use of GMP, the GNU multiple precision library. It scans a C source file for specially marked GMPS arithmetic expressions and replaces them with plain C.
The abbreviation gmpc stands for GMP compiler, or alternatively GMPS-to-C compiler. GMPS arithmetic expressions are straightforward infix expressions which transparently support the special types mpq_t, mpz_t and mpf_t as defined by GMP. GMPS means, rather unimaginatively, `GMP script.
No dependencies are added to the resulting C source, so there is no need to include additional header files or link with special libraries other than GMP.
Invoking gmpc
To translate a .gmpc file to C source, at least the input and output files must be given. The most concise invocation would look like this:
gmpc -o foo.c foo.gmpc
This will translate foo.gmpc into foo.c.
It is highly recommended to enable all warnings with the -Wall switch:
gmpc -Wall -o foo.gmpc foo.c
Other switches can be used to change the default behaviour of gmpc. They are listed in the following sections.
Enhancements:
- Added support for C-like compound assignments, increment and decrement operators.
- Fixed an assignment precedence bug.
- Temporary variables and constants are grouped together to make generated code more readable.
- Added Doxygen comments and configuration file.

Forth Foundation Library, in short FFL is a Forth library. It gives you a collection of words written in (ANS) forth which are useful in areas such as data types, collections, interfaces, development support, and compound modules.
The modules in the library are grouped in five clusters:
- Data types - char
- Collections - single linked list
- Interfaces - crc-32
- Development - struct, unit test
- Compound - nothing yet.
Enhancements:
- This release adds four new features to the library, including an n-tree with an iterator, a SHA-256 module, and a regular expressions module.
- The library will now also run on MinForth.

POLE is a portable C++ library to access structured storage. It is designed to be compatible with Microsoft structured storage, also sometimes known as OLE Compound Document.

A structured storage is normally used to store files inside another file; you can even have complex directory tree inside. It can be treated as a filesystem inside a file.

The most popular use of structured storage is in Microsoft Office. Structured storage does not offer compression nor encryption support, hence usually it is used only for interoperability purposes.

Compared to structured storage routines offered by Microsoft Windows API, POLE has the advantage that it is portable. You can access any structured storage in the supported platform, you dont need to rely on Windows library.

Using

To compile POLE, you need a C++ compiler, with standard C++ library which supports STL (Standard Template Library).

POLE is just a library, you have to integrate it as part of your application/project. Since it consists of one source file and one header file, it does not make much sense to compile POLE as separate library (either static or dynamic). Simply add these files to your project and you are done.

The source tarball of POLE demonstrates the use of POLE to build poledump, a small utility to extract any stream inside a structured storage. If you use g++ as the compiler, you can compile poledump using the following command:

g++ -o poledump pole.cpp poledump.cpp

You may use poledump like the example below:

poledump budget.xls Workbook result.xls

The above command will extract a stream named Workbook inside Excel document (budget.xls) and save it as result.xls. File result.xls will still be recognized as a valid workbook (in raw format). Launch Microsoft Excel, open this file, and convince yourself.

Since version 0.2, the source tarball also includes a graphical tool named POLEView. Its purpose is to show the content of a structured storage in a tree view. It is also possible to view each stream in hexadecimal format and/or export the stream as well. You can study its source code to get familiar on how to use POLE API.

To compile POLEView, you need Qt (from Trolltech) version 3.x. Most Linux distributions normally already package the latest version of Qt, so it is likely that you need to worry about this. The Windows version is still planned, awaiting for the release of Qt version 4.

The build command for poleview is:

qmake && make

Jude is a rapid application development tool that permits to formalize a problem and then obtain a full featured and easy to use data management, workgroup application that can be further adapted implementing specific agents.

Jude is based on a knowledge-base with an object-oriented structure on the server side and a compound-document, agent-based user interface on the client side.

Relational database, Object-Oriented database, document-management systems, XML documents, compound-documents, declarative programming, agent-based systems and Java are well understood technologies but when you use them alone in order to build data-management applications you encounter many problems.

For example relational databases management systems cannot support new data types and for some applications the allowed data are not sufficient. They lack support for long-transactions.

The development of an application using object-oriented database management systems encourages procedural coding over declarative coding and this tends to produce code hard to maintain because there are many relationships between different parts of the program. Jude tries to join all benefits of these technologies in a coherent application framework.

Jude permits developers to specify an abstract, simplified view of the world we wish to represent using an high-level, declarative, object-oriented language and then to obtain a full functional work-group application. Jude try to join in a simple but powerful way many powerful programming paradigms: object-oriented, declarative, agent-based and compound-document.

Developers can extend application functionalities adding new agents to the system. Developers can reuse already specified knowledge-base clusters (there are already clusters related to physics, organization relationships, chemical). Developers can reuse already specified agents, in particular agents related to user interface.

Jude permits users to manage (view, edit, retrieve) documents and structured informations using a coherent and simple to grasp environment based on Java and Swing library.

Password Hasher enables a good security practice.
What good security practice demands:
- Strong passwords that are hard to guess.
- Different passwords at each site.
- Periodically changing existing passwords.
Why you probably arent practicing good security:
- Strong passwords are difficult to remember.
- Juggling a multitude of passwords is a pain.
- Updating passwords compounds the memorization problem.
Main features:
- Automatically generates strong passwords.
- One master key produces different passwords at many sites.
- Quickly upgrade passwords by "bumping" the site tag.
- Upgrade a master key without updating all sites at once.
- Supports different length passwords.
- Supports special requirements, such as digits and punctuation.
- Supports restricting a hash word to not use special characters. (New!)
- Saves all data to the browsers secure password database.
- Generates a portable HTML page with your site tags and option settings that allows you to generate your hash words in any browser on any machine without the extension installed. (New!)
- Can add marker buttons to unmask passwords on any web site. (New!)
- Extremely simple to use!

msgparser project is a parser for .msg Files in Java.

msgparser is a small open source Java library that parses Outlook .msg files and provides their content using Java objects.

msgparser uses the Apache POI - POIFS library to parse the message files which use the OLE 2 Compound Document format. Thus, it is merely a convenience library that covers the details of the .msg file. The implementation is based on the information provided at fileformat.info.

Examples:

This page shows how to use the msgparser library to access to content of a .msg file.

For parsing the .msg file, a MsgParser object must be created. This parser can process .msg files stored in a file or coming from an InputStream.

MsgParser msgp = new MsgParser();
Message msg = msgp.parseMsg("mail.msg");

The resulting msg object contains all necessary information (e.g., from, to, subject).

String fromEmail = msg.getFromEmail();
String fromName = msg.getFromName();
String subject = msg.getSubject();

Attachments are stored in Attachment objects.

List atts = msg.getAttachments();
for (Attachment att : atts) {
// do something with attachment
}

An attachment is either a file (which is a FileAttachment object) or another attached .msg file (i.e, an .msg file in an .msg file) (which is a MsgAttachment object).