Free calls from your software for linux

The calltree command parses a collection of input files (assuming C syntax) and builds a graph that represents the static call structure of these files.

Calltree is similar to cflow(1) but unlike cflow(1), calltree is not based on lint(1).Calltree implements some more functions than cflow(1), but does not list the return types of the functions. This is because calltree includes an own C parser and thus may be used even on systems that dont have lint(1).

The disadvantage is that the C parser that is used by calltree is not completely correct and may not find all calls of a function. This is mainly true for calls that are done via function pointers.

Calltree is able to detect recursive function calls (e.g. functions that call themselves). Recursive function calls are marked with an ellipsis in the output.

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.

FritzCallerID is a SuperKaramba theme that shows number, name and address (if available) for incoming and outgoing calls via the AVM FritzBox (http://avm.de).

It searches for the name and address for a certain number in the German phone book www.dasoertliche.de.

Phone numbers are fetched via the integrated callmonitor of the FritzBox, available on Port 1012. Before using it, you first have to open this Port of your FritzBox by dialing #96*5* from any connected phone. Firmware version xx.03.99 or newer is required.

It is still very experimental, no error handling.

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.

Amaroc is an ncurses "frontend" for Amarok. Amaroc uses DCOP calls, and its purpose is to ease control of Amarok over a network.

You need shell access to a machine on which Amarok is running. SSH is just fine.

When you run it just hit the h key for help.

Thats it.

If you find it useful, do contact me and say so.

Sys::AlarmCall is a package to handle the logic in timing out calls with alarm() and an ALRM handler, allowing nested calls as well.

SYNOPSIS

use Sys::AlarmCall;

$result = alarm_call($timeout1,$func1,@args1);
@result = alarm_call($timeout2,$func2,@args2);

Sys::AlarmCall provides a straightforward function call to use the alarm handler. It also handles the logic which allows nested time out calls if timeout calls are run thorugh the alarm_call() functions.

The main advantages of Sys::AlarmCall are that:

1. simple calls, e.g.

@result = &func(@args); #Normal function call with &
$result = func(@args);; #Normal function call
@result = &$code_reference(@args);
@result = $obj->func(@args); #Object method call

become simple calls:

@result = alarm_call($timeout,&func,@args);
$result = alarm_call($timeout,func,@args);
@result = alarm_call($timeout,$code_reference,@args);
@result = alarm_call($timeout,->func,$obj,@args);

ClikMenu project is a library of functions for creating drop-down and popup menus with JavaScript.

Support for multi-level (i.e. cascading or hierarchical) menus is standard, and entries can be URI links, "onmousedown"-type function calls, plaintext labels, or submenus.

ClikMenu is compatible with Firefox, Internet Explorer 6, and other recent browsers. There are no server-side requirements.