Free binary translation software for linux

Bio::LiveSeq::Translation is a translation class for LiveSeq.

This stores informations about aminoacids translations of transcripts. The implementation is that a Translation object is the translation of a Transcript object, with different possibilities of manipulation, different coordinate system and eventually its own ranges (protein domains).

APPENDIX

The rest of the documentation details each of the object methods. Internal methods are usually preceded with a _

new

Title : new
Usage : $protein = Bio::LiveSeq::Translation->new(-transcript => $transcr);

Function: generates a new Bio::LiveSeq::Translation
Returns : reference to a new object of class Translation
Errorcode -1
Args : reference to an object of class Transcript

get_Transcript

Title : valid
Usage : $transcript = $obj->get_Transcript()
Function: retrieves the reference to the object of class Transcript (if any)
attached to a LiveSeq object
Returns : object reference
Args : none

aa_ranges

Title : aa_ranges
Usage : @proteinfeatures = $translation->aa_ranges()
Function: to retrieve all the LiveSeq AARange objects attached to a
Translation, usually created out of a SwissProt database entry
crossreferenced from an EMBL CDS feature.
Returns : an array
Args : none

Transolution is a Computer Aided Translation (CAT) suite supporting the XLIFF standard. It provides the open source community with features and concepts that have been used by commercial offerings for years to improve translation efficiency and quality.
The suite is modular to make it flexible and provides a XLIFF Editor, translation memory engine and filters to convert different formats to and from XLIFF.
The use of XLIFF means that almost any content can be localized as long as there is a filter for it (XML, SGML, PO, RTF,StarOffice/OpenOffice).
A versatile translation editor for XLIFF files. It aims to provide translators with professional quality editor for both documentation and software. Features tag protection and interactive Translation Memory.
Main features:
- Versatile, can be used for both software and documentation
- Sentence segmentation
- Tag protection
- Interactive Translation Memory
- File format based on XLIFF standard
- Platform independent
- Open source (GPL License)

