Free jmp 0.51 software for linux

WMpop is a Window Maker DockApp for monitoring a local (mbox format) or POP3 mailbox. WMpop project displays:
- number of mails in the mailbox (or unread mails if checked in the preference screen),
- a scrolling text with the email address of the senders (only for local mailbox for the moment),
- and a status led, indicating mail checking progression and errors.
WMpop can be configured via a graphic interface written in GTK+. The configuration interface let you define parameters of your POP3 server, and let you personalize the app (changing icons or sound and choosing an external command to launch on demand).
It is internationalized, with French translation. You can also run several instances of the program of different mailboxes (remote or local).

Ingperl module allows Perl access to Ingres databases for old ingperl scripts.

SYNOPSIS

&sql(...);
&sql_exec(...);
@values = &sql_fetch;
&sql_close;

@types = &sql_types;
@ingtypes = &sql_ingtypes;
@lengths = &sql_lengths;
@nullable = &sql_nullable;
@names = &sql_names;

$sql_version
$sql_error
$sql_sqlcode
$sql_rowcount
$sql_readonly
$sql_showerrors
$sql_debug

@row1 = &sql_eval_row1(select ...);
@col1 = &sql_eval_col1(select ...);

Ingperl is an extension to Perl which allows access to Ingres databases.
The functions that make up the interface are described in the following sections.
All functions return false or undefined (in the Perl sense) to indicate failure.

B::Graph is a Perl compiler backend to produce graphs of OP trees.

SYNOPSIS

perl -MO=Graph,-text prog.pl >graph.txt

perl -MO=Graph,-vcg prog.pl >graph.vcg
xvcg graph.vcg

perl -MO=Graph,-dot prog.pl | dot -Tps >graph.ps

