Free iriverter 0.16 software for linux

VTE library inserts terminal capability strings into a tree of tables.

You could say that VTE is something of a research project of mine, based on the simple question: "if programs can use a termcap file (through either libtermcap or curses or ncurses) to determine how to drive a terminal, why cant a terminal emulator use a termcap file to determine how to behave?"

Update: the answer is most likely "because applications which use curses have more detailed information than that which is found in termcap".

What does VTE include?

VTE includes a library (libvte) which implements such a terminal emulator widget for GTK+ 2.2/2.4, and a sample application (vte) which wraps that widget in a GTK window. Because Im more concerned with whether or not it works, all settings are hard-coded to whatever I needed to test the last time I touched it. If you actually want to use the widget to get work done, you should probably be using gnome-terminal.

How does it work?

The VTE library inserts terminal capability strings into a tree of tables, and then uses it to determine if data received from a pseudo-terminal is a control sequence or just random data. The sample program "interpret" illustrates more or less what the widget sees after it filters incoming data.

Sort::External is a Perl module that can sort huge lists.

SYNOPSIS

my $sortex = Sort::External->new( -mem_threshold => 2**24 );
while ( ) {
$sortex->feed($_);
}
$sortex->finish;
while ( defined( $_ = $sortex->fetch ) ) {
&do_stuff_with($_);
}

Problem: You have a list which is too big to sort in-memory.
Solution: "feed, finish, and fetch" with Sort::External, the closest thing to a drop-in replacement for Perls sort() function when dealing with unmanageably large lists.

How it works:

Cache sortable items in memory. Periodically sort the cache and empty it into a temporary sortfile. As sortfiles accumulate, interleave them into larger sortfiles. Complete the sort by sorting the input cache and any existing sortfiles into an output stream.

Note that if Sort::External hasnt yet flushed the cache to disk when finish() is called, the whole operation completes in-memory.

In the CompSci world, "internal sorting" refers to sorting data in RAM, while "external sorting" refers to sorting data which is stored on disk, tape, punchcards, or any storage medium except RAM -- hence, this modules name.

Stringification

Items fed to Sort::External will be returned in stringified form (assuming that the cache gets flushed at least once): $foo = "$foo". Since this is unlikely to be desirable when objects or deep data structures are involved, Sort::External throws an error if you feed it anything other than simple scalars.

Taint and UTF-8 flags

Expert: Sort::External does a little extra bookkeeping to sustain each items taint and UTF-8 flags through the journey to disk and back.

METHODS

new()
my $sortscheme = sub { $Sort::External::b $Sort::External::a };
my $sortex = Sort::External->new(
-mem_threshold => 2**24, # default: 2**20 (1Mb)
-cache_size => 100_000, # default: undef (disabled)
-sortsub => $sortscheme, # default sort: standard lexical
-working_dir => $temp_directory, # default: see below
);

Construct a Sort::External object.

-mem_threshold -- Allow the input cache to consume approximately -mem_threshold bytes before sorting it and flushing to disk. Experience suggests that the optimum setting is somewhere between 2**20 and 2**24: 1-16Mb.
-cache_size -- Specify a hard limit for the input cache in terms of sortable items. If set, overrides -mem_threshold.
-sortsub -- A sorting subroutine. Be advised that you MUST use $Sort::External::a and $Sort::External::b instead of $a and $b in your sub. Before deploying a sortsub, consider using a GRT instead, as described in the Sort::External::Cookbook. Its probably a lot faster.
-working_dir -- The directory where the temporary sortfiles will reside. By default, this directory is created using File::Temps tempdir() command.
feed()

$sortex->feed( @items );

Feed one or more sortable items to your Sort::External object. It is normal for occasional pauses to occur during feeding as caches are flushed and sortfiles are merged.

finish()
# if you intend to call fetch...
$sortex->finish;

# otherwise....
use Fcntl;
$sortex->finish(
-outfile => sorted.txt,
-flags => (O_CREAT | O_WRONLY),
);

Prepare to output items in sorted order.

