Free 1.12 maphack software for linux

sixbs is a library capable of writing and reading beans to and from XML using their public properties. sixbs is especially suited for writing configuration data or sending data over the network.

Contrary to normal Java serialization it is readable (i.e., you can easily edit it with your favourite text editor), and it is independent from class versions.

gmuck assists you in producing valid (X)HTML by checking CGI scripts, XSL stylesheets, templates, normal HTML files or [you name it] and reporting errors that it finds. The project is not a replacement for real validation tools, but is handy in quick checks and in situations where validation of the actual markup is troublesome.

gmuck assists you in producing valid (X)HTML by checking CGI scripts, XSL stylesheets, templates, normal HTML files or [you name it] and reporting errors that it finds.

It is not a replacement for real validation tools, but is handy in quick checks and in situations where validation of the actual generated markup is troublesome.

gmuck is a line-oriented tool. Because of that, its structural checking capabilities are limited, but it makes an attempt to report syntactical errors as well as provides some lint-like features.

There gmuck distribution consists of the "HTML::GMUCK" module and the "gmuck" command line interface to it.

See the gmuck(1) and HTML::GMUCK(3) manual pages (or before installation, "perldoc bin/gmuck.pod" and "perldoc lib/HTML/GMUCK.pod" in the dir where you unpacked gmuck), and ChangeLog, TODO and BUGS files for more information.

gmuck is short for Generated MarkUp ChecKer, or Generated MUCK if you like. Hmph, thats actually ambiguous, see above for a better explanation. But gmuck sounds cool

bsnmp is a miniSNMP daemon. For a couple of projects that involved controlling software on a couple of machines from a single controlling machine I decided to use SNMP. After looking at several available SNMP implementations I started to implement my own SNMP stuff, because what was available was not really what I needed (for several reasons). The result of this work is bsnmp.

bsnmp consists of the following pieces:
a library libbsnmp that includes ASN.1 handling, the SNMP protocol version V1 and V2C and a number of helper stuff to simplify writing of SNMP agents and clients.
the gensnmptree tool that generates the C- and H-files from an object hierarchy description (.def file).
the gensnmpdef tool that generates an initial .def file from a MIB. This requires the libsmi library.
bsnmpd - the SNMP daemon.
snmp_mibII - an implementation of the standard MIB-II sub-tree.
snmp_ntp - a partial implementation of the experimental NTP MIB.

The bsnmpd daemon implements just the bare minimum that is needed for such a daemon: the system group, parts of the SNMP group and a private tree that does the following:

handling of loadable modules. This allows loading/unloading parts of the tree at runtime or configuration time.
handling of communities. A table that allows loaded modules to create new communities at run-time (ILMI is a consumer of this). This table can be disabled for obvious reasons.
handling trap destinations for V1.
several configuration parameters like the protocol versions to handle, buffer sizes and so on.
tables that manage the UDP and local unix ports the daemon is listening on.
statistics and debugging
All real functionality is implemented via loadable modules and hence the daemon can be used for remote-control functions that have nothing to do with network management.

Xoscope (or oscope) is a digital oscilloscope using input from a sound card or EsounD and/or a ProbeScope/osziFOX.

Xoscopes features include 8 simultaneous signal displays, 1 us/div to 2 s/div time scale, built-in and external math functions including inverse, sum, diff, avg, xy, and FFT, 23 memory buffers, 5 automatic measurements, and file save/load.

