Free ref software for linux

Text::Refer can parse Unix "refer" files.

SYNOPSIS

Pull in the module:

use Text::Refer;

Parse a refer stream from a filehandle:

while ($ref = input Text::Refer *FH) {
# ...do stuff with $ref...
}
defined($ref) or die "error parsing input";

Same, but using a parser object for more control:

# Create a new parser:
$parser = new Text::Refer::Parser LeadWhite=>KEEP;

# Parse:
while ($ref = $parser->input(*FH)) {
# ...do stuff with $ref...
}
defined($ref) or die "error parsing input";

Manipulating reference objects, using high-level methods:

# Get the title, author, etc.:
$title = $ref->title;
@authors = $ref->author; # list context
$lastAuthor = $ref->author; # scalar context

# Set the title and authors:
$ref->title("Cyberiad");
$ref->author(["S. Trurl", "C. Klapaucius"]); # arrayref for >1 value!

# Delete the abstract:
$ref->abstract(undef);

Same, using low-level methods:

# Get the title, author, etc.:
$title = $ref->get(T);
@authors = $ref->get(A); # list context
$lastAuthor = $ref->get(A); # scalar context

# Set the title and authors:
$ref->set(T, "Cyberiad");
$ref->set(A, "S. Trurl", "C. Klapaucius");

# Delete the abstract:
$ref->set(X); # sets to empty array of values

Output:

print $ref->as_string;

File::Repl is a Perl module that provides file replication utilities.

SYNOPSIS

use File::Repl;

%con = {
dira => C:/perl,
dirb => M:/perl,
verbose => 1,
age => 10,
};

$ref=File::Repl->New(%con);
$r1 = $ref->Update(.p(l|m),ab,1);
$r2 = $ref->Update(.t.*,ab,1,.tmp$);

The File:Repl provides simple file replication and management utilities. Its main functions are

File Replication

Allowing two directory structures to be maintained, ensuring files that meet selection logic criteria are mirrored and otherwise synchronized.

Bulk Renaming

Allowing files in a directory structure to be renamed according to the selection logic.

Compressing

Allowing files in a directory structure to be compressed according to a given logic.

Process

Run a common perl process against files in a directory structure according to selection logic.

Deletion

Allowing files in a directory structure to be deleted according to the selection logic.

Proc::Forking is a Perl module that provides a set of tool to fork and daemonize.

SYNOPSIS

#!/usr/bin/perl

use strict;
use Proc::Forking;
use Data::Dumper;
use Time::HiRes qw(usleep); # to allow micro sleep

my $f = Proc::Forking->new();
$SIG{ KILL } = $SIG{ TERM } = $SIG{ INT } = sub { $f->killall_childs;sleep 1; exit },
$f->daemonize(
## uid => 1000,
## gid => 1000,
## home => "/tmp",
pid_file => "/tmp/master.pid"
);

open( STDOUT, ">>/tmp/master.log" );
my $nbr = 0;
my $timemout;

while ( 1 )
{
if ( $nbr < 20 )
{
my $extra = "other parameter";
my ( $status, $pid, $error ) = $f->fork_child(
function => &func,
name => "new_name.##",
args => [ "hello SOMEONE", 3, $extra ],
pid_file => "/tmp/fork.##.pid",
uid => 1000,
gid => 1000,
home => "/tmp",
max_load => 5,
max_mem => 185000000,
expiration => 10,
# expiration_auto => 1,
);
if ( $status == 4 ) # if the load become to high
{
print "Max load reached, do a little napn";
usleep( 100000 );
next;
}
elsif ( $status ) # if another kind of error

{
print "PID=$pidt error=$errorn";
print Dumper( $f->list_names() );
print Dumper( $f->list_pids() );
}
}
$nbr = $f->pid_nbr;
my ( $n, @dp, @dn ) = $f->expirate;
if ( $n )
{
print Dumper( @dp );
}
print "free=n";
usleep( 100000 ); # always a good idea to put a small sleep to allow task swapper to gain some free resources
}

sub func
{
my $ref = shift;
my @args = @$ref;
my ( $data, $time_out, $sockC ) = @args;
$SIG{ USR1 } = sub { open my $log, ">>/tmp/log.s"; print $log "signal USR1 receivedn"; close $log; };
if ( !$time_out )
{
$time_out = 3;
}
open my $FF, ">>/tmp/loglist";
print $FF $$, " start time =", $^T;
close $FF;

for ( 1 .. 4 )
{
open my $fh, ">>/tmp/log";
if ( defined $fh )
{
print $fh "TMOUT = $time_out " . time . " PID=$$ cwd=" . Cwd::cwd() . " name =$0n";
$fh->close;
}
sleep $time_out + rand( 5 );
}
}

Variable::Alias is a Perl module created to alias any variable to any other variable.

SYNOPSIS

