Free catch software for linux

Catch the Furball project is an icebreaker board game for friends to play around a computer.

It features a freshly-generated board for each game, an eclectic collection of cards, and beautiful pictures of Cambridge University.

The distribution is intended both to allow Web masters to quickly set up their own copy of the game, and to allow tinkerers to use the game engine to make their own games.

It includes the editor used to create game data.

Exception::Class::TryCatch is a syntactic try/catch sugar for use with Exception::Class.

SYNOPSIS

use Exception::Class::TryCatch;

# simple usage of catch()

eval { Exception::Class::Base->throw(error) };
catch my $err and warn $err->error;

# catching only certain types or else rethrowing

eval { Exception::Class::Base::SubClass->throw(error) };
catch( my $err, [Exception::Class::Base, Other::Exception] )
and warn $err->error;

# catching and handling different types of errors

eval { Exception::Class::Base->throw(error) };
if ( catch my $err ) {
$err->isa(this) and do { handle_this($err) };
$err->isa(that) and do { handle_that($err) };
}

# use "try eval" to push exceptions onto a stack to catch later

try eval {
Exception::Class::Base->throw(error)
};
do {
# cleanup that might use "try/catch" again
};
catch my $err; # catches a matching "try"

Exception::Class::TryCatch provides syntactic sugar for use with Exception::Class using the familiar keywords try and catch. Its primary objective is to allow users to avoid dealing directly with $@ by ensuring that any exceptions caught in an eval are captured as Exception::Class objects, whether they were thrown objects to begin with or whether the error resulted from die. This means that users may immediately use isa and various Exception::Class methods to process the exception.

In addition, this module provides for a method to push errors onto a hidden error stack immediately after an eval so that cleanup code or other error handling may also call eval without the original error in $@ being lost.

Inspiration for this module is due in part to Dave Rolskys article "Exception Handling in Perl With Exception::Class" in The Perl Journal (Rolsky 2004).

The try/catch syntax used in this module does not use code reference prototypes the way the Error.pm module does, but simply provides some helpful functionality when used in combination with eval. As a result, it avoids the complexity and dangers involving nested closures and memory leaks inherent in Error.pm (Perrin 2003).
Rolsky (2004) notes that these memory leaks may not occur in recent versions of Perl, but the approach used in Exception::Class::TryCatch should be safe for all versions of Perl as it leaves all code execution to the eval in the current scope, avoiding closures altogether.

AddTraction project is a SDL 2-player board game with numbers.

Two players ("red" and "green") take their turns on a 6x6 board. In the beginning, the board is empty except for a red "1" in the upper left and a green "1" in the lower right.

Taking a turn means setting one field of the board. Setting a field makes it assume the sum of the points of the 8 surrounding fields. But there is a catch: if the field is of the opponents color, their score is subtracted rather than added. If the resulting score is positive, the field will get your color, else your opponents color.

The same happens to the global score, which is just a colored difference of the score of all fields on the board. If the score in the end is red, red wins. If it is green, green wins. If it is black (0), it is a draw.

Flamethrower is intended to be an easy to use multicast file distribution system. Flamethrower project was created to add multicast install capabilities to SystemImager, but was designed to be fully functional as a stand-alone package.
Main features:
- Works with entire directory heirarchies of files, not just single files.
- Uses a server configuration file that takes module entries that are similar to those used by rsyncd.conf.
- Flamethrower is an on-demand system. The multicast of a module is initiated when a client connects, but waits MIN_WAIT (conf file) for other clients to connect. If other clients try to connect after a cast has been initiated, they simply wait until that cast has finished, and catch the next one when it begins.
- The udpcast package is used as the multicast transport, and offers a gob and a half of tuning parameters.

CGI::Validate is an advanced CGI form parser and type validation.

SYNOPSIS

use CGI::Validate; # GetFormData() only
use CGI::Validate qw(:standard); # Normal use
use CGI::Validate qw(:subs); # Just functions
use CGI::Validate qw(:vars); # Just exception vars

## If you dont want it to check that every requested
## element arrived you can use this. But I dont recommend it
## for most users.
$CGI::Validate::Complete = 0;

## If you dont care that some fields in the form dont
## actually match what you asked for. -I dont recommend
## this unless you REALLY know what youre doing because this
## normally meens youve got typos in your HTML and we cant
## catch them if you set this.
## $CGI::Validate::IgnoreNonMatchingFields = 1;

my $FieldOne = Default String;
my $FieldTwo = 8;
my $FieldThree = some default string;
my @FieldFour = (); ## For multi-select field
my @FieldFive = (); ## Ditto
my $EmailAddress= ;

## Try...
my $Query = GetFormData (
FieldOne=s => $FieldOne, ## Required string
FieldTwo=i => $FieldTwo, ## Required int
FieldThree => $FieldThree, ## Auto converted to the ":s" type
FieldFour=s => @FieldFour, ## Multi-select field of strings
FieldFive=f => @FieldFive, ## Multi-select field of floats
Email=e => $EmailAddress, ## Must look like an email address
) or do {
## Catch... (wouldnt you just love a case statement here?)
if (%Missing) {
die "Missing form elements: " . join ( , keys %Missing);
} elsif (%Invalid) {
die "Invalid form elements: " . join ( , keys %Invalid);
} elsif (%Blank) {
die "Blank form elements: " . join ( , keys %Blank);
} elsif (%InvalidType) {
die "Invalid data types for fields: " . join ( , keys %InvalidType);
} else {
die "GetFormData() exception: $CGI::Validate::Error";
}
};

## If you only want to check the form data, but dont want to
## have CGI::Validate set anything use this. -You still have full
## access to the data via the normal B object that is returned.

