Free arg software for linux

Argv is a Perl module that provides an OO interface to an arg vector.

SYNOPSIS

use Argv;

# A roundabout way of getting perls version.
my $pl = Argv->new(qw(perl -v));
$pl->exec;

# Run /bin/cat, showing how to provide "predigested" options.
Argv->new(/bin/cat, [qw(-u -n)], @ARGV)->system;

# A roundabout way of globbing.
my $echo = Argv->new(qw(echo M*));
$echo->glob;
my $globbed = $echo->qx;
print "echo M* globs to: $globbed";

# A demonstration of head-like behavior (aborting early)
my $maxLinesToPrint = 5;
my $callback = sub {
print shift;
return !(--$maxLinesToPrint);
};
my $head = Argv->new(ls, [qw(-l -a)]);
$head->readonly("yes");
$head->pipe($callback);

# A demonstration of the builtin xargs-like behavior.
my @files = split(/s+/, $globbed);
my $ls = Argv->new(qw(ls -d -l), @files);
$ls->parse(qw(d l));
$ls->dbglevel(1);
$ls->qxargs(1);
my @long = $ls->qx;
$ls->dbglevel(0);
print @long;

# A demonstration of how to use option sets in a wrapper program.
@ARGV = qw(Who -a -y foo -r); # hack up an @ARGV
my $who = Argv->new(@ARGV); # instantiate
$who->dbglevel(1); # set verbosity
$who->optset(qw(UNAME FOO WHO)); # define 3 option sets
$who->parseUNAME(qw(a m n p)); # parse these to set UNAME
$who->parseFOO(qw(y=s z)); # parse -y and -z to FOO
$who->parseWHO(r); # for the who cmd
warn "got -y flag in option set FOOn" if $who->flagFOO(y);
print Argv->new(uname, $who->optsUNAME)->qx;
$who->prog(lc $who->prog); # force $0 to lower case
$who->exec(qw(WHO)); # exec the who cmd

WML::Card is a Perl extension for builiding WML Cards according to the browser being used.

SYNOPSIS

