Free commands software for linux

Commands::Guarded Perl package provides better scripts through guarded commands.

SYNOPSIS

use Commands::Guarded;

my $var = 0;

step something =>
ensure { $var == 1 }
using { $var = 1 }
; # $var is now 1

step nothing =>
ensure { $var == 1 }
using { $var = 2 } # bug!
; # $var is still 1 (good thing too)

my $brokeUnless5 =
step brokenUnless5 =>
ensure { $var == 5 }
using { $var = shift }
; # nothing happens yet

print "var: $varn"; # prints 1

$brokeUnless5->do(5);

print "now var: $varn"; # prints 5

step fail =>
ensure { $var == 3 }
using { $var = 2 }
; # Exception thrown here

This module implements a deterministic, rectifying variant on Dijkstras guarded commands. Each named step is passed two blocks: an ensure block that defines a test for a necessary and sufficient condition of the step, and a using block that will cause that condition to obtain.

If step is called in void context (i.e., is not assigned to anything or used as a value), the step is run immediately, as in this pseudocode:

unless (ENSURE) {
USING;
die unless ENSURE;
}

If step is called in scalar or array context, execution is deferred and instead a Commands::Guarded object is returned, which can be executed as above using the do method. If do is given arguments, they will be passed to the ensure block and (if necessary) the using block.

The interface to Commands::Guarded is thus a hybrid of exported subroutines (see SUBROUTINES below) and non-exported methods (see METHODS).
For a detailed discussion of the reason for this modules existence, see RATIONALE below.

POE::Component::ControlPort::DefaultCommands is a set of default commands available to the control port.

Tank Command project is a fast-paced 2D arcade game.

Tank Command is a fast paced 2D arcade game in which the player must destroy all of the enemy units.

A balance between careful strategy and shoot-em-up action, this game is a fun and exciting way to pass some spare time.

AFS::Command::BOS is a OO API to the AFS bos command.

SYNOPSIS

use AFS::Command::BOS;

my $bos = AFS::Command::BOS->new();

my $bos = AFS::Command::BOS->new
(
command => $path_to_your_bos_binary,
);

my $bos = AFS::Command::BOS->new
(
localauth => 1,
);

This module implements an OO API wrapper around the AFS bos command. The supported methods depend on the version of the bos binary used, and are determined automagically.

Proc::Command is a backtick that does not use the shell for Perl under Windows.

SYNOPSIS

use Proc::Command

@reponse = Proc::Command->command($command)
@reponse = Proc::Command->command($command, $trys)
@reponse = Proc::Command->command($command, $trys, $sleep)

use Proc::Command qw(command)

@reponse = command($command)
@reponse = command($command, $trys)
@reponse = command($command, $trys, $sleep)

Some Perls under Microsoft windows suffers disabilities over Unix Perls. One particular disability is a backtick without the console. Altough the Microsoft console, may be started without a window (start command with /b option or spawn program call), the Perl system command on windows usually creates a window. Creating a window causes immense user interface problem since it will randomly pop-up and take focus over the current window, erasing current entries into that window. Solutions such as "Proc::SafePipe" do not run on Perls for Window.

This module provides an answer by using the "open" command with a pipe to provide a backtick without a console that will run under Perls on Microsoft Windows.

Missile Command project is a game in which you have to save your city from nuclear doom.

Missile Command is a clone of the Atari save-your-city-from-impending-nuclear-doom game.

SVK::Command::Help is a Perl module to show help.

OPTIONS

Optionally svk helps can pipe through a pager, for it is easier to read if the output is too long. For using this feature, please set environment variable SVKPAGER to some pager program. For example:

# bash, zsh users
export SVKPAGER=/usr/bin/less

# tcsh users
setenv SVKPAGER /usr/bin/less

Remote Secure Command System project is a remote asynchronous and secure command system based on a file configuration.

A standalone server sends and receives commands through files, and a batch system launch ssh and scp commands.