Free offsets software for linux

FRET is a *nix command line tool that examines any file or files and attempts to identify the data structures and patterns within those file(s).
FRET project does this by firstly scanning files using heuristic algorithms to identify structures and then by comparing files to identify common patterns. Results are compared and ranked using a probabilistic approach.
It outputs a sorted list of the detected structures within the file(s) which can then be parsed by other tools and scripts. libfret is the library used to implement FRET. It provides a clear interface to allow for the analysis of buffers of raw data.
It is designed to be integrated with a range of other programs such as hex editors, packet analysers and other development tools.
FRET and libfret are at an early development stage and do not yet provide a lot of useful functionality. FRET (and libfret) scans a single or multiple files (buffers) and currently identifies the following structures:
- data that is common to multiple files or buffers
- arrays of ASCII bytes
- arrays of fill bytes
- offsets to other fields in a file
Enhancements:
- New --phase and --scan options were added, which allow specific tests to be performed.
- The results list was made clearer, and some internal redesign streamlined the code.

Autofs NG is a Linux automounter that is intended to be completely interoperable with autofs implementations on other Unix platforms. As such, it supports some features that the current Linux automounters do not.
This includes direct mounts, /net (--hosts access), lazy mounting and unmounting of hierarchical multimounts, and browsing. Autofsng also supports the usual indirect map support available elsewhere.
Maps are supported from flat files, executable maps, NIS maps, NIS+ maps, LDAP maps, and hesiod (DNS) filsys namespace.
AutofsNG was originally developed at Sun Microsystems, but has been cancelled as a project. Fortunately, it has been released as GPL, so I am continuing its development in my spare time.
Enhancements:
- Initscript fixup for path to /proc/mounts
- We no longer update /etc/mtab because the kernel does all unmounting. Current recommendation is to symlink /proc/mounts to /etc/mtab if you want to see the what is actually mounted with calling mount
- Fixed SuSE/LSB initscript issue where ypbind wasnt neccesarily started before autofsng.
- Added an RPM .spec file to the tree.
- Fixed initscript install
- Fixed possible crash when using the -hosts map.
- Redimentary mount option translation. Currently translates the common Solaris NFS mount options to Linux specific ones. Hard-coded.
- Initscript fixups for unknown systems (Debian in particular)
- Fixed a bug where the -hosts map would return duplicate map offsets, which is a semantic error for usual entries.

Class::Bits is a Perl module with class wrappers around bit vectors.

SYNOPSIS

package MyClass;
use Class::Bits;

make_bits( a => 4, # 0..15
b => 1, # 0..1
c => 1, # 0..1
d => 2, # 0..3
e => s4 # -8..7
f => s1 # -1..0
);

package;

$o=MyClass->new(a=>12, d=>2);
print "o->b is ", $o->b, "n";

print "bit vector is ", unpack("h*", $$o), "n";

$o2=$o->new();
$o3=MyClass->new($string);

ABSTRACT

Class::Bits creates class wrappers around bit vectors.

Class::Bits defines classes using bit vectors as storage.
Object attributes are stored in bit fields inside the bit vector. Bit field sizes have to be powers of 2 (1, 2, 4, 8, 16 or 32).

There is a class constructor subroutine:

make_bits( field1 => size1, field2 => size2, ...)

exports in the calling package a ctor, accessor methods, some utility methods and some constants:

Sizes can be prefixed by s or u to define signedness of the field. Default is unsigned.

$class->new()

creates a new object with all zeros.

$class->new($bitvector)

creates a new object over $bitvector.

$class->new(%fields)

creates a new object and initializes its fields with the values in %fields.

$obj->new()

clones an object.

$obj->$field()
$obj->$field($value)

gets or sets the value of the bit field $field inside the bit vector.

$class->length
$obj->lenght

returns the size in bits of the bit vector used for storage.

$class->keys
$obj->keys

returns an array with the names of the object attributes

$obj->as_hash

returns a flatten hash with the object attributes, i.e.:
my %values=$obj->as_hash;

%INDEX

hash with offsets as used by vec perl operator (to get an offset in bits, the value has to be multiplied by the corresponding bit field size).

%SIZES

hash with bit field sizes in bits.

%SIGNED

hash with signedness of the fields

Bit fields are packed in the bit vector in the order specified as arguments to make_bits.

Bit fields are padded inside the bit vector, i.e. a class created like

make_bits(A=>1, B=>2, C=>1, D=>4, E=>8, F=>16);

will have the layout

AxBBCxxx DDDDxxxx EEEEEEEE xxxxxxxx FFFFFFFF FFFFFFFF

GSubEdit, or GNOME Subtitle Editor, is a tool for editing and converting DivX ;-) subtitles. It currently features read/write of SubRip (.srt) and MicroDVD (.sub) subtitles.
Framerate conversion and frame displacement (Increase/decrease all frames by a given offset) is also supported.
Main features:
- Open and saving of SubRip (.srt) and MicroDVD (.sub)
- Framerate conversion (.sub and .srt)
- Frame displacement. Used if the frames is shown to early or to late. (.sub and .srt)
- Removing of the text used for hearing impaired. (.sub and .srt)
- Split file into two parts
- Join two files into one
- Editing of text, start- and end- frame/time (.sub and .srt)
- DragnDrop, search and replace and support for i18n (only Swedish is currently available)
- Spellcheck

Parrot::OpTrans is a Perl module that can transform Ops to C Code.

Parrot::OpTrans is the abstract superclass for the Parrot op to C transforms. Each transform contains various bits of information needed to generate the C code, and creates a different type of run loop. The methods defined here supply various default values and behaviour common to all transforms.

The subclass hierarchy is as follows:

