Free subroutines software for linux

Sub::Regex is a Perl module to create synonymous subroutines.

SYNOPSIS

use Sub::Regex;
sub /look(s|ing)?_for/ ($){
foobar blah blah
}

look_for(Amanda);
looks_for(Amanda);
looking_for(Amanda);
lOoKiNg_fOr(Amanda);

Sub::Regex is a small tool for users to create a subroutine with multiple names. The only thing to be done is replace the normal name of a subroutine with a regular expression. However, regexp modifiers are not allowed, and matching is all considered case-insensitive.

Scalar::Util is a selection of general-utility scalar subroutines.

SYNOPSIS

use Scalar::Util qw(blessed dualvar isweak readonly refaddr reftype tainted
weaken isvstring looks_like_number set_prototype);

Scalar::Util contains a selection of subroutines that people have expressed would be nice to have in the perl core, but the usage would not really be high enough to warrant the use of a keyword, and the size so small such that being individual extensions would be wasteful.

By default Scalar::Util does not export any subroutines. The subroutines defined are

blessed EXPR

If EXPR evaluates to a blessed reference the name of the package that it is blessed into is returned. Otherwise undef is returned.

$scalar = "foo";
$class = blessed $scalar; # undef

$ref = [];
$class = blessed $ref; # undef

$obj = bless [], "Foo";
$class = blessed $obj; # "Foo"

dualvar NUM, STRING

Returns a scalar that has the value NUM in a numeric context and the value STRING in a string context.

$foo = dualvar 10, "Hello";
$num = $foo + 2; # 12
$str = $foo . " world"; # Hello world

isvstring EXPR

If EXPR is a scalar which was coded as a vstring the result is true.

$vs = v49.46.48;
$fmt = isvstring($vs) ? "%vd" : "%s"; #true
printf($fmt,$vs);

isweak EXPR

If EXPR is a scalar which is a weak reference the result is true.

$ref = $foo;
$weak = isweak($ref); # false
weaken($ref);
$weak = isweak($ref); # true

NOTE: Copying a weak reference creates a normal, strong, reference.

$copy = $ref;
$weak = isweak($ref); # false

looks_like_number EXPR

Returns true if perl thinks EXPR is a number. See "looks_like_number" in perlapi.

openhandle FH

Returns FH if FH may be used as a filehandle and is open, or FH is a tied handle. Otherwise undef is returned.

$fh = openhandle(*STDIN); # *STDIN
$fh = openhandle(*STDIN); # *STDIN
$fh = openhandle(*NOTOPEN); # undef
$fh = openhandle("scalar"); # undef

readonly SCALAR

Returns true if SCALAR is readonly.

sub foo { readonly($_[0]) }

$readonly = foo($bar); # false
$readonly = foo(0); # true

refaddr EXPR

If EXPR evaluates to a reference the internal memory address of the referenced value is returned. Otherwise undef is returned.

$addr = refaddr "string"; # undef
$addr = refaddr $var; # eg 12345678
$addr = refaddr []; # eg 23456784

$obj = bless {}, "Foo";
$addr = refaddr $obj; # eg 88123488

reftype EXPR

If EXPR evaluates to a reference the type of the variable referenced is returned. Otherwise undef is returned.

$type = reftype "string"; # undef
$type = reftype $var; # SCALAR
$type = reftype []; # ARRAY

$obj = bless {}, "Foo";
$type = reftype $obj; # HASH

set_prototype CODEREF, PROTOTYPE

Sets the prototype of the given function, or deletes it if PROTOTYPE is undef. Returns the CODEREF.

set_prototype &foo, $$;

tainted EXPR

Return true if the result of EXPR is tainted

$taint = tainted("constant"); # false
$taint = tainted($ENV{PWD}); # true if running under -T

weaken REF

REF will be turned into a weak reference. This means that it will not hold a reference count on the object it references. Also when the reference count on that object reaches zero, REF will be set to undef.

This is useful for keeping copies of references , but you dont want to prevent the object being DESTROY-ed at its usual time.

{
my $var;
$ref = $var;
weaken($ref); # Make $ref a weak reference
}
# $ref is now undef

