Free maker 0.05.18 software for linux

Class::Maker Perl module contains classes, reflection, schema, serialization, attribute- and multiple inheritance.

SYNOPSIS

use Class::Maker qw(class);
class Human, { isa => [qw( ParentClass )],
public =>
{
string => [qw(name lastname)],

ref => [qw(father mother)],

array => [qw(friends)],

custom => [qw(anything)],
},

private =>
{
int => [qw(dummy1 dummy2)],
},

configure =>
{
ctor => create,

explicit => 0,
},
};
sub Human::greeting : method { my $this = shift;
printf This is %s (%d), $this->name, $this->uid;
}
class UnixUser, { isa => [qw( Human )],
public =>
{
int => [qw(uid gid)],

string => [qw(username)],
},
};

my $a = Human->new( uid => 1, gid => 2, name => Bart );

$a->father( Human->new( name => Houmer ) );

$a->greeting();

$a->uid = 12;

$a->_dummy1( bla );

Class::Maker introduces the concept of classes via a "class" function. It automatically creates packages, ISA, new and attribute-handlers. The classes can inherit from common perl-classes and class-maker classes. Single and multiple inheritance is supported.

This package is for everybody who wants to program oo-perl and does not really feel comfortable with the common way.

Java-like reflection is also implemented and allows one to inspect the class properties and methods during runtime. This is helpfull for implementing persistance and serialization. A Tangram (see cpan) schema generator is included to the package, so one can use Tangram object-persistance on the fly as long as he uses Class::Maker classes.

List::Maker is a Perl module that can generate more sophisticated lists than just $a..$b.

SYNOPSIS

use List::Maker;

@list = < 1..10 >; # (1,2,3,4,5,6,7,8,9,10)

@list = < 10..1 >; # (10,9,8,7,6,5,4,3,2,1)

@list = < 1,3,..10 > # (1,3,5,7,9)
@list = < 1..10 x 2 > # (1,3,5,7,9)

@list = < 0..10 : prime N >; # (2,3,5,7)
@list = < 1,3,..30 : /7/ > # (7,17,27)

@words = < a list of words >; # (a, list, of, words)
@words = < a list "of words" >; # (a list, of words)

The List::Maker module hijacks Perls built-in file globbing syntax (< *.pl > and glob *.pl) and retargets it at list creation.

The rationale is simple: most people rarely if ever glob a set of files, but they have to create lists in almost every program they write. So the list construction syntax should be easier than the filename expansion syntax.

Patch Maker helps you manage multiple in-progress source code patches to software. Patch Maker remembers which files are part of which patch, and keeps them disentangled during the development process.
It speeds up common operations and housekeeping tasks, allowing you to focus on writing code. It is a command-line tool written in Perl, and so is usable on (at least) Windows, Linux and Mac OS X.
Enhancements:
- Initial SVN support was added to go with CVS.
- The configuration was moved to the .pmrc file in the home directory.
- Message and error printing were tidied up and standardized.

Slay::Makefile is a wrapper to Slay::Maker that reads the rules from a file.

SYNOPSIS

Slay::Maker is a make engine that uses perl declaration syntax for rules, including regular expressions for targets and anonymous subs for targets, dependencies, and actions. This Slay::Makefile wrapper allows for the rules to be contained within a SlayMakefile file whose syntax is similar to that of a normal Makefile.

FILE SYNTAX

The file syntax is a series of statements where each statement is one of:

< perl-block >

< target(s) > : < dependencies >
< actions >

[-] include < filename >

# Comment
< perl-block > has the syntax:
{
< perl-statement(s) >
}
where < perl-statement(s) > is any series of perl statements.
< target(s >) is either a space-delimited set of targets, each of which is either a literal string or a < perl-block > which returns an array, each of which is either a literal string or a regular expression (Regexp) reference (qr/.../). A literal string can contain a % character to act as a wild-card, just as with GNU make.

However, the Regexp feature is more general, since it can capture more than one substring and use the values $!, $2, ... inside the dependencies. Note that only one target can realistically contain wildcards, whether in a Regexp or using %, since there is only one set of $1, $2, ... variables.

The colon separating a < perl-block > for < target(s) > must be on the same line as the closing brace of the < perl-block >.

< dependencies > is either a space-delimited set of dependency strings or a < perl-block > which returns an array of dependencies (or a combination). The dependency string can contain $1, $2, ..., or %, which is synonymous with $1 and ${TARGET}, which gets the target name. They can also use any scalar global variables previously defined in a < perl-block >. A dependency < perl-block > receives an array @_ with the values ($make, $target, $matches), where $make is a Slay::Maker object, $target is the target name, and $matches is a reference to an array containing the captured values from that targets Regexp (if any).

The colon separating a < perl-block > for must be on the same line as the opening brace of the < perl-block >.

