Free flat file structures software for linux

Flat File Extractor can be used for reading different flat file structures and printing them in different formats. ffe is a command line tool developed in GNU/Linux environment and it is distributed under GNU General Public License 2 or later.
Main areas of use are:
- Extracting particular fields or records from a flat file
- Converting data from one format to an other, e.g. from CSV to fixed length
- Verifying a flat file structure
- Testing tool for flat file development
- Displaying flat file content in human readable form
Main features:
- Command-line tool
- Reads standard input and writes to standard output as default
- One input file can contain several types of records (lines)
- Fields in a flat file can be fixed length or separated
- Input file structure and output definitions are independent, meaning one output format can be used with several input files
- Input file structure and output format are freely configurable, they are not predefined
- Output can be formatted e.g. as: fixed length, separated, tokenized, XML, SQL,...
- ffe tries to guess the input format, user needs not to give it as a parameter
Enhancements:
- Configuration keyword const has been added

Erwin Data Structures is a library that is meant to be the ultimate data structure library for mixed usage of C and C++.

Arbitrary key and value types are implemented by template files that dont use C++ templates, but are instantiated by a Perl script.

This way, mixed usage in C and C++ is possible. However, a C++ interface is generated to support the advantages of the C++ language. No templates, no void*.
Erwin contains a number of tools, too, all of them written in Perl. The following list shows the data structures and tools, together with some typical examples.

Image::MetaData::JPEG::Structures is a Perl module that describes the structure of a JPEG file; it is an appendix to the main manual page of the Image::MetaData::JPEG module, which the reader should refer to for further details and the general scope.

THE STRUCTURE OF JPEG PICTURES

The JPEG (Joint Photographic Experts Group) ISO standard is a lossy image compression mechanism developed before 1990, designed for compressing colour or gray-scale photo-realistic images (it performs poorly on line-art drawings). The JPEG mechanism is designed to exploit known limitations of the human eye, in particular the fact that colour changes are perceived less accurately than changes in brightness.

Note that although the "baseline" JPEG format is patent-free, there are patents associated with some optional features, namely arithmetic coding and hierarchical storage. For this reason, these optional features are never used on the Web (good job, patent fans ...). JPEG refers only to a class of compression algorithms, not to a specific file format. In order to produce files with embedded JPEG streams, a number of file format (semi-)standards have been adapted or devised, some of which are listed in the format section. The structure of a well formed JPEG file can be described by the following pseudo production rules (for sake of simplicity, some additional constraints between tables and SOF segments are neglected).

JPEG --> (SOI)(misc)*(image)?(EOI)
(image) --> (hierarch.)|(non-hier.)
(hierarch.) --> (DHP)(frame)+
(frame) --> (misc)*(EXP)?(non-hier.)
(non-hier.) --> (SOF)(scan)+
(scan) --> (misc)*(SOS)(data)*(ECS)(DNL)?
(data) --> (ECS)(RST)
(misc) --> (DQT)|(DHT)|(DAC)|(DRI)|(COM)|(APP)

(SOI) = Start Of Image
(EOI) = End Of Image
(SOF) = Start Of Frame header (10 types)
(SOS) = Start Of Scan header
(ECS) = Entropy Coded Segment (row data, not a real segment)
(DNL) = Define Number of Lines segment
(DHP) = Define Hierarchical P??? segment
(EXP) = EXPansion segment
(RST) = ReSTart segment (8 types)
(DQT) = Define Quantisation Table
(DHT) = Define Huffman coding Table
(DAC) = Define Arithmetic coding Table
(DRI) = Define Restart Interval
(COM) = COMment segment
(APP) = APPlication segment

This package does not check that a JPEG file is really correct; it accepts a looser syntax, were segments and ECS blocks are just contiguous (basically, because it does not need to display the image!). All meta-data information is concentrated in the (COM*) and (APP) Segments, exception made for some records in the (SOF*) segment (e.g. image dimensions).

