Free argument software for linux

Aargh is a code generator, written in C++ and licensed under the terms of the GNU General Public License (GPL). It generates C++ code to parse a command line, using the getopt() facility available in UNIX and UNIX-like environments.
Automated Argument Helper project supports command-line options with integer arguments, string arguments, and no arguments. The generated code is commented and carefully indented for readability.
Its nice to have lots of command line options, but its a real pain to code for them.
Not that its difficult. Its just tedious, time-consuming, error prone, and no fun. I used to wince at the thought of adding command line options.
Not any more. All I have to do is define the options I want in a small XML file, and run it through aargh. Instantly I have C++ source code that I can compile and link into my program.
If I need to add another option, or otherwise change the rules, I can edit the XML and regenerate the code. No muss, no fuss. Now I can spend more time on the interesting parts of the project.
To use aargh, write an XML file to describe the options you want. When aargh reads the file, it generates two C++ files.
One file is a header that declares a class to represent the options. By default this class is named "Opts," but you can specify a different name. The other file is the implementation of Opts, or whatever you decide to call it. The Opts class provides member functions to parse the command line and return the results.
In your own code, declare an instance of Opts and call Opts::get() to parse the command line, passing it the argc and argv arguments from main(). Opts::get() returns zero if the command line follows the rules that you have outlined in the XML file, or non-zero otherwise. If the parsing is successful, the Opts object stores the results and makes them available to your program by a series of accessor functions.
Main features:
- You can enforce upper and/or lower limits on the number of non-option arguments.
- You can distinguish between options that take arguments and those that dont.
- You can specify that an option is required.
- You can require that the argument to an option be a non-negative integer.
- For an integer argument you can enforce upper and/or lower limits.
- For a string argument you can enforce upper and/or lower limits on the string length.
- For a string argument you can call a function of your own to validate the argument.
- You can allow multiple occurrences of the same option. In that case the generated code builds an STL vector to hold the arguments. By default the generated software allows only one occurrence of any given option.
Enhancements:
- You can now specify the location of the generated header file independently of its name.
- This feature may make it easier to incorporate aargh into complex build environments.

Jaggregate is a Java collections library that is modeled after the ANSI Smalltalk collection protocols.
It only works with J2SE 5.
Enhancements:
- A bug with SortedCollections produced by the zero-argument Collection.toSortedCollection() was fixed.
- Such collections could not be serialized, because the Comparator they use was not itself Serializable.
- This has been remedied.
- *From and *With methods were added to Dictionary and IdentityDictionary, despite compiler warnings about generic array creation.