< actions > is a series of zero or more action "lines", where each action is either a string, which will be executed inside a shell, a perl anonymous array, which is executed without a shell (see IPC::Run), or a < perl-block >. For purposes of this discussion, a "line" continues as long as the lines of string action end with "" or as long as a perl anonymous array or < perl-block > do not have their closing punctuation. A string action can use the strings $1, $2, ..., for the matches, $DEP0, $DEP1, ..., for the dependencies, and $TARGET, which represents the target being built. For make enthusiasts, $* can be used for $1. A string action can also use any scalar global variables previously defined in a < perl-block >.

An include line includes the content of a file with < filename > as a SlayMakefile file. If there is no such file, Slay::Makefile will try to build it using rules that have already been presented. If there is no such rule, Slay::Makefile exits with an error unless there was a - before the "include".

The equivalent of makes defines are handled by setting perl global variables. Each main < perl-block > is executed in the order it appears in the file, but any that is part of a dependency or action is evaluated lazily, so that all the global variables will have been set.

Comments begin with a # and extend to the end of line.

Continuation lines can be specified by putting a backslash at the end of the previous line, provided however, that continuation lines are unnecessary (automatic) within a perl block or perl anonymous array.

METHODS

new

Class method. Creates a new Slay::Makefile object.

maker

Method. Returns the Slay::Maker object used by this Slay::Makefile object.
make (@targets)

Method. Calls the Slay::Maker objects make method to build the list of targets. If no targets are given, makes the targets of the first rule with constant targets.

parse ($filename)

Method. Parses file $filename as a SlayMakefile and populates the Slay::Maker object with its rules. Returns a reference to an array of parse errors.

parse_string ($string, [$filename, [$lineno]])

Method. Parses $string as a SlayMakefile. If $filename and/or $lineno arguments are provided, they are used for more detailed error reporting. Returns a reference to an array of parse errors.

Regression mAKEr project is a simple modular application for data investigation.

This is an application to help user (mathematician) to make regression between series of data, draw grpahics, and export them into various formats by means of common graphics packages (i.e., gnuplot, plotutils). It is written in Python.

The user interfeace is built upon the wxPython (wxWindows) widget set.

The idea of usage is as follows: the user builds a project which is represented as a tree of modules; modules can generate data variables, as well as consume them. Essentialy, such a tree represents an algorithm of data analysis.

The system is intended to educate students.

wmpower is a Window Maker dock application allowing the user to graphically see (and set) the power management status of his laptop.
Main features:
- Battery status display (you choose the battery);
- Both APM and ACPI kernels are supported;
- On ACPI kernels you get fan status and a thermal sensor;
- Direct access to Toshiba hardware: you get fan status and LCD brightness management even without an APCI kernel;
- While on battery, it can stop your fan, HD, lin-seti service to make the battery last longer; if you have a Toshiba Laptop, it can also adjust your LCD brightness;
- Fast battery charge mode: you can keep on battery settings until your battery reaches 100%: this will make it recharge much faster;
- no-meddling option: if you want the program to display power manamenegt status, but not to take any action.
- On Toshiba laptops you can use your mouse wheel to adjust the brightness of your lcd screen.
- Support for Dell laptops for temperature and fan status
- Support for Compal hardware
- CPU frequency scaling support
Installation:
./configure
make
su root (if you are not root already)
make install
Enhancements:
- Fixed a memory allocation issue that on rare occasions could make wmpower crash.
- Fixed small bug that made wmpower print forever that it would not fast charge the battery as it was already at maximum capacity.
- When calculating battery time, and battery is charging, now wmpower displays time remaining until battery is fully charged instead of how much time would left if we were running on battery power.

Namazu is a full-text search engine. Namazu uses the index maker mknmz command and the text searcher namazu command.

For quickly searching through many documents, Namazu generates an index similar to that of a books.

mknmz command compiles the index. The target directory for indexing is given as an argument for mknmz. For example, if the target directory is /home/foo/public_html, then type

% mknmz /home/foo/public_html

Now documents such as *.html and *.txt under /home/foo/public_html are indexed and NMZ.* files are created in the directory where you run mknmz. NMZ.* files are from Namazus index.

The namazu command searches the index. For example:

% namazu bar /home/foo/Namazu/foobar

The above searches a keyword "bar" for the index under /home/foo/Namazu/bar.

For searching a great amount of documents quickly, Namazu makes an index in advance. The concept of index is just similar to an index of book.

Namazu is being developed by Namazu Project. Namazu will work on UNIX, Win32 and OS/2 environments. For Win32, you can find Namazu for Win32: a Full-Text Search Engine page. For OS/2, OS/2 port of Namazu a full text retrieval search system is maintained by Shimizu-san. Each page provides binary package also.

Not only with cgi interface of Web, it works on command line as namazu. Other frontends are also available from other sources, such as namazu.el and Wanderlust on Emacs, Tknamazu on X Window System and Search-S on Win32.

Filters enable namazu to index various formats of files. Mail/News filter works with no additives, some other type requires third parties filter executable although the calling capabilites included in Namazu package.