use WML::Card;
my $options= [ [Option 1, http://...], [Option 2, http://...], ];
my $c = WML::Card->guess(index,Wap Site); $c->link_list(indice, undef, 0, $options, $options); $c->print;

This perl library simplifies the creation of WML cards on the fly. It produces the most suitable wml code for the browser requesting the card. In this way the one building the cards does not have to worry about the differences in how each wap browser displays the wml code. In combination wht WML::Deck it provides functionality to build WAP applications.

Methods

$card = WML::Card->guess( $id, $title, [$user_agent] );
This class method constructs a new WML::Card object. The first argument defines the WML cards id and the second argument its title. The if the third argument is not defined, the value is obtained from $ENV{HTTP_USER_AGENT}.

$c->buttons($label, $type, $task, $href)
$c->table ($data, $title, $offset, $pager, @headers)
$c->link_list($name, $listtitle, $offset, $pager, $data, $align)
$c->value_list($name, $listtitle, $offset,$pager,$data)

The variable $data is an array reference like: my $menu_items= [ [Option 1, http://...], [Option 2, http://...], ];

The variable $pager is the number of items wanted to be displayed in each card.

$c->print
$c->info($content)
$c->img($file, $alt)
$c->input($label, $text, $name, $format, $type, $size, $target, $arg);
$c->link($target, $text);
$c->br

VTKImaging is a Perl interface to VTKImaging library.

Graphics::VTK::BooleanTexture

Inherits from StructuredPointsSource

Functions Supported for this class by the PerlVTK module: (To find more about their use check the VTK documentation at http://www.kitware.com.)

const char *GetClassName ();
unsigned char *GetInIn ();
(Returns a 2-element Perl list)
unsigned char *GetInOn ();
(Returns a 2-element Perl list)
unsigned char *GetInOut ();
(Returns a 2-element Perl list)
unsigned char *GetOnIn ();
(Returns a 2-element Perl list)
unsigned char *GetOnOn ();
(Returns a 2-element Perl list)
unsigned char *GetOnOut ();
(Returns a 2-element Perl list)
unsigned char *GetOutIn ();
(Returns a 2-element Perl list)
unsigned char *GetOutOn ();
(Returns a 2-element Perl list)
unsigned char *GetOutOut ();
(Returns a 2-element Perl list)
int GetThickness ();
int GetXSize ();
int GetYSize ();
vtkBooleanTexture *New ();
void SetInIn (unsigned char , unsigned char );
void SetInOn (unsigned char , unsigned char );
void SetInOut (unsigned char , unsigned char );
void SetOnIn (unsigned char , unsigned char );
void SetOnOn (unsigned char , unsigned char );
void SetOnOut (unsigned char , unsigned char );
void SetOutIn (unsigned char , unsigned char );
void SetOutOn (unsigned char , unsigned char );
void SetOutOut (unsigned char , unsigned char );
void SetThickness (int );
void SetXSize (int );
void SetYSize (int );

vtkBooleanTexture Unsupported Funcs:

Functions which are not supported supported for this class by the PerlVTK module.

void PrintSelf (ostream &os, vtkIndent indent);
I/O Streams not Supported yet

void SetInIn (unsigned char a[2]);
Arg types of unsigned char * not supported yet
void SetInOn (unsigned char a[2]);
Arg types of unsigned char * not supported yet
void SetInOut (unsigned char a[2]);
Arg types of unsigned char * not supported yet
void SetOnIn (unsigned char a[2]);
Arg types of unsigned char * not supported yet
void SetOnOn (unsigned char a[2]);
Arg types of unsigned char * not supported yet
void SetOnOut (unsigned char a[2]);
Arg types of unsigned char * not supported yet
void SetOutIn (unsigned char a[2]);
Arg types of unsigned char * not supported yet
void SetOutOn (unsigned char a[2]);
Arg types of unsigned char * not supported yet
void SetOutOut (unsigned char a[2]);
Arg types of unsigned char * not supported yet

Devel::CallerItem is an Perl object representing a function call from the stack of function calls.

SYNOPSIS

Usage:

require Devel::CallerItem;

$call = Devel::CallerItem->from_depth($depth) || return;
$passed_arguments_ref = $call->argument_list_ref();
$callpack = $call->pack();
$callfile = $call->file();
$callline = $call->line();
$callsub = $call->subroutine();
$bool = $call->has_args();
$bool = $call->wants_array();
($arg_ref,@caller) = $call->as_array();
$call_string = $call->as_string($print_level);
$passed_arguments_string = $call->arguments_as_string();

$printable_arg = Devel::CallerItem->printable_arg($arg,$print_level);

Devel::CallerItem objects hold all the information about a specific function call on the stack. The information is basically that obtained from caller and @DB::args, packaged into an object. This comes with some useful methods to print the object in a nice way.

Nasal is a language that I wrote for use in a personal project. Ostensibly it was because I was frustrated with the dearth of small-but-complete embeddable scripting languages, but of course I really wrote it because it was fun.
It is still young and incomplete in a few places, but is under active development and has been integrated as the extension language for the FlightGear simulator.
Documentation is still sparse. There is a design document available, which talks at length about the "whys" behind the design of Nasal and includes documentation for the built-in library functions.
More useful to the experienced programmer is the tutorial-style sample code, which explains and demonstrates all the syntax features of the language.
Like perl, python and javascript, nasal uses vectors (expandable arrays) and hash tables as its native data format. This is a well-understood idiom, and it works very well. I felt no need to rock the boat here.
Like perl, and unlike everything else, nasal combines numbers and strings into a single "scalar" datatype. No conversion needs to happen in user code, which simplifies common string handling tasks.
Like perl, but unlike python, hash keys must by scalars in nasal. Python supports a "tuple" constant type that can be used as well, but there is no equivalent in nasal (you cant use vectors as keys because they might change after the insertion).
Like perl and python, nasal uses a # character to indicate and end-of-line comment. There is no multiline begin/end comment syntax as in Javascript.
Like perl, nasal functions do not have named parameters. They get their arguments in a vector named "arg", and can extract them however they like. Unlike perl, Nasal takes advantage of this feature to do away with function "declaration" entirly; see below.
Like python, there is no hidden local object scope in a function call. The object on which a method was called is available to a function as a local variable named "me" (python calls this "self" by convention, but because nasal has no declared function arguments, there is no opportunity to change it).
Like perl, "objects" in nasal are simply hash tables. Looking an item up by name in a hash table and extracting a symbol for an object are just different syntax for the same operation (but read on for an important exception):
a["b"] = 1 means the same thing as: a.b = 1
The above paragraph is a minor lie. The "dot" syntax is also the clue to the interpreter to "save" the left hand side as the "me" reference if the expression is used as a function/method call. That is, these expressions are not equivalent (one is a plain function call, the other a method invocation on the object "a"):
a["b"](arg1, arg2) isnt the same as: a.b(arg1, arg2)
Like javascript, nasal lacks a specific "class" syntax for OOP programming. Instead, classes are simply objects. Each object supports a "parents" member array; symbol lookup on the object at runtime bounces to the parents (and the parents parents) if the symbol is not found in the hash. The parents field is just like any other object field, you can set it however you like and even change it at runtime if you are feeling especially perverse.
Like lisp, javascript and perl, nasal supports lexical closures. This means that the local symbol namespace available to your function when it is assigned remain constant over time. If you dont know what this means, you dont need to care. It is this feature that allows functions to use variables declared in the outer scope when it is defined (e.g. seeing "module" variables).
Like all other scripting languages, functions are just symbols in a namespace, but unlike all other scripting languages, there is no function "declaration" syntax. A function is always an anonymous object (a "lambda," in the parlance), which you assign to a variable in order to use. Like so:
myfunction = func { arg[0] + 1 }
myfunction(1); # returns 2
One annoyance of this feature is that Nasal functions dont have unique internal "names". So a debugging or exception stack trace can only give you a source line number, and not a function name as reference.
Nasal has a straightforward, readable syntax which is closest to javascript among other scripting languages. Like later versions of javascript, it includes has a hash lookup syntax as well as an object field accessor syntax (that is, you can do both a.b and a["b"]).
Unlike python, nasal has a grammar which is not whitespace-sensitive. This doesnt make python hard to write, and it arguably makes it easier to read. But it is different from the way the rest of the world works, and makes python distinctly unsuitable for "inline" environments (consider PHP, Javascript, ASP or in-configuration-file scripts) where it needs to live as a plain old string inside of another programs code or data file.
Nasal garbage collects runtime storage, so the programmer need not worry about manual allocation, or even circular references. The current implementation is a simple mark/sweep collector, which should be acceptable for most applications. Future enhancements will include a "return early" capability for latency-critical applications. The collector can be instructred to return after a certain maximum delay, and be restarted later. Fancy items like generational collectors fail the "small and simple" criteria and are not likely to be included.
Like python, nasal supports exception handling as a first-class language feature, with built-in runtime-inspectable stack trace. Rather like perl, however, there is no special "try" syntax for exception handling, nor inheritance-based catching semantics. Instead, you call a "try" function on another function, and inspect the return value on your own. Code simply calls die with an argument list, which is returned from the closest enclosing try() invocation. Elaborate exception handling isnt really appropriate for embedded scripting languages. [NOTE: this isnt finished yet]
Nasal tries to be stricter than perl. Operations like converting a non-numeric string value to a number, reading or writing past the end of an array or operating on a nil reference, which are generally legal in perl, throw exceptions in nasal. Perl sometimes bends over backwards to do something "reasonable" with your instructions (e.g. whats the boolean truth value of a hash reference?); nasal doesnt try ("error: non-scalar used in boolean context at line 92")
Nasal is very small, very simple, written in ANSI C, and generally an excellent choice for embedded applications. It uses a simple and transparent syntax interpretable by a simple "bracket matching and operator precedence" parser. It does not depend on any third party libraries other than the standard C library. It does not depend on third party tools like (f)lex and yacc/bison. It builds simply and easily, supports a reasonably simple extension API and cohabitates well with other code.
Nasal makes no use of the processor stack when running recursive code. This is important for embedded languages as it provides the ability to "exit early" from a Nasal context. An outside application may have realtime constraints, and Nasal can be instructed to run for only a certain number of "cycles" before returning. Later calls will automatically pick up the interpreter state where it left off.
Nasal provides "minimal threadsafety". Multithreaded operations on Nasal objects are safe in the sense that they cannot crash or corrupt the interpreter. They are not guaranteed to be atomic. In particular, poorly synchronized insertions into containers can "drop" objects into oblivion (which is OK from an interpreter stability standpoint, since the GC will clean them up normally). Race conditions have to be the programmers problem anyway, this is just another symptom. Garbage collection will block all threads before running. [NOTE: this part is still unimplemented.]
Enhancements:
- This release contains the updates that have been available in SimGear for some time now.
- Important new functionality includes bugfixes, many performance enhancements, a declared function argument syntax, a ternary (?:) operator, indexable and mutable string objects, interpreter thread safety features, and much work to the "standard" library (including stdio, bitfields, Unix system calls, and PCRE regular expressions).

Device::Audiotron provides a tie-in into the API included in the latest firmware for Voyetra Turtle Beachs Audiotron.

SYNOPSIS

use Device::Audiotron; $at = new Device::Audiotron("Audiotron IP address","username","password"); if(!$at){die "Audiotron object failed to initialize.";}
my ($ref_status, $ref_shares, $ref_hosts) = $at->GlobalInfo(); my $firmware_version = $ref_status->{"Version"};

Device::Audiotron provides a tie-in into the API included in the latest firmware for Voyetra Turtle Beachs Audiotron.

I highly suggest reading through the API documentation located at http://www.turtlebeach.com/site/products/audiotron/api/dl_api.asp before attempting to implement this module.

The available methods for the Audiotron object and an example of usage for each are listed below. The native API call is listed in brackets below each method for informational purposes and for ease in referencing Voyetras API documentation.

GetInfo(Type,[Count],[Criteria])
[Apigetinfo.asp]

Returns a string containing the results from the command request.

$type = "Global";
$info = $at->GetInfo($type);

OR

$type = "artist";
$count = 4;
$criteria = "Staind";
$info = $at->GetInfo($type,$count,$criteria);


Qfile(Type,Criteria)
[Apiqfile.asp]

Returns a string containing the results from the command request.

$type = "File";
$file = q|LITHIUMMP3BushdeconstructedComedown.mp3|;
$cmd_result = $at->Qfile($type, $file);


AddFile(Full_File_Name)
[Apiaddfile.asp]

Returns a string containing the results from the command request.

$file = q|COBALTMP3new_song.mp3|;
$cmd_result = $at->AddFile($file);


Cmd(Command,[Arg])
[Apicmd.asp]

Returns a string containing the results from the command request.

$cmd_name = "play";
$cmd_result = $at->Cmd($cmd_name);

OR

$cmd_name = "goto";
$cmd_arg = "18";
$cmd_result = $at->Cmd($cmd_name, $cmd_arg);


GetStatus()
[Apigetstatus.asp]

Returns a hash containing element names equivalent to the field names returned by the Audiotron.

%status = $at->GetStatus();
print $status{State};


GlobalInfo()
[See GetInfo]

Returns references to a hash, an array, and an array of hashes.

This is simply a call to GetInfo with "Global" passed as the type but has been customized to pre-parse the results.

($ref_status, $ref_shares, $ref_hosts) = $at->GlobalInfo();

In the above example $ref_status is a reference to a hash containing element names equivalent to the field names returned from the "status" portion of the results. So for example, to get the version number of the firmware:

$firmware_version = $ref_status->{"Version"};

Next, $ref_shares is a reference to an array where each element contains the UNC name for the share as listed in the Audiotron.

Lastly, $ref_hosts is a reference to an array of hashes, one hash per host known by the Audiotron. Each hash in the array contains three elements named Host,IP, and State. So for example, to get the IP address of the first host in the array:

$ip_add = $ref_hosts->[0]->{"IP"};


Msg(Text_line1,[Text_line2],[Timeout])
[Apimsg.api]

Returns a string containing the results from the command request.

$line1 = "This is a test.";
$line2 = "Just Another Perl Hacker";
$time_out = "5";
$cmd_result = $at->Msg($line1, $line2, $time_out);


DumpToc(Share_name)
[Apidumptoc.asp]

Returns a (sometimes huge!) string containing the results from the command request.

$share = q|LITHIUMMP3|;
$toc = $at->DumpToc($share);

NOTE:

This is here just as a placeholder, newer versions will allow the output to be written to a file instead of be handed back as a string. Very inefficient in its current form.

C::DynaLib::Struct is a tool for handling the C `struct data type.

SYNOPSIS

use C::DynaLib::Struct;

Define C::DynaLib::Struct(
$struct_tag,
$template0, @field_names0,
[$template1, @field_names1,]
... );

$rstruct = tie( $struct, $struct_tag [, @initializer_list] );
$value = $rstruct->my_field();
$rstruct->my_field( $new_value );

$pointer_to_struct = pack( p, $struct );
$struct = $new_struct; # assigns all fields at once

# after passing pointer-to-struct to a C function:
$rstruct->Unpack();
$returned_value = $rstruct->my_field();

When mixing Perl and C, the conversion of data types can be rather tedious and error-prone. This module provides an abstraction from Perls pack and unpack operators for using structures whose member data types and positions do not change.

Here are some examples of C code that deals with a struct. On the right are some possible Perl equivalents.

C Perl
- ----
typedef struct { use C::DynaLib::Struct;
int m_int; Define C::DynaLib::Struct(
double m_double; Foo,
char * m_string; i => [m_int],
} Foo; d => [m_double],
p => [m_string] );
# or, equivalently,
Define C::DynaLib::Struct(Foo,
idp, [qw(m_int m_double m_string)]);

Foo foo;
Foo *pfoo = &foo; $rfoo = tie ($foo, Foo);

i = pfoo->m_int; $i = $rfoo->m_int;

d = foo.m_double; $d = (tied $foo)->m_double;

pfoo->m_string = "hi"; $rfoo->m_string("hi");

Foo bar; tie ($bar, Foo);
bar = foo; $bar = $foo;

void do_foo(Foo *arg); use C::DynaLib;
$lib = new C::DynaLib("-lfoo");
$do_foo = $lib->DeclareSub("do_foo","","P");
# or you could write an XSUB.

do_foo(&foo); &$do_foo($foo);

returned_i = foo.m_int; $rfoo->Unpack();
$returned_i = $rfoo->m_int;