Free bin to hex software for linux

Hex-a-hop is a puzzle game based on hexagonal tiles. There is no time limit and no real-time elements.

The objective is simply to destroy all the green hexagonal tiles on each of the 100 levels. As you progress through the game, more types of tiles are introduced which make things more difficult and interesting (hopefully).

The project is built on top of SDL, which is an open-source layer for direct media access.

Convert::BinHex can extract data from Macintosh BinHex files.

ALPHA WARNING: this code is currently in its Alpha release. Things may change drastically until the interface is hammered out: if you have suggestions or objections, please speak up now!

SYNOPSIS

Simple functions:

use Convert::BinHex qw(binhex_crc macbinary_crc);

# Compute HQX7-style CRC for data, pumping in old CRC if desired:
$crc = binhex_crc($data, $crc);

# Compute the MacBinary-II-style CRC for the data:
$crc = macbinary_crc($data, $crc);

Hex to bin, low-level interface. Conversion is actually done via an object ("Convert::BinHex::Hex2Bin") which keeps internal conversion state:
# Create and use a "translator" object:
my $H2B = Convert::BinHex->hex2bin; # get a converter object
while (< STDIN >) {
print $STDOUT $H2B->next($_); # convert some more input
}
print $STDOUT $H2B->done; # no more input: finish up

Hex to bin, OO interface. The following operations must be done in the order shown!
# Read data in piecemeal:
$HQX = Convert::BinHex->open(FH=>*STDIN) || die "open: $!";
$HQX->read_header; # read header info
@data = $HQX->read_data; # read in all the data
@rsrc = $HQX->read_resource; # read in all the resource

Bin to hex, low-level interface. Conversion is actually done via an object ("Convert::BinHex::Bin2Hex") which keeps internal conversion state:
# Create and use a "translator" object:
my $B2H = Convert::BinHex->bin2hex; # get a converter object
while (< STDIN >) {
print $STDOUT $B2H->next($_); # convert some more input
}
print $STDOUT $B2H->done; # no more input: finish up

Bin to hex, file interface. Yes, you can convert to BinHex as well as from it!
# Create new, empty object:
my $HQX = Convert::BinHex->new;

# Set header attributes:
$HQX->filename("logo.gif");
$HQX->type("GIFA");
$HQX->creator("CNVS");

# Give it the data and resource forks (either can be absent):
$HQX->data(Path => "/path/to/data"); # here, data is on disk
$HQX->resource(Data => $resourcefork); # here, resource is in core

# Output as a BinHex stream, complete with leading comment:
$HQX->encode(*STDOUT);

PLANNED!!!! Bin to hex, "CAP" interface. Thanks to Ken Lunde for suggesting this.
# Create new, empty object from CAP tree:
my $HQX = Convert::BinHex->from_cap("/path/to/root/file");
$HQX->encode(*STDOUT);

BinHex is a format used by Macintosh for transporting Mac files safely through electronic mail, as short-lined, 7-bit, semi-compressed data streams. Ths module provides a means of converting those data streams back into into binary data.

galculator is a GTK 2 based calculator with ordinary notation/reverse polish notation, a formula entry mode, different number bases (OCT, HEX, DEC, BIN) and different units of angular measure (DEG, RAD, GRAD).
[a basic calculator] galculator features two user modes: basic and scientific mode. Basic mode is intended for simple computations. Only the most important operations and functions are available in algebraic mode as well as in Reverse Polish Mode. Formula entry, available for the basic as well as for the more sophisticated scientific mode, aims to make the calculator even more user friendlier: type as you would write on a paper!
[a scientific calculator] Scientific Mode is galculators state-of-the-art. It supports different number bases (DEC/HEX/OCT/BIN) and angle units (DEG/RAD/GRAD) and features a wide range of mathematical (basic arithmetic operations, trigonometric functions, etc), other useful functions (memory, etc) and user defined functions. Of course, algebraic mode as well as Reverse Polish Notation are available. See below for a detailed list of supported functions.
[a GTK 2 based calculator] galculator is written entirely in C and uses GTK version 2. Especially the display takes big advantages of the new possibilities in GTK 2. Have a look at the screenshots section to see what Im talking about.
[why another calculator] Some time ago, I was looking for a GTK based calulator. Nothing special, just for simple computations. But I wasnt able to find one. This application lacked full keypad support, that one didnt know hexadecimal numbers. Therefore I decided to write my own calculator application with all the features Id expected others to have.
Main features:
- Algebraic mode, RPN (Reverse Polish Notation) and Formula Entry mode
- decimal, hexadecimal, octal and binary number base
- radiant, degree and grad support
- arithmetic precedence
- Basic and Scientific Mode
- user defined constants
- user defined functions
- trigonometric functions
- power, sqare root
- natural and common logarithm
- inverse and hyperbolic functions
- memory functions
- logical operations
- display RPN stack
- preferences dialog/configuration file
- display modules
- X pasting
- i18n
- configurable variable type in HEX/BIN/OCT mode
- thousands separator

