Free runescape hex editor software for linux

Redbox13 CSS-editor software offers a way for webmasters to modify their css files in their webbrowser. It also uses a third party program called Editarea.
Main features:
- Create CSS in your native language.
- Categorize your elements.
- Compress CSS Files, remove those useless line breaks, tabs & double spaces.. On a 700 bytes css file it can sometimes save about 100 bytes.
- Use css files for database purposes.
- Independent function library that you can use very easily to parse css files to 3d php arrays.
- Identify & memorize color codes, click a memorized color and the color-hex code is sent to the edit field with one mouse click.
- Offers a solution to browser incompatibility problems.

Necromancers Dos Navigator is a "Norton Commander" clone. Necromancers Dos Navigator uses a well known text-mode interface, is highly customizable, and has a lot of features.
Main features:
- Long File Names Support
- Multi-windowed interface
- Disk utilities
- Comprehensive File Manager
- 26 types of archives supported
- Powerful customizable editor with 3 code pages support
- Hex-editor with code pages support
- Huge strings support
- Regular expressions
- Spreadsheet communications
- Fully 32 bit version
- Multiconfiguration
- Very often updates
- and more...
Enhancements:
- This release contains bugfixes and enhancements to extension execution, archiver setup, dialogs, the DBF viewer, the command line, file copy/move, VFS, the file panel, and keyboard macro code.