fget supports downloading a single URL (the first argument on the command line) from an FTP or HTTP server. fget supports IPv4 and IPv6 (the IPv6 URL format for IP numbers is http://[::1]:80/file.tar.gz) transport. You can set the INTERFACE environment variable to the name of the network interface ("eth0") to use IPv6 link-local addresses. This program can acces URLs with username and password like http://bob:secret@download.com/file.tar.gz
Files are always written to stdout.

fget is meant for boot and rescue disks, so small size is the most important feature. It can be linked against diet libc and you can disable the built-in DNS routines to make the binary even smaller. On my x86-linux box, the diet libc statically linked fget binary without DNS weighs about 24k (update! dietlibc 0.5 reduces the size to 13k!)

AviUtils is a little tool for lazy peoples, to visually work with avi files. It can change fourcc and can accept a command line argument: filepath of the avi.

Designed for seamless migration from win apps Gspot and Fourcc changer .

Aviutils2 is better graphics single tab version, but is experimental because of the string functions. Tested working only in Gentoo/ KDE3.5.0 .

Instructions: Choose your version (AviUtils or AviUtils2) and put the content of the choosed folder into ~/.kde/share/apps/konqueror/servicemenus to have it as service-menu for avi files.

Getargs::Long is a Perl module with named subroutine arguments, with optional type checking.

SYNOPSIS

use Getargs::Long; # case sensitive
use Getargs::Long qw(ignorecase); # case insensitive

# Simple, args mandatory
my ($val, $other) = getargs(@_, qw(val other));

# Simple, args optional (in [] means optional)
my ($val, $other) = getargs(@_, [qw(val other)]);

# Simple with typechecking, args mandatory
my ($val, $other) = getargs(@_, qw(val=Class::X other=ARRAY));

# Simple with typechecking, args optional
my ($val, $other) = getargs(@_, [qw(val=Class::X other=ARRAY)]);

# Faster version, building dedicated argument parsing routine
my ($val, $other) = cgetargs(@_, qw(val other));

# Other cases, use full specs:
my ($x, $y, $z, $a, $b, $c) = xgetargs(@_,

# Non-mandatory, defaults to undef unless specified otherwise
x => [i], # integer, no default
y => [ARRAY, [a, b]], # Has a default
z => [], # No typecheck, can be anything

# Mandatory arguments
a => i, # integer (scalar)
b => TYPE, # TYPE or any heir of TYPE
c => undef, # unspecified type but mandatory
);

# Extract remaining unparsed args in @extra
my ($val, $other, @extra) = getargs(@_, { -strict => 0 }, qw(val other));

# Alter behaviour of the getargs() routines via switches in hashref
my ($val, $other) = getargs(@_,
{
-strict => 1, # unknown switches are fatal
-ignorecase => 1, # override packages global
-inplace => 1, # edit @_ inplace: remove parsed args
-extra => 0, # suppress return of extra arguments
},
qw(val other)
);

The Getargs::Long module allows usage of named parameters in function calls, along with optional argument type-checking. It provides an easy way to get at the parameters within the routine, and yields concise descriptions for the common cases of all-mandatory and all-optional parameter lists.

The validation of arguments can be done by a structure-driven routine getargs() which is fine for infrequently called routines (but should be slower), or via a dedicated routine created and compiled on the fly the fist time it is needed, by using the cgetargs() family (expected to be faster).

The Log::Agent module is used to report errors, which leaves to the application the choice of the final logging method: to a file, to STDERR, or to syslog.

Sub::ArgShortcut is a Perl module with writing functions that use default arguments.

SYNOPSIS

use Sub::ArgShortcut::Attr;

sub mychomp :ArgShortcut { chomp @_ }

while ( ) {
# make a chomped copy of $_ without modifying it
my $chomped_line = mychomp;

# or, modify $_ in place
mychomp;

# ...
}

This module encapsulates the logic required for functions that assume $_ as their argument when called with an empty argument list, and which modify their arguments in void context but return modified copies in any other context. You only need to write code which modifies the elements of @_ in-place.
argshortcut(&)

This function takes a code reference as input, wraps a function around it and returns a reference to that function. The code that is passed in should modify the values in @_ in whatever fashion desired. The function from the synopsis could therefore also be written like this:

use Sub::ArgShortcut;
my $mychomp = argshortcut { chomp @_ };

This function is exported by default.

Sub::ArgShortcut::Attr and :ArgShortcut - The attribute interface
Instead of using argshortcut to wrap a code reference, you can use an Attribute::Handler-based interface to add Sub::ArgShortcut functionality to regular subs. Simply use Sub::Shortcut::Attr instead of Sub::Shortcut, then request its behaviour using the :ArgShortcut attribute on functions:
sub mychomp :ArgShortcut { chomp @_ }

my $mychomp = sub :ArgShortcut { chomp @_ };

Verilog::CodeGen module is a Verilog code generator.

SYNOPSIS

use Verilog::CodeGen;

mkdir DeviceLibs/Objects/YourDesign, 0755;
chdir DeviceLibs/Objects/YourDesign;

# if the directory YourDesign exists, the second argument can be omitted
# create YourModule.pl in YourDesign
&create_template_file(YourModule,YourDesign);

# create a device library for testing in DeviceLibs/Objects/DeviceLibs
&make_module(YourModule,YourDesign);

# create the final device library in DeviceLibs (once YourModule code is clean)
&make_module(,YourDesign);

Libopennet is a library that provides the function open_net() which accepts the same parameters as the open() system call, but the pathname argument can be an FTP or HTTP URL.
Libopennet project allows you to open_net() files the same way you open() them now.
Enhancements:
- fseek_net() support was improved.
- ftell_net(), ftello_net(), fseeko_net(), and setvbuf_net() were added.