rcheck is a tool that will allow you to check the status of one or more accounts on one or more RealizationEngines. rcheck is written in Perl, requires LWP::Simple and Digest::MD5 and Tk.

rcheck is intended to be a demonstration for creating clients that can check for and report new messages.

The status for an account can be requested by the following URL:

http://www.your_re.com/cgi-bin/re_status.cgi?status=username

this will return the results in the form:

total_messages:todays_messages:new_messages

Example: 100:10:2

The results are XORed against the MD5 digest (hex) of the users password before being sent so that the results are "lightly" encrypted. The results are trimmed to the length of the output only.

After receiving the encrypted result string from the server, take the MD5 digest (hex) of the users password, trim it to the same length as the status string and XOR the two against each other. This will give the plaintext of the status message.

rcheck only reports new messages since last session, and the other two numbers are tossed in the trash.

rcheck stores a file called .rcheck2 in the local directory with account information (passwords encrypted).

radare is a toolchain that aims to create a complete set of utilities for handling binary files from the command line. The project is mainly an hexadecimal editor for the command line but with advanced features.
There are extensions for debugging processes on x86-32 and ARM, libusb and fd sniffers, binary diffing utilities, base format conversions, generating graphs of a program, A cross-platform disassembler as an objdump frontend, and more.
Enhancements:
- A new search engine. I/O plugin layers (debugging, Haret, and POSIX). Debugging on NetBSD.
- Arguments to the debugged process (radare "dbg:///bin/ls /usr").
- Base address (B command). xc now can convert from stdin binary data to hex pairs.
- Date format string and filetime (NTFS) support.
- Non-readline interface fixes (more orthogonalized).
- Wide-char support (reading and writing 00 filled strings).
- Fixes in the visual mode.
- The debugger can backtrace on Linux/x86 (needs more work).
- New xor/xorpair hashing algorithms for hasher.

FindBin is a Perl module that can locate directory of original perl script.

SYNOPSIS

use FindBin;
use lib "$FindBin::Bin/../lib";

or

use FindBin qw($Bin);
use lib "$Bin/../lib";

Locates the full path to the script bin directory to allow the use of paths relative to the bin directory.

This allows a user to setup a directory tree for some software with directories < root >/bin and < root >/lib, and then the above example will allow the use of modules in the lib directory without knowing where the software tree is installed.
If perl is invoked using the -e option or the perl script is read from STDIN then FindBin sets both $Bin and $RealBin to the current directory.

EXPORTABLE VARIABLES

$Bin - path to bin directory from where script was invoked
$Script - basename of script from which perl was invoked
$RealBin - $Bin with all links resolved
$RealScript - $Script with all links resolved