Note that if you take a copy of a scalar with a weakened reference, the copy will be a strong reference.

my $var;
my $foo = $var;
weaken($foo); # Make $foo a weak reference
my $bar = $foo; # $bar is now a strong reference

This may be less obvious in other situations, such as grep(), for instance when grepping through a list of weakened references to objects that may have been destroyed already:

@object = grep { defined } @object;

This will indeed remove all references to destroyed objects, but the remaining references to objects will be strong, causing the remaining objects to never be destroyed because there is now always a strong reference to them in the @object array.

B::Terse - Walk Perl syntax tree, printing terse info about ops.

SYNOPSIS

perl -MO=Terse[,OPTIONS] foo.pl

This version of B::Terse is really just a wrapper that calls B::Concise with the -terse option. It is provided for compatibility with old scripts (and habits) but using B::Concise directly is now recommended instead.

For compatibility with the old B::Terse, this module also adds a method named terse to B::OP and B::SV objects. The B::SV method is largely compatible with the old one, though authors of new software might be advised to choose a more user-friendly output format. The B::OP terse method, however, doesnt work well. Since B::Terse was first written, much more information in OPs has migrated to the scratchpad datastructure, but the terse interface doesnt have any way of getting to the correct pad. As a kludge, the new version will always use the pad for the main program, but for OPs in subroutines this will give the wrong answer or crash.

Language::Zcode::Runtime::State is a Perl module to handle saving, restoring, etc. the game state.

restoring

Getter/setter: currently in the process of restoring or not?

start_machine

Start executing the Z-machine.

In the normal case (starting a new game, or restarting), this is as simple as calling the Z-machine subroutine whose address is stored in the header.
If were restoring from a save file, its more complicated. See "resume_execution".

z_call

Wrapper around Z-code subroutine calls. The main reason we need it is for save/restore.

In the normal case, z_call just calls the Z-code subroutine at address arg0 with the given args (arg5-argn), if any. Args 1-4 arent used by z_call, but (hack alert!) they go into the Perl call stack, which is needed for saving Z-machine state.

Input: subroutine address to call, local variables & eval stack (arrayrefs), next PC, store variable, args to the Z-sub.

See "The call stack" for far more detail on this sub and save/restore.

save_state

Implement the @save opcode, saving the current Z-machine state (as opposed to writing a table to a file, the other use of the @save opcode)

Note that this sub also gets called at the very end of the restoring process.

Returns 0 for failed save, 1 for successful save, 2 for "just finished restoring".

build_save_stack

Create a Z-machine call stack by peeking at the Perl call stack.

When calling Z_machine subroutines, we call z_call with all the information contained in a Z stack frame. We retrieve that information from the Perl call stack and build a Z-machine call stack with it.

restore_state

Implement the @restore opcode, restoring the current Z-machine state (as opposed to reading a table from a file, the other use of the @restore opcode)

SYNOPSIS

#####
# Subroutines
#
use Tie::Layers qw(is_handle config);

$yes = is_handle( $file_handle );

($key, $old_value) = config(%options, $key);
($key, $old_value) = config(%options, $key => $new_value );

####
# Config default startup options
#
@old_options_list = config(%options, @option_list);
@old_options_list = config(%options, @option_list);
@old_options_list = config(%options, %option_list);

#####
# Class interface
#
require Tie::Layers;

#####
# Using support methods and file handle with
# the file subroutines such as open(), readline()
# print(), close()
#
tie *LAYERS_FILEHANDLE, Tie::Layers, @options
$layers = tied *LAYERS_FILEHANDLE;


#####
# Using support methods only, no file subroutines
#
$layers = Tie::Layers->TIEHANDLE(@options);

($key, $old_value) = $layers->config($key);
($key, $old_value) = $layers->config($key => $new_value );

@old_options_list = $layers->config(@option_list);
@old_options_list = $layers->config(@option_list);
@old_options_list = $layers->config(%option_list);

$data = $layers->fin($filename, @options);

$data = $layers->fout($filename, $data, @options);

$yes = $layers->is_handle( $file_handle );

If a subroutine or method will process a list of options, @options, that subroutine will also process an array reference, @options, [@options], or hash reference, %options, {@options}.