qmqtool is a qmail queue manipulation program geared towards the viewing and safe modification of the contents in a qmail queue.
qmqtool may be copied and distributed under the terms found in the Perl "Artistic License". A copy of this license may be found in the standard Perl distribution, or in the file "Artistic".
qmqtool was designed with Michele Beltrames "qmHandle" in mind, however no source code from qmHandle was used within qmqtool.
qmqtool is significantly faster than qmHandle 1.2.0 on my system, even though it has more work to do (such as examining the todo queue):
> time qmqtool -s
Messages in local queue: 0
Messages in remote queue: 0
Messages in todo queue: 0
real 0m0.777s
user 0m0.650s
sys 0m0.110s
> time qmHandle -s
Messages in local queue: 0
Messages in remote queue: 0
real 0m3.746s
user 0m3.110s
sys 0m0.360s
Notes:
This program makes use of several shell utilities, such as "ps" and "grep". Please ensure the syntax to these utilities are correct for your operating system (i.e. ps -ef vs ps auxc). Also note that GNUs grep is much faster than Solariss grep, so you should consider telling qmqtool to use it, as your searches (with -f) will be about five times faster. GNU grep can also use a pipe as a logical OR (i.e. qmqtool -f this|that).
qmqtool supports many arguments, each which must be used separately unless specifically allowed. All syntax is described with qmqtool -h.
Enhancements:
- This release adds -S support for seeing bytes queued per IP (similar to -i).

Rats! is an easily extensible parser generator for C-like languages; though currently it only generates parsers in Java. Rats! project has been explicitly designed so that grammars are concise and easily modifiable. To this end, Rats!
- organizes grammars into modules,
- builds on parsing expression grammars instead of context-free grammars and vintegrates lexing with parsing, i.e., is scannerless,
- supports the automatic generation of abstract syntax trees,
- and provides a well-defined interface for extending parsers to recognize context-sensitive languages and formats.
Parsers generated by Rats! memoize intermediate results, which ensures linear time performance in the presence of unlimited lookahead and backtracking. As a result, they are essentially functional (even though they are implemented in an imperative language) and also called "packrat parsers."
Main features:
- Rats! relies on a module system to structure grammars and their extensions. In particular, it relies on modules to group related productions into separate units. Next, module modifications concisely express extensions to other modules and can add, change, or remove individual alternatives in productions. Finally, module parameters are used to compose modules and their extensions with each other.
- Rats! grammars build on parsing expression grammars (PEGs). While PEGs share many constructs with the familiar EBNF notation, a key difference is that they utilize ordered choices instead of the unordered choices used by context-free grammars (CFGs) and other parser generators, such as Yacc or ANTLR. As a result, Rats! grammars avoid ambiguities and support localized changes. Additional flexibility is offered through syntactic predicates, which match expressions but do not consume the input, thus providing unlimited lookahead, and through the integration of lexing with parsing, which greatly simplifies the addition of new tokens to a grammar. PEGs have the additional benefit that they are not only closed under composition (unlike the LR or LL grammars used by Yacc and ANTLR), but also intersection and complement (unlike CFGs in general).
- To eliminate the need for explicit semantic actions, Rats! can automatically generate abstract syntax trees. In particular, it supports productions that return no semantic values (such as those recognizing spaces or comments), string values (such as those recognizing literals or identifiers), and generic tree nodes (potentially all other productions).
- Since some computer-readable formats are inherently context-sensitive and cannot be expressed as PEGs (or CFGs), Rats! supports two techniques for managing parser context or state, thus providing a well-defined interface for extending parsers. First, Rats! provides parser actions to recognize expressions that depend on local context, i.e., expressions that depend on immediately preceding expressions within the same production. An example for such local context is an explicit length preceding as many instances of some expression. Second, Rats! supports a global state object to recognize expressions that depend on possibly global context. State modifications are performed within lightweight transactions, which preserve the basically functional nature of Rats!-generated parsers. An example for a global context is the symbol table used for disambiguating variable and typedef names when parsing C.
Enhancements:
- Release highlights are support for formatting-preserving source refactorings through parse trees, support for parsing and pretty printing Java 5, (an improved abstract syntax tree for Java, and improved support for type checking C and Java ASTs.

libusb is a library to provide userspace access to USB devices. libusb project supports Linux 2.6/2.4/2.2, FreeBSD/OpenBSD/NetBSD, and Darwin/MacOS X.
Operating System support
- Linux
- FreeBSD
- NetBSD
- OpenBSD
- Darwin
- MacOS X
Building:
It should be as simple as running these two commands:
./configure
make