use CGI::Validate qw(CheckFormData); # not exported by default
my $Query = CheckFormData (
FieldOne=s, FieldTwo=i, FieldThree, FieldFour,
FieldFive, Email,
) or do {
... Same exceptions available as GetFormData above ...
};

## Need some of your own validation code to be used? Here is how you do it.
addExtensions (
myType => sub { $_[0] =~ /test/ },
fooBar => &fooBar,
i_modify_the_actual_data => sub {
if ($_[0] =~ /test/) { ## data validation
$_[0] = whatever; ## modify the data by alias
return 1;
} else {
return 0;
}
},
);
my $Query = GetFormData (
foo=xmyType => $foo,
bar=xfooBar => $bar,
cat=xi_modify_the_actual_data => $cat,
);


## Builtin data type checks available are:
s string # Any non-zero length value
w word # Must have at least one w char
i integer # Integer value
f float # Float value
e email # Must match m/^s*]+@[^@.]+(?:.[^@.]+)+>?s*$/
x extension # User extension type. See EXTENSIONS below.

Basicly a blending of the CGI and Getopt::Long modules, and requires the CGI module to function.

The basic concept of this module is to combine the best features of the CGI and Getopt::Long modules. The CGI module is great for parsing, building, and rebuilding forms, however it lacks any real error checking abilitys such as misspelled form input names, the data types received from them, missing values, etc. This however, is something that the Getopt::Long module is vary good at doing. So, basicly this module is a layer that collects the data using the CGI module and passes it to routines to do type validation and name consistency checks all in one clean try/catch style block.

The syntax of GetFormData() is mostly the same as the GetOptions() of Getopt::Long, with a few exceptions (namely, the handling of exceptions) . See the VALUE TYPES section for detail of the available types, and the EXCEPTIONS section for exception handling options. If given without a type, fields are assumed to be type ":s" (optional string), which is normally correct.
If successful, GetFormData() returns the CGI object that it used to parse the data incase you want to use it for anything else, and undef otherwise.

If you only want to do value type and name validation, use CheckFormData() instead with a field=type list. -See the SYNOPSIS for an example.

SYNOPSIS

perl -MModule::AutoINC < script >

ABSTRACT

When Module::AutoINC is loaded, it will add itself to @INC and catch any requests for missing resources. If a Perl module is requested that has not been installed, then this will attempt to load it. Under Active State Perl (or any Perl where PPM is available), PPM will attempt to install it. Otherwise CPAN will be queried and, assuming that the module exists on CPAN, CPAN::Shell will be invoked to install it. Execution of the script continues after the requisite module has been installed.

Module::AutoINC is a slightly useful tool designed to streamline the process of installing the modules required by a script. By loading the Module::AutoINC module (usually via a "-MModule::AutoINC" command-line option), the user is registering a handler that will catch any attempt to use a module that does not exist on the local machine. In this case, the CPAN::Shell module will be invoked to search for the specified module and, if found, an attempt will be made to install the module. If successful, the module will be loaded and execution will continue as normal.

Imported Symbols

You can modify the behavior of the module slightly using several import symbols. All import symbols are case-insensitive.

If you import the special symbol force then the installation of the module(s) will be forced. The definition of a forced installation varies depending on whether you are installing using PPM or CPAN. See the relevant documentation for each system for more information.

You can override the installation method detection using the import symbols, cpan or ppm. cpan will cause CPAN to be used for module installation no matter whether PPM is available or not. ppm will attempt to install the module using PPM regardless of whether ppm is findable by Module::AutoINC. Of course, you should know what you are doing if you use these import symbols.

Examples

perl -MModule::AutoINC -MLingua::Num2Word=cardinal -le print cardinal("en", 42)

...will download and install Lingua::Num2Word and Lingua::EN::Num2Word.

perl -MModule::AutoINC=cpan -MLingua::Num2Word=cardinal -le print cardinal("de", 42)

...will then download and install (using CPAN, even under ActiveState Perl) Lingua::DE::Num2Word (German).

perl -MModule::AutoINC=force -MLingua::Num2Word=cardinal -le print cardinal("es", 42)

...will then download and install (forcefully) Lingua::ES::Numeros (Spanish).

Class::Multimethods::Pure is a Perl module that contains a method-ordered multimethod dispatch.

SYNOPSIS

use Class::Multimethods::Pure;

package A;
sub magic { rand() > 0.5 }
package B;
use base A;
package C;
use base A;

BEGIN {
multi foo => (A, A) => sub {
"Generic catch-all";
};

multi foo => (A, B) => sub {
"More specific";
};

multi foo => (subtype(A, sub { $_[0]->magic }), A) => sub {
"This gets called half the time instead of catch-all";
};

multi foo => (any(B, C), A) => sub {
"Accepts B or C as the first argument, but not A"
};
}

procmail is a mail processing and SmartList mailing list suites. Procmail can be used to create mail-servers, mailing lists, sort your incoming mail into separate folders/files (real convenient when subscribing to one or more mailing lists or for prioritising your mail), preprocess your mail, start any programs upon mail arrival (e.g. to generate different chimes on your workstation for different types of mail) or selectively forward certain incoming mail automatically to someone.
Enhancements:
- Regression bugs from 3.20:
- Broke compilation with K&R compilers
- procmail -p -m was overridding PATH
- maildir delivery included garbage in filenames
- Mismatched HOST in last rcfile didnt discard the message
- COMSAT wasnt turned off by an rcfile on the command line
- Catch overly long command line variable assignments
- If a command expansion is truncated, set PROCMAIL_OVERFLOW and dont trim trailing (really middle) newlines
- If the comsat host cant be resolved, set COMSAT to "no"