cg is a semi-automatic newsgroup binary downloader. It assembles parts based on subject headers and then offers them in an editor for the user to choose which files he really wants.
cg is a automatic binary newsgroups downloader. It assembles parts based on subject headers and then offers them in an editor for the user to choose which files he really wants.
It supports decoding data in the following formats:
uuencode (both single- and multi-posting binaries)
MIME (multipart/mixed, message/partial; base64, quoted printable, x-uuencode) yEnc
Start it with cg somenewsgroup; `cg -h offers a short help, should you need it.
Enhancements:
- yenc support
- rename broken files to filename.broken
- CTRL-C/SIGINT handling: write rc file and quit after completely decoding current file.
- segfault fix (for postings of the type [422/7])
- ignore some uninteresting comment lines (no .desc file)
- dont assume last line before end is not allowed to contain data in uu data

Translate! (multi-language) is a Google-based, over-the-network translation desktop widget.

It automatically supports all languages translate.google.com supports as of the moment you start the widget.

(Double-)Click the Wrench button on the middle to chose the language pair.

The Java Binary Enhancement Tool (JBET) is a general Java program analysis and manipulation tool. Existing class files can be disassembled, reassembled, or edited programmatically through the JBET API. JBET can also be used to create new Java class files from scratch. JBET uses a convenient internal representation of all the contents of Java binary (.class) files, allowing the user to edit the classes easily, in a structured manner.

JBET was developed as part of the DARPA Self-Protecting Mobile Agents project under the OASIS and Active Networks programs (contract number N66001-00-C-8602) in order to study automated software obfuscation.

The Java language was chosen for this project because of the (relative) ease of constructing binary editing tools provided by the large amount of type information present in the class files. Our two reports, the Obfuscation Techniques Evaluation Report, and the Obfuscation Report, are available from the download area. The obfuscation tool developed is not part of this release.

JBET was also used in the DARPA/AFRL Survivable Server project (contract number F30602-00-C-0183) to add additional security checks to the Java Standard Library. (The Java SecurityManager API does not support many desirable security checks, such as continued authorization of file accesses after opening.)

JBET was used to replace the native method references in the Java standard library with stubs that call a pluggable security policy. This tool, called Jpolicy, is also available for download at this website. Jpolicy is very incomplete at this time, but may be interesting to those working in Java security or changing the standard library themselves.

The internal representation of Java class files used by JBET is intented to make it easy for programmers to write Java binary code transforms. Each element of Java class files has a corresponding internal data structure: ClassInfo for entire classes, MethodInfo for methods, FieldInfo for fields, Snippit for code blocks, and Instruction for individual instructions. Snippit and Instruction understand Java opcode syntax and semantics, allowing automated creation of valid Java programs. A Java-compatible class verifier is also included.

Some code transforms are difficult to program directly by manipulating Java instructions. For those transforms, a directed acyclic graph (DAG) representation of code is available. In the DAG representation, each basic block has a corresponding DAG, with a set of input and output nodes. Edges in the graph connect "producer" nodes (such as constants, or the result of calculations) to "user" nodes (such as method calls or other calculations). Methods are divided into basic blocks and control flow is stored at the basic block level (possible because Java has only fixed jump targets)

JBET requires a Java 1.4 virtual machine to run, although it can operate on class files from earlier Java versions. The packaging and build environment supplied supports Linux and Windows with Cygwin; however, the build process is simple and could be performed manually on other platforms. Perl is required for regression testing.

Jpolicy requires a Java 1.4 virtual machine to build, either Linux or Windows NT/XP with Cygwin. gcc is required for building on Windows (supplied with Cygwin). The runtime system can be either Java 1.3 or 1.4 (with Suns JVM only), running on Linux or Windows NT/XP. Windows 9x and Windows 2000 may work as well, but have not been tested.

Installation

1. Install jdk 1.4.1.
2. Set CLASSPATH to jdk1.4.1/jre/lib/rt.jar
3. cd src; make
4. If that didnt work, examine the makefile. java or javac may not be in the path.
5. To build a jar file that can be used with "java -jar jbet.jar", run "make jar".
6. If you have perl installed, run the tests with "make test".
Optionally, run "make regen; make test".

Make a symbolic link from jbet3/bin/jbet to somewhere in your path.

Usage

JBET uses the JNI format for class names, and JNI type and method descriptors. For a summary of this syntax, use jbet help syntax. Suns JVM specification may also be helpful.

To look at a class disassembly, use jbet print. Try disassembling a class you have source for, and was built with debug info (-g): jbet -P < classpath > print < classname >. Suns JVM specification has an instruction reference.

Parse::Binary::FixedFormat::Variants is a Perl module to convert between variant records and hashes.

Parse::Binary::FixedFormat supports variant record formats. To describe a variant structure, pass a hash reference containing the following elements to new. The object returned to handle variant records will be a Parse::Binary::FixedFormat::Variants.

Chooser

When converting a buffer to a hash, this subroutine is invoked after applying the first format to the buffer. The generated hash reference is passed to this routine. Any field names specified in the first format are available to be used in making a decision on which format to use to decipher the buffer. This routine should return the index of the proper format specification.

When converting a hash to a buffer, this subroutine is invoked first to choose a packing format. Since the same function is used for both conversions, this function should restrict itself to field names that exist in format 0 and those fields should exist in the same place in all formats.

Formats

This is a reference to a list of formats. Each format contains a list of field specifications.

For example:
my $cvt = new Parse::Binary::FixedFormat {
Chooser => sub { my $rec=shift;
$rec->{RecordType} eq 0 ? 1 : 2
},
Formats => [ [ RecordType:A1 ],
[ RecordType:A1, FieldA:A6, FieldB:A4:4 ],
[ RecordType:A1, FieldC:A4, FieldD:A18 ] ]
};
my $rec0 = $cvt->unformat("0FieldAB[0]B[1]B[2]B[3]");
my $rec1 = $cvt->unformat("1FldC");

In the above example, the Chooser function looks at the contents of the RecordType field. If it contains a 0, format 1 is used. Otherwise, format 2 is used.

Parse::Binary::FixedFormat::Variants can be used is if it were a Parse::Binary::FixedFormat. The format and unformat methods will determine which variant to use automatically. The blank method requires an argument that specifies the variant number.

Parse::Binary::FixedFormat is a Perl module to convert between fixed-length fields and hashes.

SYNOPSIS

use Parse::Binary::FixedFormat;

my $tarhdr =
new Parse::Binary::FixedFormat [ qw(name:a100 mode:a8 uid:a8 gid:a8 size:a12
mtime:a12 chksum:a8 typeflag:a1 linkname:a100
magic:a6 version:a2 uname:a32 gname:a32
devmajor:a8 devminor:a8 prefix:a155) ];
my $buf;
read TARFILE, $buf, 512;

# create a hash from the buffer read from the file
my $hdr = $tarhdr->unformat($buf); # $hdr gets a hash ref

# create a flat record from a hash reference
my $buf = $tarhdr->format($hdr); # $hdr is a hash ref

# create a hash for a new record
my $newrec = $tarhdr->blank();

Parse::Binary::FixedFormat can be used to convert between a buffer with fixed-length field definitions and a hash with named entries for each field. The perl pack and unpack functions are used to perform the conversions. Parse::Binary::FixedFormat builds the format string by concatenating the field descriptions and converts between the lists used by pack and unpack and a hash that can be reference by field name.