binary
Sponsored Links
Sponsored Links
Secleted [ 0 ] software to compare
Results 1 - 15 of about 1340
BinaryKlock 0.1
BinaryKlock project is a binary clock kicker applet. more>>
BinaryKlock project is a binary clock kicker applet.
The special thing about this clock is that it displays the time in binary instead of using the decimal system.
Binary is pretty easy to read and many people will nonetheless stare at your desktop, not believing how you can read the time from that.
This is my first KDE application, let me know if you like it ;)
Building:
This is my first KDevelop project as well, and Im not yet extremely familiar with it. It generated the usual autoconf files and you should be able to build it like this:
./configure
make
make install
<<lessThe special thing about this clock is that it displays the time in binary instead of using the decimal system.
Binary is pretty easy to read and many people will nonetheless stare at your desktop, not believing how you can read the time from that.
This is my first KDE application, let me know if you like it ;)
Building:
This is my first KDevelop project as well, and Im not yet extremely familiar with it. It generated the usual autoconf files and you should be able to build it like this:
./configure
make
make install
Download (0.61MB)
Added: 2007-07-02 License: GPL (GNU General Public License) Price:
844 downloads
Tree::Binary 0.07
Tree::Binary is a Object Oriented Binary Tree for Perl. more>>
Tree::Binary is a Object Oriented Binary Tree for Perl.
SYNOPSIS
use Tree::Binary;
# a tree representaion of the expression:
# ((2 + 2) * (4 + 5))
my $btree = Tree::Binary->new("*")
->setLeft(
Tree::Binary->new("+")
->setLeft(Tree::Binary->new("2"))
->setRight(Tree::Binary->new("2"))
)
->setRight(
Tree::Binary->new("+")
->setLeft(Tree::Binary->new("4"))
->setRight(Tree::Binary->new("5"))
);
# Or shown visually:
# +---(*)---+
# | |
# +-(+)-+ +-(+)-+
# | | | |
# (2) (2) (4) (5)
# get a InOrder visitor
my $visitor = Tree::Binary::Visitor::InOrderTraversal->new();
$btree->accept($visitor);
# print the expression in infix order
print $visitor->getAccumulation(); # prints "2 + 2 * 4 + 5"
# get a PreOrder visitor
my $visitor = Tree::Binary::Visitor::PreOrderTraversal->new();
$btree->accept($visitor);
# print the expression in prefix order
print $visitor->getAccumulation(); # prints "* + 2 2 + 4 5"
# get a PostOrder visitor
my $visitor = Tree::Binary::Visitor::PostOrderTraversal->new();
$btree->accept($visitor);
# print the expression in postfix order
print $visitor->getAccumulation(); # prints "2 2 + 4 5 + *"
# get a Breadth First visitor
my $visitor = Tree::Binary::Visitor::BreadthFirstTraversal->new();
$btree->accept($visitor);
# print the expression in breadth first order
print $visitor->getAccumulation(); # prints "* + + 2 2 4 5"
# be sure to clean up all circular references
$btree->DESTROY();
This module is a fully object oriented implementation of a binary tree. Binary trees are a specialized type of tree which has only two possible branches, a left branch and a right branch. While it is possible to use an n-ary tree, like Tree::Simple, to fill most of your binary tree needs, a true binary tree object is just easier to mantain and use.
Binary Tree objects are especially useful (to me anyway) when building parse trees of things like mathematical or boolean expressions. They can also be used in games for such things as descisions trees. Binary trees are a well studied data structure and there is a wealth of information on the web about them.
This module uses exceptions and a minimal Design By Contract style. All method arguments are required unless specified in the documentation, if a required argument is not defined an exception will usually be thrown. Many arguments are also required to be of a specific type, for instance the $tree argument to both the setLeft and setRight methods, must be a Tree::Binary object or an object derived from Tree::Binary, otherwise an exception is thrown. This may seems harsh to some, but this allows me to have the confidence that my code works as I intend, and for you to enjoy the same level of confidence when using this module. Note however that this module does not use any Exception or Error module, the exceptions are just strings thrown with die.
This object uses a number of methods copied from another module of mine, Tree::Simple. Users of that module will find many similar methods and behaviors. However, it did not make sense for Tree::Binary to be derived from Tree::Simple, as there are a number of methods in Tree::Simple that just wouldnt make sense in Tree::Binary. So, while I normally do not approve of cut-and-paste code reuse, it was what made the most sense in this case.
<<lessSYNOPSIS
use Tree::Binary;
# a tree representaion of the expression:
# ((2 + 2) * (4 + 5))
my $btree = Tree::Binary->new("*")
->setLeft(
Tree::Binary->new("+")
->setLeft(Tree::Binary->new("2"))
->setRight(Tree::Binary->new("2"))
)
->setRight(
Tree::Binary->new("+")
->setLeft(Tree::Binary->new("4"))
->setRight(Tree::Binary->new("5"))
);
# Or shown visually:
# +---(*)---+
# | |
# +-(+)-+ +-(+)-+
# | | | |
# (2) (2) (4) (5)
# get a InOrder visitor
my $visitor = Tree::Binary::Visitor::InOrderTraversal->new();
$btree->accept($visitor);
# print the expression in infix order
print $visitor->getAccumulation(); # prints "2 + 2 * 4 + 5"
# get a PreOrder visitor
my $visitor = Tree::Binary::Visitor::PreOrderTraversal->new();
$btree->accept($visitor);
# print the expression in prefix order
print $visitor->getAccumulation(); # prints "* + 2 2 + 4 5"
# get a PostOrder visitor
my $visitor = Tree::Binary::Visitor::PostOrderTraversal->new();
$btree->accept($visitor);
# print the expression in postfix order
print $visitor->getAccumulation(); # prints "2 2 + 4 5 + *"
# get a Breadth First visitor
my $visitor = Tree::Binary::Visitor::BreadthFirstTraversal->new();
$btree->accept($visitor);
# print the expression in breadth first order
print $visitor->getAccumulation(); # prints "* + + 2 2 4 5"
# be sure to clean up all circular references
$btree->DESTROY();
This module is a fully object oriented implementation of a binary tree. Binary trees are a specialized type of tree which has only two possible branches, a left branch and a right branch. While it is possible to use an n-ary tree, like Tree::Simple, to fill most of your binary tree needs, a true binary tree object is just easier to mantain and use.
Binary Tree objects are especially useful (to me anyway) when building parse trees of things like mathematical or boolean expressions. They can also be used in games for such things as descisions trees. Binary trees are a well studied data structure and there is a wealth of information on the web about them.
This module uses exceptions and a minimal Design By Contract style. All method arguments are required unless specified in the documentation, if a required argument is not defined an exception will usually be thrown. Many arguments are also required to be of a specific type, for instance the $tree argument to both the setLeft and setRight methods, must be a Tree::Binary object or an object derived from Tree::Binary, otherwise an exception is thrown. This may seems harsh to some, but this allows me to have the confidence that my code works as I intend, and for you to enjoy the same level of confidence when using this module. Note however that this module does not use any Exception or Error module, the exceptions are just strings thrown with die.
This object uses a number of methods copied from another module of mine, Tree::Simple. Users of that module will find many similar methods and behaviors. However, it did not make sense for Tree::Binary to be derived from Tree::Simple, as there are a number of methods in Tree::Simple that just wouldnt make sense in Tree::Binary. So, while I normally do not approve of cut-and-paste code reuse, it was what made the most sense in this case.
Download (0.027MB)
Added: 2006-10-14 License: Perl Artistic License Price:
1108 downloads
Search::Binary 0.95
Search::Binary is a Perl module for generic binary search. more>>
Search::Binary is a Perl module for generic binary search.
SYNOPSIS
use Seach::Binary;
$pos = binary_search($min, $max, $val, $read, $handle, [$size]);
binary_search implements a generic binary search algorithm returning the position of the first record whose index value is greater than or equal to $val. The search routine does not define any of the terms position, record or index value, but leaves their interpretation and implementation to the user supplied function &$read(). The only restriction is that positions must be integer scalars.
During the search the read function will be called with three arguments: the input parameters $handle and $val, and a position. If the position is not undef, the read function should read the first whole record starting at or after the position; otherwise, the read function should read the record immediately following the last record it read. The search algorithm will guarantee that the first call to the read function will not be with a position of undef. The read function needs to return a two element array consisting of the result of comparing $val with the index value of the read record and the position of the read record. The comparison value must be positive if $val is strictly greater than the index value of the read record, 0 if equal, and negative if strictly less. Furthermore, the returned position value must be greater than or equal to the position the read function was called with.
The input parameters $min and $max are positions and represents the extent of the search. Only records which begin at positions within this range (inclusive) will be searched. Moreover, $min must be the starting position of a record. If present $size is a difference between positions and determines when the algorithms switches to a sequential search. $val is an index value. The value of $handle is of no consequence to the binary search algorithm; it is merely passed as a convenience to the read function.
<<lessSYNOPSIS
use Seach::Binary;
$pos = binary_search($min, $max, $val, $read, $handle, [$size]);
binary_search implements a generic binary search algorithm returning the position of the first record whose index value is greater than or equal to $val. The search routine does not define any of the terms position, record or index value, but leaves their interpretation and implementation to the user supplied function &$read(). The only restriction is that positions must be integer scalars.
During the search the read function will be called with three arguments: the input parameters $handle and $val, and a position. If the position is not undef, the read function should read the first whole record starting at or after the position; otherwise, the read function should read the record immediately following the last record it read. The search algorithm will guarantee that the first call to the read function will not be with a position of undef. The read function needs to return a two element array consisting of the result of comparing $val with the index value of the read record and the position of the read record. The comparison value must be positive if $val is strictly greater than the index value of the read record, 0 if equal, and negative if strictly less. Furthermore, the returned position value must be greater than or equal to the position the read function was called with.
The input parameters $min and $max are positions and represents the extent of the search. Only records which begin at positions within this range (inclusive) will be searched. Moreover, $min must be the starting position of a record. If present $size is a difference between positions and determines when the algorithms switches to a sequential search. $val is an index value. The value of $handle is of no consequence to the binary search algorithm; it is merely passed as a convenience to the read function.
Download (0.002MB)
Added: 2007-04-05 License: Perl Artistic License Price:
932 downloads
Convert::Binary::C 0.64
Convert::Binary::C is a Binary Data Conversion using C Types. more>>
Convert::Binary::C is a Binary Data Conversion using C Types.
SYNOPSIS
Simple
use Convert::Binary::C;
#---------------------------------------------
# Create a new object and parse embedded code
#---------------------------------------------
my $c = Convert::Binary::C->new->parse( DEC, day => 24 };
my $packed = $c->pack( Date, $date );
Advanced
use Convert::Binary::C;
use Data::Dumper;
#---------------------
# Create a new object
#---------------------
my $c = new Convert::Binary::C ByteOrder => BigEndian;
#---------------------------------------------------
# Add include paths and global preprocessor defines
#---------------------------------------------------
$c->Include( /usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include,
/usr/include )
->Define( qw( __USE_POSIX __USE_ISOC99=1 ) );
#----------------------------------
# Parse the time.h header file
#----------------------------------
$c->parse_file( time.h );
#---------------------------------------
# See which files the object depends on
#---------------------------------------
print Dumper( [$c->dependencies] );
#-----------------------------------------------------------
# See if struct timespec is defined and dump its definition
#-----------------------------------------------------------
if( $c->def( struct timespec ) ) {
print Dumper( $c->struct( timespec ) );
}
#-------------------------------
# Create some binary dummy data
#-------------------------------
my $data = "binaryteststring";
#--------------------------------------------------------
# Unpack $data according to struct timespec definition
#--------------------------------------------------------
if( length($data) >= $c->sizeof( timespec ) ) {
my $perl = $c->unpack( timespec, $data );
print Dumper( $perl );
}
#--------------------------------------------------------
# See which member lies at offset 5 of struct timespec
#--------------------------------------------------------
my $member = $c->member( timespec, 5 );
print "member( timespec, 5 ) = $membern";
Convert::Binary::C is a preprocessor and parser for C type definitions. It is highly configurable and should support arbitrarily complex data structures. Its object-oriented interface has pack and unpack methods that act as replacements for Perls pack and unpack and allow to use the C types instead of a string representation of the data structure for conversion of binary data from and to Perls complex data structures.
Actually, what Convert::Binary::C does is not very different from what a C compiler does, just that it doesnt compile the source code into an object file or executable, but only parses the code and allows Perl to use the enumerations, structs, unions and typedefs that have been defined within your C source for binary data conversion, similar to Perls pack and unpack.
Beyond that, the module offers a lot of convenience methods to retrieve information about the C types that have been parsed.
<<lessSYNOPSIS
Simple
use Convert::Binary::C;
#---------------------------------------------
# Create a new object and parse embedded code
#---------------------------------------------
my $c = Convert::Binary::C->new->parse( DEC, day => 24 };
my $packed = $c->pack( Date, $date );
Advanced
use Convert::Binary::C;
use Data::Dumper;
#---------------------
# Create a new object
#---------------------
my $c = new Convert::Binary::C ByteOrder => BigEndian;
#---------------------------------------------------
# Add include paths and global preprocessor defines
#---------------------------------------------------
$c->Include( /usr/lib/gcc-lib/i686-pc-linux-gnu/3.3.6/include,
/usr/include )
->Define( qw( __USE_POSIX __USE_ISOC99=1 ) );
#----------------------------------
# Parse the time.h header file
#----------------------------------
$c->parse_file( time.h );
#---------------------------------------
# See which files the object depends on
#---------------------------------------
print Dumper( [$c->dependencies] );
#-----------------------------------------------------------
# See if struct timespec is defined and dump its definition
#-----------------------------------------------------------
if( $c->def( struct timespec ) ) {
print Dumper( $c->struct( timespec ) );
}
#-------------------------------
# Create some binary dummy data
#-------------------------------
my $data = "binaryteststring";
#--------------------------------------------------------
# Unpack $data according to struct timespec definition
#--------------------------------------------------------
if( length($data) >= $c->sizeof( timespec ) ) {
my $perl = $c->unpack( timespec, $data );
print Dumper( $perl );
}
#--------------------------------------------------------
# See which member lies at offset 5 of struct timespec
#--------------------------------------------------------
my $member = $c->member( timespec, 5 );
print "member( timespec, 5 ) = $membern";
Convert::Binary::C is a preprocessor and parser for C type definitions. It is highly configurable and should support arbitrarily complex data structures. Its object-oriented interface has pack and unpack methods that act as replacements for Perls pack and unpack and allow to use the C types instead of a string representation of the data structure for conversion of binary data from and to Perls complex data structures.
Actually, what Convert::Binary::C does is not very different from what a C compiler does, just that it doesnt compile the source code into an object file or executable, but only parses the code and allows Perl to use the enumerations, structs, unions and typedefs that have been defined within your C source for binary data conversion, similar to Perls pack and unpack.
Beyond that, the module offers a lot of convenience methods to retrieve information about the C types that have been parsed.
Download (1.3MB)
Added: 2006-07-05 License: Perl Artistic License Price:
1208 downloads
cg binary downloader 0.4
cg is a semi-automatic newsgroup binary downloader. more>>
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
<<lesscg 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
Download (0.16MB)
Added: 2006-06-20 License: GPL (GNU General Public License) Price:
1222 downloads
Tree::Binary::Search 0.07
Tree::Binary::Search is a binary search tree for Perl. more>>
Tree::Binary::Search is a binary search tree for Perl.
SYNOPSIS
use Tree::Binary::Search;
my $btree = Tree::Binary::Search->new();
$btree->useNumericComparison();
$btree->insert(5 => "Five");
$btree->insert(2 => "Two");
$btree->insert(1 => "One");
$btree->insert(3 => "Three");
$btree->insert(4 => "Four");
$btree->insert(9 => "Nine");
$btree->insert(8 => "Eight");
$btree->insert(6 => "Six");
$btree->insert(7 => "Seven");
# this creates the following tree:
#
# +-------(5)----------+
# | |
# +-(2)-+ +-(9)
# | | |
# (1) (3)-+ +----(8)
# | |
# (4) (6)-+
# |
# (7)
#
$btree->exists(7); # return true
$btree->update(7 => "Seven (updated)");
$btree->select(9); # return Nine
$btree->min_key(); # returns 1
$btree->min(); # returns One
$btree->max_key(); # return 9
$btree->max(); # return Nine
$btree->delete(5);
# this results in the following tree:
#
# +-------(6)-------+
# | |
# +-(2)-+ +-(9)
# | | |
# (1) (3)-+ +-(8)
# | |
# (4) (7)
#
This module implements a binary search tree, which is a specialized usage of a binary tree. The basic principle is that all elements to the left are less than the root, all elements to the right are greater than the root. This reduces the search time for elements in the tree, by halving the number of nodes that need to be searched each time a node is examined.
Binary search trees are a very well understood data-structure and there is a wealth of information on the web about them.
Trees are a naturally recursive data-structure, and therefore, tend to lend themselves well to recursive traversal functions. I however, have chosen to implement the tree traversal in this module without using recursive subroutines. This is partially a performance descision, even though perl can handle theoreticaly unlimited recursion, subroutine calls to have some overhead. My algorithm is still recursive, I have just chosen to keep it within a single subroutine.
<<lessSYNOPSIS
use Tree::Binary::Search;
my $btree = Tree::Binary::Search->new();
$btree->useNumericComparison();
$btree->insert(5 => "Five");
$btree->insert(2 => "Two");
$btree->insert(1 => "One");
$btree->insert(3 => "Three");
$btree->insert(4 => "Four");
$btree->insert(9 => "Nine");
$btree->insert(8 => "Eight");
$btree->insert(6 => "Six");
$btree->insert(7 => "Seven");
# this creates the following tree:
#
# +-------(5)----------+
# | |
# +-(2)-+ +-(9)
# | | |
# (1) (3)-+ +----(8)
# | |
# (4) (6)-+
# |
# (7)
#
$btree->exists(7); # return true
$btree->update(7 => "Seven (updated)");
$btree->select(9); # return Nine
$btree->min_key(); # returns 1
$btree->min(); # returns One
$btree->max_key(); # return 9
$btree->max(); # return Nine
$btree->delete(5);
# this results in the following tree:
#
# +-------(6)-------+
# | |
# +-(2)-+ +-(9)
# | | |
# (1) (3)-+ +-(8)
# | |
# (4) (7)
#
This module implements a binary search tree, which is a specialized usage of a binary tree. The basic principle is that all elements to the left are less than the root, all elements to the right are greater than the root. This reduces the search time for elements in the tree, by halving the number of nodes that need to be searched each time a node is examined.
Binary search trees are a very well understood data-structure and there is a wealth of information on the web about them.
Trees are a naturally recursive data-structure, and therefore, tend to lend themselves well to recursive traversal functions. I however, have chosen to implement the tree traversal in this module without using recursive subroutines. This is partially a performance descision, even though perl can handle theoreticaly unlimited recursion, subroutine calls to have some overhead. My algorithm is still recursive, I have just chosen to keep it within a single subroutine.
Download (0.027MB)
Added: 2007-07-21 License: Perl Artistic License Price:
825 downloads
Scriptol to binary Compiler
Scriptol to binary Compiler is a C++ native compiler. more>>
Scriptol to binary Compiler is a C++ native compiler.
Installation:
It is better to install Scriptol at root of a disk, for example:
c:scriptolc
Once the archive is extracted into the scriptolc directory, you have just to change to this directory to run the compiler.
To use the compiler at command line from any directory, you have to put the compiler into the path variable.
The setup script installs required file into sub-directories, or into the directory given as argument. Before to use the compiler, you have to read the licence, in the doc
directory: licence.html.
Usage:
Just type:
./solc mysource
Type "solc" only to list the options.
If your program is a multi-file project, the source given as parameter must be the main source file, the compiler will know dependencies from "include" statements and will build what is needed.
Exemples:
Type from the main scriptol directory:
./solc -bre demosfibo
Configuring:
By editing the solc.ini file, you may change the second pass compiler (you may have to rebuild the libsol library for this compiler), change the options of the compiler or add header files to include.
To add header files, just add "header=someheader.hpp" lines into the config file.
A xxx.cfg file may be written for each project main source beeing xxx, and if present, it overloads the solc.ini file.
<<lessInstallation:
It is better to install Scriptol at root of a disk, for example:
c:scriptolc
Once the archive is extracted into the scriptolc directory, you have just to change to this directory to run the compiler.
To use the compiler at command line from any directory, you have to put the compiler into the path variable.
The setup script installs required file into sub-directories, or into the directory given as argument. Before to use the compiler, you have to read the licence, in the doc
directory: licence.html.
Usage:
Just type:
./solc mysource
Type "solc" only to list the options.
If your program is a multi-file project, the source given as parameter must be the main source file, the compiler will know dependencies from "include" statements and will build what is needed.
Exemples:
Type from the main scriptol directory:
./solc -bre demosfibo
Configuring:
By editing the solc.ini file, you may change the second pass compiler (you may have to rebuild the libsol library for this compiler), change the options of the compiler or add header files to include.
To add header files, just add "header=someheader.hpp" lines into the config file.
A xxx.cfg file may be written for each project main source beeing xxx, and if present, it overloads the solc.ini file.
Added: 2005-12-02 License: Freeware Price:
1423 downloads
Parse::Binary::FixedFormat 0.10
Parse::Binary::FixedFormat is a Perl module to convert between fixed-length fields and hashes. more>>
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.
<<lessSYNOPSIS
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.
Download (0.031MB)
Added: 2006-08-09 License: Perl Artistic License Price:
1171 downloads
Java Binary Enhancement Tool 3 R1
Java Binary Enhancement Tool is a Java assembler, dissassembler, and binary editor. more>>
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.
<<lessJBET 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.
Download (0.19MB)
Added: 2005-03-07 License: BSD License Price:
1697 downloads
Parse::Binary::FixedFormat::Variants 0.10
Parse::Binary::FixedFormat::Variants is a Perl module to convert between variant records and hashes. more>>
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.
<<lessParse::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.
Download (0.031MB)
Added: 2006-08-23 License: Perl Artistic License Price:
1158 downloads
BNR 0.14.7
BNR is a news reader software specifically tailored for binary articles more>>
BNR is a news reader software specifically tailored for binary articles. BNR downloads and decodes binary articles and saves them on your hard drive to the directory of your choice.BNR can download and decode only binary articles and can save them to the hard drive.. BNR can also download text articles, but other news readers are probably better suited to this task. BNR will run on PC hardware running either Windows or Linux operating systems.
Main features:
- support for multiple news servers simultaneously
- checking for file existence before you start downloading an article
- plugin support
- article download optimization
- header download optimization
- connect-on-demand
- internal JPEG viewer
- newsgroup-specific settings
- customizable interface
Version restrictions:
- does not support reply threads
- does not (at least for now) support article posting
<<lessMain features:
- support for multiple news servers simultaneously
- checking for file existence before you start downloading an article
- plugin support
- article download optimization
- header download optimization
- connect-on-demand
- internal JPEG viewer
- newsgroup-specific settings
- customizable interface
Version restrictions:
- does not support reply threads
- does not (at least for now) support article posting
Download (0.94MB)
Added: 2006-06-06 License: Freely Distributable Price:
1241 downloads
Jdelay
Jdelay project is a small JACK app you can use to measure the latency of your sound card. more>>
Jdelay project is a small JACK app you can use to measure the latency of your sound card.
It uses a phase measurements on a set of tones to measure the delay from the output to the input. Accuracy is about 1/1000 of a sample.
Installation:
To install, cd to this directory and make.
Copy the binary to your preferred location.
<<lessIt uses a phase measurements on a set of tones to measure the delay from the output to the input. Accuracy is about 1/1000 of a sample.
Installation:
To install, cd to this directory and make.
Copy the binary to your preferred location.
Download (0.003MB)
Added: 2006-02-03 License: GPL (GNU General Public License) Price:
1358 downloads
UbuntuTrinux
UbuntuTrinux seeks to integrate elements of Trinux with the Debian/Ubuntu mkinitramfs infrastructure. more>>
UbuntuTrinux seeks to integrate elements (and code, where appropriate) of Trinux with the Debian/Ubuntu mkinitramfs infrastructure to allow easy development and packaging Ubuntu binary (and ultimately package and repository) compatible ramdisk distributions using recent 2.6.x kernels. As before, the most common use is network security monitoring and analysis.
Trinux: A Linux Security Toolkit was a ramdisk-based Linux distribution that was under active development from 1998-2003.
<<lessTrinux: A Linux Security Toolkit was a ramdisk-based Linux distribution that was under active development from 1998-2003.
Download (6.3MB)
Added: 2007-07-02 License: GPL (GNU General Public License) Price:
850 downloads
wmBinClock 0.3
wmBinClock shows the actual system time as binary clock. more>>
wmBinClock shows the actual system time as binary clock. You have to add up the "bits" to get the time. The clock has a 24 hour format.
Example:
+ + + + + +<<less
Example:
+ + + + + +<<less
Download (0.014MB)
Added: 2005-10-10 License: GPL (GNU General Public License) Price:
1474 downloads
edanator 1.03
edanator is an intuitive graphical binary and hex calculator. more>>
edanator is an intuitive graphical binary and hex calculator. Each nibble is displayed in hex and binary. Clicking on the button (hex nibble or binary bit) changes the value. Bit and nibble shifting is supported via dedicated buttons. The project supports variable widths per word (up to 64- bits), three words (each on a different row), and mathematical operations between words.
Enhancements:
- An endian-ness button for swapping bit labels was added along with a bit reverse function.
<<lessEnhancements:
- An endian-ness button for swapping bit labels was added along with a bit reverse function.
Download (0.007MB)
Added: 2007-03-27 License: LGPL (GNU Lesser General Public License) Price:
944 downloads
Secleted [ 0 ] software to compare
Copyright Notice:
Software piracy is theft, Using crack, password, serial numbers, registration codes, key generators is illegal and prevent future software development. The above binary search only lists software in full, demo and trial versions for free download. Download links are directly from our mirror sites or publisher sites, torrent files or links from rapidshare.com, yousendit.com or megaupload.com are not allowed