The Tie::Layers program module contains the tie file handle Tie::Layers package. The Tie::Layers package provides the ability to insert a stack of subroutines between file subroutines print and realine and the underlying $file. The syntax of the subroutines of each layer of the readline stack and the print stack must comply to the the requirements described herein below.

This is necessary so that the Tie::Layers READLINE and PRINT subroutines know how to transfer the output from one layer to the input of another layer. The stacks are setup by supplying options with a reference to the subroutine for each layer in the print stack and the readline stack. The Tie::Layers are line orientated and do not support any character file subrouintes.

The getc, read, and write file subroutines are supported by the Tie::Layers package. The seek routines are line oriented in that the seek and tell subroutine positions are the line in the underlying file and not the character position in the file.

Async::Group is a Perl class to deal with simultaneous asynchronous calls.

SYNOPSIS

use Async::Group ;
use strict ;

sub sub1
{
print "Dummy subroutine n";
my $dummy = shift ;
my $cb = shift ;

&$cb(1);
}

sub allDone
{
print "All done, result is ", shift ,"n" ;
}
my $a = Async::Group->new(name => aTest, test => 1) ;

$a->run(set => [ sub {⊂1( callback => sub {$a->callDone(@_)} )},
sub {⊂1( callback => sub {$a->callDone(@_)} )} ],
callback => &allDone
)

# or another way which avoids the clumsy nested subs
my $cb = $a->getCbRef();
$a->run(set => [ sub {⊂1( callback => $cb)},
sub {⊄1( callback => $cb )} ],
callback => &allDone
)

If you sometimes have to launch several asynchronous calls in parrallel and want to call one call-back function when all these calls are finished, this module may be for you.

Async::Group is a class which enables you to call several asynchronous routines. Each routine may have their own callback. When all the routine are over (i.e. all their callback were called), Async::Group will call the global callback given by the user.

Note that one Async::Group objects must be created for each group of parrallel calls. This object may be destroyed (or will vanish itself) once the global callback is called.

Note also that Async::Group does not perform any fork or other system calls. It just run the passed subroutines and keep count of the call-back functions called by the aforementionned subroutines. When all these subs are finished, it calls another call-back (passed by the user) to perform whatever function required by the user.

Using fork or threads or whatever is left to the user.

Ace::Browser::AceSubs Perl module contains subroutines for AceBrowser.

SYNOPSIS

use Ace;
use Ace::Browser::AceSubs;
use CGI qw(:standard);
use CGI::Cookie;

my $obj = GetAceObject() || AceNotFound();
PrintTop($obj);
print $obj->asHTML;
PrintBottom();

Ace::Browser::AceSubs exports a set of routines that are useful for creating search pages and displays for AceBrowser CGI pages. See http://stein.cshl.org/AcePerl/AceBrowser.

The following subroutines are exported by default:

AceError
AceMissing
AceNotFound
Configuration
DoRedirect
GetAceObject
Object2URL
ObjectLink
OpenDatabase
PrintTop
PrintBottom
Url

The following subroutines are exported if explicitly requested:

AceAddCookie
AceInit
AceHeader
AceMultipleChoices
AceRedirect
DB_Name
Footer
Header
ResolveUrl
Style
Toggle
TypeSelector

To load the default subroutines load the module with:

use Ace::Browser::AceSubs;

To bring in a set of optionally routines, load the module with:

use Ace::Browser::AceSubs qw(AceInit AceRedirect);

To bring in all the default subroutines, plus some of the optional ones:

use Ace::Browser::AceSubs qw(:DEFAULT AceInit AceRedirect);

There are two main types of AceBrowser scripts:

display scripts

These are called with the CGI parameters b and b , corresponding to the name and class of an AceDB object to display. The subroutine GetAceObject() will return the requested object, or undef if the object does not exist.

To retrieve the parameters, use the CGI.pm param() method:

$name = param(name);
$class = param(class);
search scripts

These are not called with any CGI parameters on their first invocation, but can define their own parameter lists by creating fill-out forms. The AceBrowser system remembers the last search performed by a search script in a cookie and regenerates the CGI parameters the next time the user selects that search script.