This module is a backend to the perl compiler (B::*) which, instead of outputting bytecode or C based on perls compiled version of a program, writes descriptions in graph-description languages specifying graphs that show the programs structure. It currently generates descriptions for the VCG tool (http://www.cs.uni-sb.de/RW/users/sander/html/gsvcg1.html) and Dot (part of the graph visualization toolkit from AT&T: http://www.research.att.com/sw/tools/graphviz/). It also can produce plain text output (which is more useful for debugging the module itself than anything else, though you might be able to make cut the nodes out and make a mobile or something similar).

OPTIONS

Like any other compiler backend, this module needs to be invoked using the O module to run correctly:

perl -MO=Graph,-opt,-opt,-opt program.pl
OR
perl -MO=Graph,-opt,obj -e BEGIN {$obj = ["hi"]}; print $obj
OR EVEN
perl -e use O qw(Graph -opt obj obj); print "hi!n";

Obj is the name of a perl variable whose contents will be examined. It cant be a my() variable, and it shouldnt have a prefix symbol ($@^*), though you can specify a package -- the name will be used to look up a GV, whose various fields will lead to the scalar, array, and other values that correspond to the named variable. If no object is specified, the whole main program, including the CV that points to its pad, will be displayed.

Each of the the opts can come from one of the following (each set is mutually exclusive; case and underscores are insignificant):

-text, -vcg, -dot

Produce output of the appropriate type. The default is -text, which isnt useful for much of anything (it does draw some nice ASCII boxes, though).

-addrs, -no_addrs

Each of the nodes on the graph produced corresponds to a C structure that has an address and includes pointers to other structures. The module uses these addresses to decide how to draw edges, but it makes the graph more compact if they arent printed. The default is -no_addrs.

-compile_order, -run_order

The collection of OPs that perl compiles a script into has two different layers of structure. It has a tree structure which corresponds roughly to the synactic nesting of constructs in the source text, and a roughly linked-list representation, essentially a postorder traversal of this tree, which is used at runtime to decide what to do next. The graph can be drawn to emphasize one structure or the other. The former, compile_order, is the default, as it tends to lead to graphs with aspect ratios close to those of standard paper.

-SVs, -no_SVs

If OPs represent a programs compiled code, SVs represent its data. This includes literal numbers and strings (IVs, NVs, PVs, PVIVs, and PVNVs), regular arrays, hashes, and references (AVs, HVs, and RVs), but also the structures that correspond to individual variables (special HVs for symbol tables and GVs to represent values within them, and special AVs that hold my() variables (as well as compiler temporaries)), structures that keep track of code (CVs), and a variety of others. The default is to display all these too, to give a complete picture, but if you arent in a holistic mood, you can make them disappear.

-ellipses, -rhombs

The module tries to give the nodes representing SVs a different shape from those of OPs. OPs are usually rectangular, so two obvious shapes for SVs are ellipses and rhombuses (stretched diamonds). This option currently only makes a difference for VCG (ellipse is the default).

-stashes, -no_stashes

The hashes that perl uses to represent symbol tables are called stashes. Since every GV has a pointer back to its stash, its virtually inevitable for the links in a graph to lead to the main stash. Unfortunately stashes, especially the main one, can be quite big, and lead to forests of other structures -- theres one GV and another SV for each magic variable, plus all of @INC and %ENV, and so on. To prevent information overload, then, the display of stashes is disabled by default.

-fileGVs, -no_fileGVs

Another kind graph element that can be annoying are the pointers from every GV and COP (a kind of OP that occurs for every statement) to the GV that represents the file from which that code came (used for error messages). By default, these links arent shown, to keep them from cluttering the graph. Also, perls internal interfaces changed in a recent version, so in perl 5.005_63 or later you cant see the fileGVs at all.

-SEQs, -no_SEQs

As it is visited in the peephole optimization phase, each OP gets a sequence number, which is currently used by anything (except the peephole optimizer, to avoid visiting OPs twice). If you want to see these, ask for them. (COPs have their own sequence numbers too, but theyre more interesting to look at -- for instance, theyre used to bound the lifetimes of lexicals).

-types, -no_types

B::Graph always gives the type of each OP symbolically (entersub), but it can also print the numeric value of the type field, if you want. The default is no_types.

-float, -no_float

Almost every OP has an op_next and an op_sibling pointer, and B::Graph colors them distinctively (pink and light blue, respectively). Because of this, it isnt strictly necessary to anchor the arrow on a line in the OPs box saying op_next. The float option lets the graph layout engine start these arrows wherever it wants, which can sometimes lead to a more pleasing layout, at the expense of being less obvious. The default is not to float.

-targlinks, -no_targlinks

Lexical (my()) variables and temporary values used by individual OPs are stored in pads, per-code arrays linked to the CV. OPs store indexes into these arrays in the op_targ field, but B::Graph can often also draw links directly from the OP to the SV that stores the name of the variable. These links dont correspond to any real pointers, however, and they can make the graph more complicated, so they are disabled by default.

libEtPans purpose of this mail library is to provide a portable, efficient middleware for different kinds of mail access.
When using the drivers interface, the interface is the same for all kinds of mail access, remote and local mailboxes.
libEtPan! project can read mbox, MH format, and Maildir mailboxes, and does MIME parsing.
Installation:
The simplest way to compile this package is:
1. `cd to the directory containing the packages source code and type `./configure to configure the package for your system. If youre using `csh on an old version of System V, you might need to type `sh ./configure instead to prevent `csh from trying to execute `configure itself.
Running `configure takes awhile. While running, it prints some messages telling which features it is checking for.
2. Type `make to compile the package.
3. Optionally, type `make check to run any self-tests that come with the package.
4. Type `make install to install the programs and any data files and documentation.
5. You can remove the program binaries and object files from the source code directory by typing `make clean. To also remove the files that `configure created (so you can compile the package for a different kind of computer), type `make distclean. There is also a `make maintainer-clean target, but that is intended mainly for the packages developers. If you use it, you may have to get all sorts of other programs in order to regenerate files that came with the distribution.
Enhancements:
- This release is just a bugfix release for the compile errors in 0.50, namely with enabled SASL, GnuTLS, and BIOs handling with openSSL.

Deskweb applies the iconography and usability of a common Windows desktop system to Web applications.

Deskweb is familiar and user-friendly and lets users easily learn how to exploit all of the softwares features.

It can be used in various ways, such as a content management system, a company groupware, a wiki, or more.

Project VDW contains a package that generates van der Waerden sequences.
Project VDW is a an attempt to further research into van der Waerden sequences.
The software consists of a client that generates sequences, and a utility to generate unique starting seeds.
The ultimate goal of this project is to develop a BOINC-based client that can supply the massively parallel computing resources necessary to solve currently untouched sequences.
Currently the makefile will compile and test several different versions using char, u_char, int, u_int, long, and u_long as the element type.
Different architectures perform differently on chars vs ints and differently given the size of the data cache.
Feel free to try different combinations of element type to optimize the code for your particular configuration.
Enhancements:
- Changed to timed checkpointing
- Changed to millionbased accounting from 2^32 accounting
- Added Interrupted/Completed messages to output file
- Changed makefile to test different element types
- and lots of other cool stuff.

Jim is an opensource small footprint implementation of the Tcl programming language. It implements a large subset of Tcl and adds new features like references with garbage collection, closures, built-in Object Oriented Programming system, Functional Programming commands, First class arrays. All this with a binary size of 70kb (that can be reduced further excluding some command).
Jim is currently a work in progress, but most of the core language is already implemented and it is possible to use it to run many unmodified Tcl programs, so if you want to start to evaluate it, or want to look at our internal design and virtual machine, go to the download section.
Jims goal is to provide a powerful language implemented in roughly 10k lines of code that is presented as a single C file and an header file, in order to allow developers to put Jim inside their applications, as scripting language, configuration file syntax, without to depend on external libraries or other big systems.
We belive scripting is a very interesting feature for many applications, but developers are often not encouraged to link the application to a big external system. Jim try to address this problem providing a very simple to understand and small footprint implementation of a language that is ideal for scripting, and at the same time is powerful and able to scale.
Another field where Jim may help is the one of Embedded Systems. Jim is written in ANSI-C, is very little both in binary size and memory requirements, and the Tcl language is just ideal for this tasks (For example, CISCO routers are using Tcl).
Main features:
- Support for important features that will be availabe in Tcl8.5, like dict and {expand}.
- Arrays in Jim arent collection of variables like in Tcl, but a first class type. Array access syntax is in Jim syntax sugar to set and get dictionaries elements.
- A compact design. Jim is currently less than 10k lines of code. It does a heavy use of dual ported objects, in Jim even the VM pseudo-bytecode is a specialized Jim_Obj type.
- lambda with garbage collection, and a reference system to build linked data structures.
- closures, Jims procedures can have persistent procedure-specific variables (called statics). Statics initialization value can be caputred form the procedure creation context, so it is very similar to lexical scoping to use. This is how The Paul Grahams accumulator procedure looks like in Jim:
proc accumulator n {
lambda increment n {
set n [+ $n $increment]
}
}
- Math operations as commands (together with expr support).
- Ability to load extensions at runtime via a STUB system. Even programs using Jim that are linked statically are able to load extensions.
- 70Kbyte binary size!.