use Variable::Alias alias;
my $src;
my $a;
our $b;
my @c;
our @d;

alias $src => $a;
alias $a => $b;
alias $b => $c[0];
alias @c => @d;

$src=src;
# All the other variables now have the string
# src in the appropriate places.

There are various ways to alias one variable to another in Perl. The most popular is by assigning to typeglobs. This is quite efective, but only works with globals. Another method is to use a module like Lexical::Alias or Devel::LexAlias, but as their names suggest, these only work with lexicals. Theres no way to alias an element of an array or hash.

Variable::Alias changes all that. It uses a tie to provide One True Way to alias a variable.

Interface

Variable::Alias may export any or all of five functions. If youve used Lexical::Alias, the interface is virtually identical.

alias(VAR, VAR)

alias takes two variables of any type (scalar, array or hash) and aliases them. Make sure they have the sigil you want on the front.

This function is only available in Perl 5.8.0 and later, because the prototype tricks it uses were first implemented in that version.

alias_s(SCALAR, SCALAR)

alias_s takes two scalars and aliases them.

alias_a(ARRAY, ARRAY)

alias_a takes two arrays and aliases them. Note that this is actual arrays, not array elements, although you can alias references in elements, like so:

alias_a(@short, @{$some->sequence->{of}->calls->{thats}[2]{long}});

alias_h(HASH, HASH)

alias_h takes two hashes and aliases them.

alias_r(REF, REF)

alias_r takes two references and aliases them. The referents must be of the same type.

ShiftJIS::Regexp contains regular expressions in Shift-JIS.

SYNOPSIS

use ShiftJIS::Regexp qw(:all);

match($string, p{Hiragana}{2}p{Digit}{2});
match($string, pH{2}pD{2});
# these two are equivalent:

This module provides some functions to use regular expressions in Shift-JIS on the byte-oriented perl.

The legal Shift-JIS character in this module must match the following regular expression:

[x00-x7FxA1-xDF]|[x81-x9FxE0-xFC][x40-x7Ex80-xFC]

To avoid false matching in multibyte encoding, this module uses anchoring technique to ensure each matching position places at the character boundaries.

cf. perlfaq6, "How can I match strings with multibyte characters?"

Functions

re(PATTERN)

re(PATTERN, MODIFIER)

Returns a regular expression parsable by the byte-oriented perl.

PATTERN is specified as a string. MODIFIER is specified as a string. Modifiers in the following list are allowed.

i case-insensitive pattern (only for ascii alphabets)
I case-insensitive pattern (greek, cyrillic, fullwidth latin)
j hiragana-katakana-insensitive pattern (but halfwidth katakana
are not considered.)

s treat string as single line
m treat string as multiple lines
x ignore whitespace (i.e. [x20nrtf]) unless backslashed
or inside a character class; but comments are not recognized!

o once parsed (not compiled!) and the result is cached internally.
o modifier
while ( ) {
print replace($_, (perl), $1, igo);
}
is more efficient than

while ( ) {
print replace($_, (perl), $1, ig);
}

because in the latter case the pattern is parsed every time
whenever the function is called.

match(STRING, PATTERN)

match(STRING, PATTERN, MODIFIER)

An emulation of m// operator aware of Shift-JIS. But, to emulate @list = $string =~ m/PATTERN/g, the pattern should be parenthesized (capturing parentheses are not added automatically).

@list = match($string, pH, g); # wrong; returns garbage!
@list = match($string,(pH),g); # good
PATTERN is specified as a string. MODIFIER is specified as a string.
i,I,j,s,m,x,o please see re().

g match globally
z tell the function the pattern matches an empty string
(sorry, due to the poor auto-detection)

replace(STRING or SCALAR REF, PATTERN, REPLACEMENT)

replace(STRING or SCALAR REF, PATTERN, REPLACEMENT, MODIFIER)

An emulation of s/// operator but aware of Shift-JIS.
If a reference to a scalar is specified as the first argument, substitutes the referent scalar and returns the number of substitutions made. If a string (not a reference) is specified as the first argument, returns the substituted string and the specified string is unaffected.

MODIFIER is specified as a string.

i,I,j,s,m,x,o please see re().
g,z please see match().

jsplit(PATTERN or ARRAY REF of [PATTERN, MODIFIER], STRING)

jsplit(PATTERN or ARRAY REF of [PATTERN, MODIFIER], STRING, LIMIT)

An emulation of CORE::split but aware of Shift-JIS.
In scalar/void context, it does not split into the @_ array; in scalar context, only returns the number of fields found.
PATTERN is specified as a string. But as PATTERN has no special meaning; it splits the string on a single space similarly to CORE::split / /.

When you want to split the string on whitespace, pass an undefined value as PATTERN or use the splitspace() function.

jsplit(undef, " x81x40 This is x81x40 perl.");
splitspace(" x81x40 This is x81x40 perl.");
# (This, is, perl.)

