Free interface software for linux

Java GForge SOAP Interface (or JaGoSI for short) is an approach to access the GForge collaboration platform via Java. This can be used to put other applications on top of JaGoSI. It may be integrated with other applications like the former MyLar project.
Enhancements:
- A complete working file distribution is available for the GForge platform via an Ant task.
- Many bugs were fixed.
- The Maven build was fixed, so compiling with sub components is working.
- The project structure was changed.
- JUnit was updated to version 4.

Perlbug::Interface::Web is a web interface to perlbug database.

SYNOPSIS

my $o_web = Perlbug::Interface::Web->new;

print $o_web->top;

print $o_web->request(help);

print $o_web->links;

METHODS

new

Create new Perlbug::Interface::Web object.
my $web = Perlbug::Interface::Web->new;

setup

Setup Perlbug::Interface::Web
$o_web->setup($cgi);

check_user

Access authentication via http, we just prime ourselves with data from the db as well.

menus

Return menu of system, designed for vertical format. Wraps logo, title and links

print $o_web->menus();

logo

Return logo of system with href=hard_wired_url

print $o_web->logo();

get_title

Return title of current page

print $o_web->get_title();

summary

Return summary of open/closed bugs

print $o_web->summary();

links

Return links of system, with adminfaq inserted if appropriate, configured links and object search forms.

print $o_web->links();

index

Display the index results here...

get_request

Return the req value for this request

my $req = $self->get_request;

set_command

Set the command type for the rest of the process, based on the input and operation

my $cmd = $o_web->set_command($req);

commands

Return command menu buttons for request given

print $o_web->commands($req);

switch

Return appropriate method call for request(else index), using internal CGI object

my $method = $o_web->switch([$req]); # set $method=($call|index)

start

Return appropriate start header data for web request, includes start table.

print $o_web->start();

form

Return form with appropriate name and target etc.

print $o_web->form(menus);

top

Return consistent top of page.

print $o_web->top($req, $cmd);

request

Handle all web requests (internal print)

$o_web->request($call);

target2file

Return appropriate dir/file.ext for given target string

my $filename = $o_base->target2file(header);

# -> /home/richard/web/header.html

finish

Return appropriate finishing html
Varies with framed, includes table finish

print $o_web->finish($req);

overview

Wrapper for doo method

graph

Display pie or mixed graph for groups of bugs etc., mixed to come.

date

Wrapper for search by date access

create

Wrapper for object creation

$o_web->create($obj, %data);

object_handler

Wrapper for object access: no ids = search form

$o_web->object_handler($me_thod, $oid); # o_cgi comes from the heavens

hist

History mechanism for bugs and users.

Move formatting to Formatter::history !!!

headers

Headers for all objects (message, note, ...) by id

$o_web->headers(patch, $id);

bidmid

Wrapper for bugid and messageid access

spec

Returns specifications for the Perlbug system.

$dynamic =~ s/ />/g;
$dynamic =~ s/b(http:.+?perlbug.cgi)b/$1/gi;
$dynamic =~ s/b([ |&.t;]+@.+?.(?:com|org|net|edu))b/$1/gi;

webhelp

Web based help for perlbug.

print $web->webhelp;

mailhelp

Web based mail help for perlbug.

print $web->mailhelp;

delete

Wrapper for delete access

sql

Open field sql query processor

todo

To do list, may be appended to

adminfaq

adminFAQ

web_query

Form bugid search web query results

# results - dont map to query() unless Base::query modified

search

Construct search form

with chosen params as defaults...

update

For all application objects, wraps to object_handler

$o_web->update(); # args ignored here for passing purposes

current_buttons

Get and set array of relevant buttons by context key

my @buttons = $o_web->current_buttons(search update reset, scalar(@uids), [$colspan]);

case

Handle case sensitivity from web search form.

format_query

Produce SQL query for bug search from cgi query.

Can be optimised somewhat ...

my $query = $web->format_query;

wildcard

Convert * into % for sqlquery

my $string = $self->wildcard(5.*);

tenify

Create range of links to split (by tens or more) bugids from web query result.

$self->tenify(@_bids, bug, 7); # in chunks of 7

gCAD3D is a 3D-CAD and CAM-software with Iges-Import and Export, DXF-Import and Export, VRML-1, programming-Interface, scripting language.

Realtime Application Interface project allows applications with strict timing constraints to be run on Linux.
A real time system is able to guarantee the timing requirements of the processes under its control.
RTAI provides an API and the necessary kernel modifications to accommodate such requirements.
Enhancements:
- Improvements were made to netrpc.
- Context switching between hard and soft real-time, handling of TSC errors, and POSIX compatibility have been improved.
- There are numerous minor bugfixes.