Reference: B< "Digital compression and coding of continuous-tone still
images: requirements and guidelines", CCITT recommend. T.81, 1992,
The International Telegraph and Telephone Consultative Committee,
standard ISO/IEC IS 10918-1 or ITU-T Recommendation T.81 >.
Also: B< "The JPEG still picture compression standard", G.K.Wallace,
1991, IEEE Transactions on Consumer Electronics >.

GraphViz::Data::Structure can visualise data structures.

SYNOPSIS

use GraphViz::Data::Structure;

my $gvds = GraphViz:Data::Structure->new($data_structure);
print $gvds->graph()->as_png;

This module makes it easy to visualise data structures, even recursive or circular ones.
It is provided as an alternative to GraphViz::Data::Grapher. Differences:

GraphViz::Data::Structure handles structures of arbitrary depth and complexity, automatically following links using a standard graph traversal algorithm.
GraphViz::Data::Grapher creates graphics of indiividual substructures (arrays, scalars, hashes) which keep the substructure type and data together; GraphViz::Data::Structure does this by shape alone.
GraphViz::Data::Structure encapsulates object info (if any) directly into the node being used to represent the class.
GraphViz::Data::Grapher colors its graphs; GraphViz::Data::Structure doesnt by default.
GraphViz::Data:Structure can parse out globs and CODE references (almost as well as the debugger does).

GNOME Structured File Library is a utility library for reading and writing structured file formats. Support for MS OLE2 streams is complete, as is zip import.
There is also support for document metadata and some initial work on decompressing VBA streams in OLE files for future conversion to other languages.
This library replaces libole2 and is used in gnumeric, mrproject, abiword, libwv2, koffice. It is also part of the AAF format.
Enhancements:
- This release reverts jump to dynamic types, as they arent thread-safe.
- A compilation glitch on Windows has been fixed.
- Problems building without gconf macros installed are avoided.
- Configure breakage with --without-gnome has been fixed.

Struct::Compare is a recursive diff for perl structures.

SYNOPSIS

use Struct::Compare;
my $is_different = compare($ref1, $ref2);

Compares two values of any type and structure and returns true if they are the same. It does a deep comparison of the structures, so a hash of a hash of a whatever will be compared correctly.

This is especially useful for writing unit tests for your modules!

PUBLIC FUNCTIONS

$bool = compare($var1, $var2)

Recursively compares $var1 to $var2, returning false if either structure is different than the other at any point. If both are undefined, it returns true as well, because that is considered equal.

The flat assembler is a fast and efficient self-assembling 80x86 assembler for DOS, Windows, and Linux operating systems. Currently, it supports all 8086-80486/Pentium instructions with MMX, SSE, SSE2, SSE3, and 3DNow! extensions.
It can produce output in binary, MZ, PE, COFF, or ELF format. Flat Assembler includes the powerful but easy-to-use macroinstruction support, and does multiple passes to optimize the instruction codes for size. The flat assembler is entirely written in assembly language.
Enhancements:
- 32-bit relocations are now allowed in PE64 output format.
- EIP-relative addressing was added.
- The PLT operator was added for the ELF output format.
- SSSE3 (Supplemental SSE3) instructions were added.
- Some Win64 headers and examples were provided in the Windows package.
- The SYSRETQ mnemonic was added, and RDMSRQ/WRMSRQ/SYSEXITQ mnemonics were added for the 64-bit variants of respective instructions.
- R8L-R15L (Intel-style) aliases were added for R8B-R15B registers. Support for the AMD SVM technology instructions was added. Numerous bugs were fixed.

Amarok has a built-in function for setting the icon for folders (the one that displays in Konqueror etc) to be the cover image for the album it contains. However, it only works if you let it recognize your music.

Amarok Folder Icons script will scan the current directory and sub directories for music, and set all the folder icons where it can determine that the folder contains tracks from just one album.

This works best if you store your albums in a flat structure e.g.

/path/to/your/music/artist name - album name/

Installation:

Copy the script to your main music directory, and make it executable:

At a terminal:

$ chmod +x make_amarok_folder_icons.py

Usage:

At a terminal:

$ cd /to/your/music/folder
$ ./make_amarok_folder_icons.py