If you want to pass pattern with modifiers, specify an arrayref of [PATTERN, MODIFIER] as the first argument. You can also use "Embedded Modifiers").

MODIFIER is specified as a string.

i,I,j,s,m,x,o please see re().

splitspace(STRING)

splitspace(STRING, LIMIT)

This function emulates CORE::split( , STRING, LIMIT). It returns a list given by split STRING on whitespace including "x81x40" (IDEOGRAPHIC SPACE). Leading whitespace characters do not produce any field.

Note: splitspace(STRING, LIMIT) is equivalent to jsplit(undef, STRING, LIMIT).

splitchar(STRING)

splitchar(STRING, LIMIT)

This function emulates CORE::split(//, STRING, LIMIT). It returns a list given by split of STRING into characters.
Note: splitchar(STRING, LIMIT) is equivalent to jsplit(, STRING, LIMIT).

Brick::Composers Perl module defines composing functions in the Brick::Constraints package. Each function takes a list of code refs and returns a single code ref that wraps all of them. The single code ref returns true or false (but defined), as with other constraints.

If a composer cannot create the single code ref (for instance, due to bad input) it returns undef of the empty list, indicating a failure in programming rather than a failure of the data to validate.

__and( LIST OF CODEREFS )
__compose_satisfy_all( LIST OF CODEREFS )

This is AND with NO short-circuiting.

( A && B && C )

This function creates a new constraint that returns true if all of its constraints return true. All constraints are checked so there is no short-circuiting. This allows you to get back all of the errors at once.

__or( LIST OF CODEREFS )
__compose_satisfy_any( LIST OF CODEREFS )

This is OR but with NO short-circuiting.

( A || B || C )

This function creates a new constraint that returns true if all of its constraints return true. All constraints are checked so there is no short-circuiting.

__none( LIST OF CODEREFS )
__compose_satisfy_none( LIST OF CODEREFS )

( NOT A && NOT B && NOT C )

NOT ( A || B || C )

This function creates a new constraint that returns true if all of its constraints return false. All constraints are checked so there is no short-circuiting.

__compose_satisfy_N( SCALAR, LIST OF CODEREFS )

This function creates a new constraint that returns true if exactly N of its constraints return true. All constraints are checked so there is no short-circuiting.

__compose_satisfy_N_to_M( LIST OF CODEREFS )

This function creates a new constraint that returns true if between N and M (inclusive) of its constraints return true. All constraints are checked so there is no short-circuiting.

__not( CODEREF )
__compose_not( CODEREF )

This composers negates the sense of the code ref. If the code ref returns true, this composer makes it false, and vice versa.

__compose_until_pass
__compose_pass_or_skip

Go through the list of closures, trying each one until one suceeds. If a closure doesnt die, but doesnt return true, this doesnt fail but just moves on. Return true for the first one that passes, short-circuited the rest. If none of the closures pass, die with an error noting that nothing passed.

If one of the subs dies, this composer still dies.
This can still die for programming (not logic) errors.

__compose_until_fail
__compose_pass_or_stop

Keep going as long as the closures return true.

The closure that returns undef is a selector.

If a closure doesnt die and doesnt dont fail, just move on. Return true for the first one that passes, short-circuited the rest. If none of the closures pass, die with an error noting that nothing passed.

This can still die for programming (not logic) errors.

$result $@ what action
------------------------------------------------------------
1 undef passed go on to next brick

undef undef selector stop, return undef, no die
failed

undef string program stop, die with string
error

undef ref validator stop, die with ref
failed

XML::Simple::DTDReader is a simple XML file reading based on their DTDs.

SYNOPSIS

use XML::Simple::DTDReader;

my $ref = XMLin("data.xml");
Or the object oriented way:
require XML::Simple::DTDReader;

my $xsd = XML::Simple::DTDReader->new;
my $ref = $xsd->XMLin("data.xml");

XML::Simple::DTDReader aims to be a XML::Simple drop-in replacement, but with several aspects of the module controlled by the XMLs DTD. Specifically, array folding and array forcing are inferred from the DTD.

Currently, only XMLin is supported; support for XMLout is planned for later releases.

netToe project is a Tic Tac Toe game for the Linux console, playable over the network.
netToe is a Tic Tac Toe-like game for the Linux console written in C using UNIX sockets. It is playable by 2 players over the network, against computer AI, or against another player on the same machine.
Enhancements:
- Completed the code section regarding colors.
- netToe now uses colors !
- Modified the parse_cmd_args(...) function to accept more than one argument at time, option --no-colors added. (ref: misc.c)
- Added modules terminal.c and terminal.h Those file include the new code to handle colors in nettoe.
- Added modules matrices.c and matrices.h Those files include the new code to handle the nettoe board matrix.
- Removed netmisc.c and netmisc.h modules and included the code in the network.c and network.h modules.