Free sparc procedure software for linux

RPC::XML::Procedure is an object encapsulation of server-side RPC procedures.

SYNOPSIS

require RPC::XML::Procedure;

...
$method_1 = RPC::XML::Procedure->new({ name => system.identity,
code => sub { ... },
signature => [ string ] });
$method_2 = RPC::XML::Procedure->new(/path/to/status.xpl);

IMPORTANT NOTE

This package is comprised of the code that was formerly RPC::XML::Method. The package was renamed when the decision was made to support procedures and methods as functionally different entities. It is not necessary to include both this module and RPC::XML::Method -- this module provides the latter as an empty subclass. In time, RPC::XML::Method will be removed from the distribution entirely.

The RPC::XML::Procedure package is designed primarily for behind-the-scenes use by the RPC::XML::Server class and any subclasses of it. It is documented here in case a project chooses to sub-class it for their purposes (which would require setting the method_class attribute when creating server objects, see RPC::XML::Server).

This package grew out of the increasing need to abstract the operations that related to the methods a given server instance was providing. Previously, methods were passed around simply as hash references. It was a small step then to move them into a package and allow for operations directly on the objects themselves. In the spirit of the original hashes, all the key data is kept in clear, intuitive hash keys (rather than obfuscated as the other classes do). Thus it is important to be clear on the interface here before sub-classing this package.

Generic test processor is a language and processor for a language aiming to automatically apply or generate test source code in another language.
It is taken from a library of tests and data conversion operations.
These so generated instances shall be capable of inspecting a system by gathering data and screening this data to meet certain criteria, in other words to have certain attributes.
Enhancements:
- Fixed a bug in results reporting.

Splack Linux is Slackware for Sparc.

Splack supports all Sun4c, Sun4d, and Sun4m hardware.

Most Sun4U (Ultrasparc) machines are supported, but the more modern SunBlade and SunFire systems are not supported in the 2.2.20 kernel.

As a workaround you may be able to move the boot disk to a supported UltraSparc machine, install Splack 8.0, upgrade to Splack-current, and build a 2.4.27 or later kernel.

Sun4m SMP requires kernel 2.4.27 or later. Sun4d SMP requires 2.4.27 plus patches, the patches should be included in 2.4.28. Sun4d SMP will not work with serial console: install a framebuffer, monitor, and keyboard.

Ishtar provides a network toolbox for C++ programs.

Ishtar is a set of three C++ libraries that provide useful classes for networked applications. It features basic serialization, a protocol for remote procedure call (RPC), network accessible variables, and hierarchical config files.

A client is also provided.

Ishtar is a set of three C++ libraries providing usefull classes for use with network:

- libishtarnet: The underlying structure, provides network classes and basic serialisation.
- libishtarservices: Built upon libishtarnet, implements a protocol for remote procedure call (RPC).
- libishtarsettings: Built upon libishtarservices, provides network accessible variables and hierarchical config files.

In addition to those libraries, Ishtar contains two programs:

- ishtarclients: Clients that use the RPC to access remote services and variables.
- ishtarproxy: Gateway that redirect queries to multiple servers. Usefull in the context of robotics.

Usage in robotics

In addition to its obvious use as a RPC mechanism and config file accessor, Ishtar can be used within a robot as a software bus to connect its sensors and actuators to its control program or external monitor.

Sysquake Viewer is an application which lets you load and manipulate interactively graphics developed with Sysquake.

Sysquake Viewer is much more limited than Sysquake LE, which supersedes it on Mac OS and Windows. We still provide it as a preview release for Linux on i386 and for Solaris on Sparc, until we have a robust beta version of Sysquake LE for Unix.

On Unix, files are archived with tar. In a terminal, type tar xzf sqviewer*tgz to un-archive them.

The preview is made available to you so that you can test it and provide feedback, and to have a broader range of platforms where SQ files can be viewed. It has no expiration date.

Software::Packager is a common software packaging interface.

SYNOPSIS

use Software::Packager;
my $packager = new Software::Packager();
$packager->version(1.2.3.4.5.6);
$packager->package_name("Somename");
$packager->program_name(Software Packager);
$packager->description("This is the description.");
$packager->short_description("This is a short description.");
$packager->output_dir("/home/software/packages");
$packager->category("Applications");
$packager->architecture("sparc");

my %object_data = (
SOURCE => /source/file1,
TYPE => file,
DESTINATION => /usr/local/file1,
USER => joe,
GROUP => staff,
MODE => 0750,
);
$packager->add_item(%object_data);

my $version = $packager->version();
my $name = $packager->package_name();
my $program_name = $packager->program_name();
my $description = $packager->description();
my $description = $packager->short_description();
my $output_directory = $packager->output_dir();
my $category = $packager->category();
my $arch = $packager->architecture();

The Software Packager module is designed to provide a common interface for packaging software on any platform. This module does not do the packaging of the software but is merely a wraper around the various software packaging tools already provided with various operating systems.

This module provides the base API and sets default values common to the various software packaging methods.

Jim is an opensource small footprint implementation of the Tcl programming language. It implements a large subset of Tcl and adds new features like references with garbage collection, closures, built-in Object Oriented Programming system, Functional Programming commands, First class arrays. All this with a binary size of 70kb (that can be reduced further excluding some command).
Jim is currently a work in progress, but most of the core language is already implemented and it is possible to use it to run many unmodified Tcl programs, so if you want to start to evaluate it, or want to look at our internal design and virtual machine, go to the download section.
Jims goal is to provide a powerful language implemented in roughly 10k lines of code that is presented as a single C file and an header file, in order to allow developers to put Jim inside their applications, as scripting language, configuration file syntax, without to depend on external libraries or other big systems.
We belive scripting is a very interesting feature for many applications, but developers are often not encouraged to link the application to a big external system. Jim try to address this problem providing a very simple to understand and small footprint implementation of a language that is ideal for scripting, and at the same time is powerful and able to scale.
Another field where Jim may help is the one of Embedded Systems. Jim is written in ANSI-C, is very little both in binary size and memory requirements, and the Tcl language is just ideal for this tasks (For example, CISCO routers are using Tcl).
Main features:
- Support for important features that will be availabe in Tcl8.5, like dict and {expand}.
- Arrays in Jim arent collection of variables like in Tcl, but a first class type. Array access syntax is in Jim syntax sugar to set and get dictionaries elements.
- A compact design. Jim is currently less than 10k lines of code. It does a heavy use of dual ported objects, in Jim even the VM pseudo-bytecode is a specialized Jim_Obj type.
- lambda with garbage collection, and a reference system to build linked data structures.
- closures, Jims procedures can have persistent procedure-specific variables (called statics). Statics initialization value can be caputred form the procedure creation context, so it is very similar to lexical scoping to use. This is how The Paul Grahams accumulator procedure looks like in Jim:
proc accumulator n {
lambda increment n {
set n [+ $n $increment]
}
}
- Math operations as commands (together with expr support).
- Ability to load extensions at runtime via a STUB system. Even programs using Jim that are linked statically are able to load extensions.
- 70Kbyte binary size!.

PloneExFile provides a Plone/AT content type with an attachment, supporting preview & indexing & lock.
PloneExFile is a file like content type that provides indexing and preview support for MS Word, MS Excel, MS Powerpoint, PDF and OO Writer files.
Works with:
- Plone 2.5
- Plone 2.1
Enhancements:
- Added German translations and fixed description of upgrade procedure; provided by Carsten Kirck. Thank you!