OpTrans
|_________________________
| | |
C CGoto Compiled
| |
CPrederef |
| | |
| |_________|
| |
CSwitch CGP

Class Methods

new()

Returns a new instance.

Instance Methods

prefix()

Returns the default Parrot_ prefix.

Used by Parrot::Ops func_name() to individuate op function names.

suffix()

Implemented in subclasses to return a suffix with which to individuate variable names. This default implementation returns an empty string.

defines()

Implemented in subclasses to return the C #define macros required.

opsarraytype()

Returns the type for the array of opcodes. By default here its an array opcode_t, but the prederef runops core uses an array of void* to do its clever tricks.

core_type()

Implemented in subclasses to return the type of core created by the transform. This default implementation raises an exception indicating that the core type is missing. See the Parrot_Run_core_t enum in include/parrot/interpreter.h for a list of the core types.

core_prefix()

Implemented in subclasses to return a short prefix indicating the core type used to individuate core function names.

run_core_func_decl($base)

Optionally implemented in subclasses to return the C code for the run core function declaration. $base is the name of the main ops file minus the .ops extension.

ops_addr_decl($base_suffix)

Optionally implemented in subclasses to return the C code for the ops address declaration. $base_suffix is the name of the main ops file minus the .ops extension with suffix() and an underscore appended.

run_core_func_decl($base)

Optionally implemented in subclasses to return the C code for the run core function declaration. $base is the same as for run_core_func_decl().

run_core_func_start()

Implemented in subclasses, if run_core_func_decl() is implemented, to return the C code prior to the run core function.

run_core_after_addr_table($base_suffix)

Optionally implemented in subclasses to return the run core C code for section after the address table. $base_suffix is the same as for ops_addr_decl().

run_core_finish($base)

Implemented in subclasses to return the C code following the run core function. $base is the same as for run_core_func_decl().

init_func_init1($base)

Optionally implemented in subclasses to return the C code for the cores init function. $base is the same as for run_core_func_decl().

init_set_dispatch($base_suffix)

Optionally implemented in subclasses to return the C code for initializing the dispatch mechanism within the cores init function. $base_suffix is the same as for ops_addr_decl().

Macro Substitutions

The following methods are called by Parrot::OpFile to perform ops file macro substitutions.

access_arg($type, $value, $op)

Implemented in subclasses to return the C code for the specified op argument type and value. $op is an instance of Parrot::Op.

gen_goto($where)

The various goto_X methods below call this method with the return value of an expr_X method (implemented in subclass).

restart_address($address)

Implemented in subclasses to return the C code for restart ADDRESS($address).

restart_offset($offset)

Implemented in subclasses to return the C code for restart OFFSET($offset).

goto_address($address)

Transforms the goto ADDRESS($address) macro in an ops file into the relevant C code.

goto_offset($offset)

Transforms the goto OFFSET($offset) macro in an ops file into the relevant C code.

goto_pop()

Transforms the goto POP($address) macro in an ops file into the relevant C code.

expr_offset($offset)

Implemented in subclasses to return the C code for OFFSET($offset). Called by goto_offset().

expr_address($address)

Implemented in subclasses to return the C code for ADDRESS($address). Called by goto_address().

resample is a small commandline application for samplerate conversion and playback of audio data. It is based on a 16 bit fix-point MMX optimized polyphase filterbank, and should run in realtime on any almost any processor. It is processor independent but requires Linux
open sound system (OSS) to run.

resample takes its input from standard input and sends the resampled sound to the soundcard. It can convert from any samplerate to any other samplerate, and supports up to 6 channels (see resample --help for options). It is optimixed for converting ftom 44.1kHz to 48kHz, and may give a small frequency offset for other combinations.

Below is an example of how to use resample with cdparanoia to rip a track from a audio CD in realtime and play it at 48kHz using the soundcard:

cdparanoia -p -Z -Y -r -e -q 1 - | resample -q

Spreadsheet::Perl is a pure Perl implementation of a spreadsheet engine.
SYNOPSIS
use Spreadsheet::Perl;
use Spreadsheet::Perl::Arithmetic ;
my $ss = tie my %ss, "Spreadsheet::Perl"
$ss->SetNames("TEST_RANGE" => A5:B8) ;
$ss{TEST_RANGE} = 7 ;
DefineSpreadsheetFunction(AddOne, &AddOne) ;
$ss{A3} = PerlFormula($ss->AddOne("A5") + $ss{A5}) ;
print "A3 formula => " . $ss->GetFormulaText(A3) . "n" ;
print "A3 = $ss{A3}n" ;
$ss{ABC1:ABD5} = 10 ;
$ss{A4} = PerlFormula($ss->Sum("A5:B8", "ABC1:ABD5")) ;
print "A4 = $ss{A4}n" ;
...
Main features:
- set and get values from cells or ranges
- handle cell private data
- has fetch/store callback
- has cell attributes access
- has cell/range fillers (auto-fill functionality)
- set formulas (pure perl and common format)
- compute the dependencies between cells
- formulas can fetch data from multiple spreadsheets and the dependencies still work
- checks for circular dependencies
- debugging triggers
- has a simple architecture for expansion
- has a simple architecture for debugging (and some flags are already implemented)
- can read its data from a file
- supports cell naming
- cell and range locking
- input validators
- cell formats (pod, HTML, ...)
- can define spreadsheet functions from the scripts using it or via a new module of your own
- Recalculate() / AUTOCALC
- value caching to speed up formulas and volatile cells
- cell address offsetting functions
- Automatic formula offsetting
- Relative and fixed cell addresses
- slice access
- Perl scalar mapping to a cell
- some debugging tool (dump, dump table, dump to HTML, formula stack trace, ...)