Pasmo project is a Z80 cross assembler, written in standard C++ that compiles easily in multiple platforms. Actually can generate object code in the following formats: raw binary, Intel HEX, PRL for CP/M Plus RSX, Plus3Dos (Spectrum +3 disk), TAP, TZX and CDT (Spectrum and Amstrad CPC emulators tape images), AmsDos (Amstrad CPC disk) and MSX (for use with BLOAD from disk in Basic).
Starting with version 0.5.0, can also generate 8086 code from Z80 sources, in binary format for Ms-dos COM files or in CP/M 86 CMD format.
Pasmo is a multiplatform Z80 cross-assembler, easy to compile and easy to use. It can generate object code in several formats suitable for many Z80 machines and emulators.
Pasmo generates fixed position code, can not be used to create relocatable object files for use with linkers.
Pasmo is compatible with the syntax used in several old assemblers, by supporting several styles of numeric and string literals and by providing several names of the most used directives.
However, in Pasmo the Z80 mnemonics, register and flags names and directives are reserved words, this may require changes of symbol names conflicting in some programs.
Pasmo can also generate the 8086 equivalent to the z80 assembly code. It can create COM files for ms-dos, by using the binary generation mode, or CMD files for CP/M 86, by using the --cmd generation mode. This feature is experimental, use with care.
Installation:
To compile you need gcc version 2.95 or later, with the c++ language included (usually a package called g++-something).
Others compilers may also be used, any reasonable standard complaint c++ compiler must compile it with few or none corrections.
Just execute make in the pasmo directory, and the excutable will be generated. There is no install, you must manually copy the executable to a directory in the PATH, if you want.
Pasmo is invoked from command line as:
pasmo [options] file.asm file.bin [file.symbol [file.publics] ]
Where file.asm is the source file, file.bin is the object file to be created and optionally file.symbol is the file where the symbol table will be written and file.publics is the file for the public symbols table. Both symbol file names can be an empty string for no generation or - to write in the standard output. When the --public option is used this is handled in another way, see below.
Options can be zero or more of the following:
-d
Show debug info during second pass of assembly.
-1 (digit one)
Show debug info during both passes of assembly.
-8
Same as --w8080
-v
Verbose mode. Show progress information about loading of files, progress of assembly and maybe other things.
-I (upper case i)
Add directory to the list for searching files in INCLUDE and INCBIN.
-B
Same as --bracket
-E
Same as --equ
--86
Generate 8086 code instead of Z80. This feature is experimental.
--bin
Generate the object file in raw binary format without headers.
--hex
Generate the object file in Intel HEX format.
--prl
Generate the object file in CP/M PRL format.
--cmd
Generate the object file in CP/M 86 CMD format.
--tap
Generate the object file in .tap format.
--tzx
Generate the object file in .tzx format.
--cdt
Generate the object file in .cdt format.
--tapbas
Same as --tap but adding a Basic loader before the code.
--tzxbas
Same as --txz but adding a Basic loader before the code.
--cdtbas
Same as --cdt but adding a Basic loader before the code.
--plus3dos
Generate the object file in PLUS3DOS format.
--amsdos
Generate the object file in Amsdos format.
--msx
Generate the object file in MSX format.
--public
Only the public symbols table is generated, using the file.symbol name, file.symbol must not be specified when using this option.
--name
Name to put in the header in the formats that use it. If unspecified the object file name will be used.
--err
Direct error messages to standard output instead of error output (except for errors in options).
--nocase
Make identifiers case insensitive.
--alocal
Use autolocal mode. In this mode all labels that begins with _ are locals. See the chapter about labels for details.
--bracket
Use bracket only mode. In this mode the parenthesis are valid only in expressions, for indirections brackets must be used.
--equ
Predefine a symbol. Predefined symbol are treated in a similar way as defineds with EQU. Some possible uses are exemplified in the black.asm example file. The syntax is: --equ label=value where label must be a valid label name and value a numeric constant in a format valid in pasmo syntax. The part =value is optional, if not specified the value asigned is FFFF hex.
--w8080
Show warnings when Z80 instructions that have no equivalent in 8080 are used. Makes easy to write programs for 8080 processor using Z80 assembler syntax.
When no option for code generation is specified, --bin is used by default.
The -d option is intended to debug pasmo itself, but can also be useful to find errors in asm code. When used the information is showed in the standard output. Error messages goes to error ouptut unless the --err option is used.
Enhancements:
- This release fixes several bugs and adds warnings for unused LOCAL and PUBLIC symbols.

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.