Sparklines are intense, simple, wordlike graphics.
Theres a PHP library for producing sparklines, and even a sparkline web service, but I wanted something I could use to generate sparklines in both Java and JSTL (and I thought it would be a fun project). (Its also worth checking out Whys minimalist python sparklines, which encode the image data directly in the HTML as a data: URI [this library allows you to encode the images as using either data: format or javascript: format (supported by IE) in JSTL])
JSTL examples
< %@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" % >
< %@ taglib prefix="spark" uri="http://www.representqueens.com/taglibs/spark" % >
< c:set var="test" value="5, 35, 22, 19, 16, 10, 4, 33, 9, 12, 27, 36, 22" / >
< img src="< spark:bar name="test" color="red" / >" / >
will produce:
(I think the default size might be a little large).
The "name" attribute specifies the key to find the data (Uses JspContext.findAttribute). It expects the value to be either a List , a Number[], or a String of comma separated int values. Its the only manditory attribute.
The other attributes are width, height, spacing, color, highColor, lastColor, output. You can replace "bar" with "line" to get a linegraph (note: highColor and lastColor are currently not supported for line graphs).
The color attributes can either be a color name (a field name from java.awt.Color), or a HTML hex color (e.g. #ff0000 for red).
Enhancements:
- This release properly URL encodes parameters for server generated sparklines.
- This fixes an issue when using hex specified image colors.
- The tag parameter "background" has been added as a workaround for IE6 PNG transparency.

YAPE::Regex::Element contains sub-classes for YAPE::Regex elements.

SYNOPSIS

use YAPE::Regex MyExt::Mod;
# this sets up inheritence in MyExt::Mod
# see YAPE::Regex documentation

YAPE MODULES

The YAPE hierarchy of modules is an attempt at a unified means of parsing and extracting content. It attempts to maintain a generic interface, to promote simplicity and reusability. The API is powerful, yet simple. The modules do tokenization (which can be intercepted) and build trees, so that extraction of specific nodes is doable.

Methods for YAPE::Regex::Element

This class contains fallback methods for the other classes.
my $str = $obj->text;
Returns a string representation of the content of the regex node itself, not any nodes contained in it. This is undef for non-text nodes.
my $str = $obj->string;
Returns a string representation of the regex node itself, not any nodes contained in it.
my $str = $obj->fullstring;
Returns a string representation of the regex node, including any nodes contained in it.
my $quant = $obj->quant;
Returns a string with the quantity, and a ? if the node is non-greedy. The quantity is one of *, +, ?, {M,N}, or an empty string.
my $ng = $obj->ngreed;
Returns a ? if the node is non-greedy, and an empty string otherwise.

Methods for YAPE::Regex::anchor

This class represents anchors. Objects have the following methods:
my $anchor = YAPE::Regex::anchor->new($type,$q,$ng);
Creates a YAPE::Regex::anchor object. Takes three arguments: the anchor (^, A, $, Z, z, B, b, or G), the quantity, and the non-greedy flag. The quantity should be an empty string.
my $anc = YAPE::Regex::anchor->new(A, , ?);
# /A?/
my $type = $anchor->type;
Returns the string anchor.
Methods for YAPE::Regex::macro
This class represents character-class macros. Objects have the following methods:
my $macro = YAPE::Regex::macro->new($type,$q,$ng);
Creates a YAPE::Regex::macro object. Takes three arguments: the macro (w, W, d, D, s, or S), the quantity, and the non-greedy flag.
my $macro = YAPE::Regex::macro->new(s, {3,5});
# /s{3,5}/
my $text = $macro->text;
Returns the macro.
print $macro->text; # s
my $type = $macro->type;
Returns the string macro.

Methods for YAPE::Regex::oct

This class represents octal escapes. Objects have the following methods:
my $oct = YAPE::Regex::oct->new($type,$q,$ng);
Creates a YAPE::Regex::oct object. Takes three arguments: the octal number (as a string), the quantity, and the non-greedy flag.
my $oct = YAPE::Regex::oct->new(040);
# / 40/
my $text = $oct->text;
Returns the octal escape.
print $oct->text; # 40
my $type = $oct->type;
Returns the string oct.

Methods for YAPE::Regex::hex

This class represents hexadecimal escapes. Objects have the following methods:
my $hex = YAPE::Regex::hex->new($type,$q,$ng);
Creates a YAPE::Regex::hex object. Takes three arguments: the hexadecimal number (as a string), the quantity, and the non-greedy flag.
my $hex = YAPE::Regex::hex->new(20,{2,});
# /x20{2,}/
my $text = $hex->text;
Returns the hexadecimal escape.
print $hex->text; # x20
my $type = $hex->type;
Returns the string hex.

Methods for YAPE::Regex::utf8hex

This class represents UTF hexadecimal escapes. Objects have the following methods:
my $hex = YAPE::Regex::utf8hex->new($type,$q,$ng);
Creates a YAPE::Regex::utf8hex object. Takes three arguments: the hexadecimal number (as a string), the quantity, and the non-greedy flag.
my $utf8hex = YAPE::Regex::utf8hex->new(beef,{0,4});
# /x{beef}{2,}/
my $text = $utf8hex->text;
Returns the hexadecimal escape.
print $utf8hex->text; # x{beef}
my $type = $utf8hex->type;
Returns the string utf8hex.

Methods for YAPE::Regex::backref

This class represents back-references. Objects have the following methods:
my $bref = YAPE::Regex::bref->new($type,$q,$ng);
Creates a YAPE::Regex::bref object. Takes three arguments: the number of the back-reference, the quantity, and the non-greedy flag.
my $bref = YAPE::Regex::bref->new(2,,?);
# /2?/
my $text = $bref->text;
Returns the backescape.
print $bref->text; # 2
my $type = $bref->type;
Returns the string backref.

Methods for YAPE::Regex::ctrl

This class represents control character escapes. Objects have the following methods:
my $ctrl = YAPE::Regex::ctrl->new($type,$q,$ng);
Creates a YAPE::Regex::ctrl object. Takes three arguments: the control character, the quantity, and the non-greedy flag.
my $ctrl = YAPE::Regex::ctrl->new(M);
# /cM/
my $text = $ctrl->text;
Returns the control character escape.
print $ctrl->text; # cM
my $type = $ctrl->type;
Returns the string ctrl.

Methods for YAPE::Regex::named

This class represents named characters. Objects have the following methods:
my $ctrl = YAPE::Regex::named->new($type,$q,$ng);
Creates a YAPE::Regex::named object. Takes three arguments: the name of the character, the quantity, and the non-greedy flag.
my $named = YAPE::Regex::named->new(GREEK SMALL LETTER BETA);
# /N{GREEK SMALL LETTER BETA}/
my $text = $named->text;
Returns the character escape text.
print $named->text; # N{GREEK SMALL LETTER BETA}
my $type = $named->type;
Returns the string named.

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.

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.

ethtool is a Linux net driver diagnostic and tuning tool for the Linux 2.4.x (or later) series of kernels. You can obtain information and diagnostics related to media, link status, driver version, PCI (or other) bus location, and more.
Enhancements:
- This release fixes handling of statistics where the label is exactly 32 bytes.
- It adds the ability to change the advertised speed/duplex to a different range of values, rather than all-or-one.
- It adds/updates register dump support for ixgb, sky2, Fabric7 VIOC, e1000, r8169, and SMSC LAN911x/LAN921x.
- It adds the ability to decode raw register dump stored in a file.
- It adds the ability to force hex register dump.
- Additional 10Gbps support is included. 2.5G support is included.
- The internal ethtool.h has been synchronized with upstream kernel 2.6.23-rc1.

hexdump produces a CP/M-like format by default, and can handle EBCDIC. It is internationalized, and has many formatting functions.
This hex dumper was born because
a) od octal format is appallingly ugly
b) od -x aint much better
c) I needed to dump EBCDIC files from SNA sessions
d) I needed to dump single blocks of files offset into the file.
If any of these describes your universe, youll like it too. The format resembles a CP/M or MS/DOS DEBUG dump screen. There is nothing UNIX-specific in the source, it should work OK under any C with a stdio.h library.
Enhancements:
- Source RPMs no longer depend on --define myversion