PAPI aims to provide the tool designer and application engineer with a consistent interface and methodology for use of the performance counter hardware found in most major microprocessors.
PAPI enables software engineers to see, in near real time, the relation between software performance and processor events.
The Performance API (PAPI) project specifies a standard application programming interface (API) for accessing hardware performance counters available on most modern microprocessors.
These counters exist as a small set of registers that count Events, occurrences of specific signals related to the processors function. Monitoring these events facilitates correlation between the structure of source/object code and the efficiency of the mapping of that code to the underlying architecture.
This correlation has a variety of uses in performance analysis including hand tuning, compiler optimization, debugging, benchmarking, monitoring and performance modeling. In addition, it is hoped that this information will prove useful in the development of new compilation technology as well as in steering architectural development towards alleviating commonly occurring bottlenecks in high performance computing.
PAPI provides two interfaces to the underlying counter hardware; a simple, high level interface for the acquisition of simple measurements and a fully programmable, low level interface directed towards users with more sophisticated needs.
The low level PAPI interface deals with hardware events in groups called EventSets. EventSets reflect how the counters are most frequently used, such as taking simultaneous measurements of different hardware events and relating them to one another.
For example, relating cycles to memory references or flops to level 1 cache misses can indicate poor locality and memory management. In addition, EventSets allow a highly efficient implementation which translates to more detailed and accurate measurements.
EventSets are fully programmable and have features such as guaranteed thread safety, writing of counter values, multiplexing and notification on threshold crossing, as well as processor specific features. The high level interface simply provides the ability to start, stop and read specific events, one at a time.
PAPI provides portability across different platforms. It uses the same routines with similar argument lists to control and access the counters for every architecture. As part of PAPI, we have predefined a set of events that we feel represents the lowest common denominator of every good counter implementation.
Our intent is that the same source code will count similar and possibly comparable events when run on different platforms. If the programmer chooses to use this set of standardized events, then the source code need not be changed and only a fresh compilation and link is necessary. However, should the developer wish to access machine specific events, the low level API provides access to all available events and counting modes.
If an event or feature does not exist on the current platform, PAPI returns an appropriate error code. This significantly reduces the porting effort of code using PAPI because the semantics of each call to PAPI remains the same, just the argument lists need updating. In addition to the standard set, each PAPI implementation supports all native events through the ability to directly accept platform specific counter numbers. Definitions for most, if not all of these, are included as conditional macros in the header file. In this way, PAPI avoids having inefficient code to translate all events for all platforms into a uniform representation and back again.
This translation is only done for the relatively few events defined in the standardized set. Some processors like those in the POWER series have counter groups. They enable access to specific groups of counters, instead of individual events. This presents a serious portability problem, thus PAPI abstracts hardware counters from their groups with a packed naming scheme. Each counter control value or event is made up of the counter group number and the number of the specific counter in that group.
PAPI can be divided into two layers of software. The upper layer consists of the API and machine independent support functions. The lower layer defines and exports a machine independent interface to machine dependent functions and data structures. These functions access the substrate, which may consist of the operating system, a kernel extension or assembly functions to directly access the processors registers.
PAPI tries to use the most efficient and flexible of the three, depending on what is available. Naturally, the functionality of the upper layers heavily depends on that provided by the substrate. In cases where the substrates do not provide highly desirable features, PAPI attempts to emulate them as described below.
PAPI makes sure the underlying operating system or library guards against overflow of counter values.
Each counter can potentially be incremented multiple times in a single clock cycle. This combined with increasing clock speeds and the small precision of some of the physical counters means that overflow is likely to occur.
One of the more advanced features of PAPI is to provide a portable implementation of asynchronous notification when counters exceed a user specified value.
This functionality provides the basis for PAPIs SVR4 compatible profiling calls, that generate an accurate histogram of performance interrupts based on hardware metrics, not on time. Such functionality provides the basis for all line level performance analysis software, from the antiquated days of AT&Ts prof to SGIs SpeedShop. Thus for any architecture with even the most rudimentary access to hardware performance counters, PAPI provides the foundation for a truly portable, source level, performance analysis tool based on real processor statistics.
Enhancements:
- The API was extended to decouple abstraction layers from hardware support and to provide initial support for different types of performance counters.

Xmms::Remote is a Perl Interface to xmms_remote API.

SYNOPSIS

use Xmms::Remote ();
my $remote = Xmms::Remote->new;
$remote->play;

This module provides a Perl interface to the xmms remote control interface. No docs yet, sorry, see test.pl and Xmms.pm for now