Free flat software for linux

Flatworm project is a Java library intended to allow a developer to describe the format of a flat file using an XML definition file, and then to be able to automatically read lines from that file, and have one or more beans be instantiated for each logical record.

There are a few powerful features in Flatworm worth mentioning. For one thing, a record may consist of one or more physical lines in the file. A record may contain more than one bean once decoded. A flat file may contain more than one type of record, and Flatworm can use line length and substring matching to determine which type of record a line begins.

Besides fielded buffer flat files, Flatworm also supports text files where the different fields are separated by a separator character, e.g. CSV (comma separated values) files.

Last but not least, Flatworm is able to produce flat files from beans and the same definition file.

FLAT::Legacy::FA::RE is a regular expression base class.

SYNOPSIS

use FLAT::Legacy::FA::RE;
use FLAT::Legacy::FA::NFA;
my $re = RE->new();
$re->set_re(a|b|(hi)*);
my $nfa = $re->to_nfa();
print $nfa->info(); # see stuff on NFA
my $dfa = $nfa->to_dfa();
print $dfa->info(); # see stuff on DFA
my @removed = $dfa->minimize();
print $dfa->info(); # see stuff on minimized DFA
print "Removed ".($#removed+1)." statesn";

This module implements a regular expression parser, and supports the conversion of a RE to a deterministic finite automata. A homegrown recursive descent parser is used to build the parse tree, and the method used to conver the regular expression to a DFA uses no intermediate NFA.
Recursive Descent-safe Regex Grammar:

R -> O

O -> CO

O -> | CO | epsilon

C -> SC

C -> .SC | epsilon

S -> LS

S -> *S | epsilon

L -> a | b | c |..| 0 | 1 | 2 |..| (R) | epsilon

Terminal symbols: a,b,c,..,z,0,1,2,..,9,|,*,(,)

NOTE: Concatenation operator, ., is not a terminal symbol and should not be included in the regex

FAQ: Q: Does this support Perl regular expressions?
A: No, just the regular expression using the terminal symbols listed above.

Tie::FlatFile::Array is a Perl extension which treats a flatfile database as an array of arrays.

This module allows the programmer to treat a flatfile database as as array of arrays. For example, lets say you have a datafile that has fixed-length records like so:

Field-name Type
URL ASCII characters, length 30
Referals Integer, 4 bytes, binary in network order

If you were going to use pack to create a record like this, youd use a format string of A30N. Since Tie::FlatFile::Array does the packing and unpacking behind the scenes, you would use that pack format string in the call to tie:

tie @flat, Tie::FlatFile::Array, data.file,
O_RDWR | O_CREAT, 0644, { packformat => A30N }
or die("Tie failure: $!");

To insert an item into the data file, you would assign an array reference to one of the arrays elements like so:

$flat[0] = [ www.yahoo.com, 3601 ];

Fastilo project is a freeware shopping cart script based on PHP and Flat Files. Extremely easy to run and use. Our product work on Quick.Cart engine with some modifications.
Main features:
- full administration of the products, categories and delivery companies (delivery cost)
- full administration of the orders
- system for managing the content of additional pages and (subpages) in the web shop, as the company information, regulations etc.
- printing products and order cards
- system of additions, which helps to make your web shop even more functional
- inventory stock control
- WYSIWYG editor
- bestsellers panel
- email customer with his order
- friendly links

File::Tabular can search and edit flat tabular files.

SYNOPSIS

use File::Tabular;
my $f = new File::Tabular($filename);

my $row = $f->fetchrow;
print $row->{field1}, $row->{field2};

$row = $f->fetchrow(where => someWord);
$row = $f->fetchrow(where => field1 > 4 AND field2 >= "01.01.2001");
$row = $f->fetchrow(where => qr/somes+(complexs*)?(regex|regular expression)/i);

$f->rewind;
my $rows = $f->fetchall(where => someField =~ ^[abc]+);
print $_->{someField} foreach @$rows;

$f->rewind;
$rows = $f->fetchall(where => +field1:someWord -field2:otherWord,
orderBy => field3, field6:num, field5:-alpha);

$f->rewind;
my $hashRows = $f->fetchall(where => foo AND NOT bar,
key => someField);
print $hashRows->{someKey}{someOtherField};

# open for updates, and remember the updates in a journal file
$f = new File::Tabular("+>$journalFile"});

# updates at specific positions (line numbers)
$f->splices(4 => 2, undef, # delete 2 lines from position 4
7 => 1, {f1 => $v1, f2 => $v2, ...}, # replace line 7
9 => 0, { ...}, # insert 1 new line at position 9
22 => 0, [{...}, {...}, ...] # insert several lines at pos. 22
...
-1 => 0, [{...}, {...}, ...] # append at the end
);

# shorthand to add new data at the end
$f->append({f1 => $v1, f2 => $v2, ...});
# same thing, but use the "Hash::Type" associated to the file
$f->append($f->ht->new($v1, $v2, ...));


$f->clear; # removes all data (but keeps the header line)

# updates at specific keys, corresponding to @keyFields
$f->writeKeys({key1 => {f1 => $v1, f2 => $v2, ...}, # add or update
key2 => undef, # remove
...
}, @keyFields);


# replay the updates on a backup file
my $bck = new File::Tabular("+<<less