If you specify the parameter -outfile, Sort::External will attempt to write your sorted list to that location. By default, Sort::External will refuse to overwrite an existing file; if you want to override that behavior, you can pass Fcntl flags to finish() using the optional -flags parameter.

Note that you can either finish() to an -outfile, or finish() then fetch()... but not both.

fetch()
while ( defined( $_ = $sortex->fetch ) ) {
&do_stuff_with($_);
}

Fetch the next sorted item.

0verkill project is a bloody action 2D deathmatch game in ASCII art.
It supports free connecting/disconnecting during the game, and runs well on modem lines. Graphics are in 16-color ASCII art with elaborate hero animations.
0verkill features 4 different weapons, grenades, invisibility, and armor. The package also contains reaperbot clients, a simple graphics editor, and a level editor.
Main features:
- four types of gun
- grenades
- armor
- counting frags and deaths
- walking, running, jumping, shooting, creeping, walking up the stairs, climbing up and down ladders
- automatic weapon switching
- damage depending on distance and hit body part
- item respawning
- invisibility
- chat
- online help
- players respawning on random places
- boundless connecting/disconnecting during the game
- choice of 15 different colors of hero, choice of male/female hero
- ASCII-art graphics in full 16 color text mode
- client-server architecture
- clients motion prediction => decent running on slower lines
- raw keyboard
- simple level editor, but not very user friendly, currently only for initiates
- graphics editor
- top players list
- full X support
- experimental reaperbots
- multi level support
- lethal objects
- two levels done at this moment
- experimental 3D support (like stereogram)
Enhancements:
- minor level changes (in old level)
- new level (its very lethal ;-) )
- lot of cool new graphics
- level negotiation (client negotiates level with server)
- fixed bug with -s option
- optional 3D view
- lethal objects
- optimized output from the avi editor
- fixed segfault in the avi editor when cannot write to a file
- improved avi editor - status bar, hold key
- fixed several bugs in avi loader
- memory leak catching mechanism (only for debugging, its turned off by default for higher speed)

GNU `gettext is an important step for the GNU Translation Project, as it is an asset on which we may build many other steps. gettext package offers to programmers, translators, and even users, a well integrated set of tools and documentation.

Specifically, the GNU `gettext utilities are a set of tools that provides a framework to help other GNU packages produce multi-lingual messages.

These tools include a set of conventions about how programs should be written to support message catalogs, a directory and file naming organization for the message catalogs themselves, a runtime library supporting the retrieval of translated messages, and a few stand-alone programs to massage in various ways the sets of translatable strings, or already translated strings.

A special GNU Emacs mode also helps interested parties in preparing these sets, or bringing them up to date.

sitecopy allows you to easily maintain remote Web sites.
The program will upload files to the server which have changed locally, and delete files from the server which have been removed locally, keeping the remote site synchronized. FTP and WebDAV are supported.
Enhancements:
- This release adds support for client certificates in DAV and neon 0.26.

Bigtop::Parser is the Parse::RecDescent grammar driven parser for bigtop files.

SYNOPSIS

Make a file like this:
config {
base_dir `/home/username`;
Type1 Backend {}
Type2 Backend {}
Type3 Backend {}
}
app App::Name {
table name { }
controller SomeController {}
}
Then run this command:
bigtop my.bigtop all

This module is really only designed to be used by bigtop. It provides the grammar which understands bigtop files and turns them into syntax trees. It provides various utility functions for bigtop (or similar tools you might write) and for backends.

Reading further is an indication that you are interested in working on Bigtop and not just in using it to serve your needs.

Stratego/XT is a development environment for creating stand-alone transformation systems.
It combines Stratego, a language for implementing transformations based on the paradigm of programmable rewriting strategies, with XT, a collection of reusable components and tools for the development of transformation systems.
In general, Stratego/XT is intended for the analysis, manipulation, and generation of programs, though its features make it useful for transforming any structured documents.
In practice, it has been used to build many types of transformation systems including compilers, interpreters, static analyzers, domain-specific optimizers, code generators, source code refactorers, documentation generators, and document transformers.
Enhancements:
- The compiler was restructured.
- Some old language features were removed.
- Man pages for all tools were completed.
- A new introductory tutorial with examples was co-released, and more.