Free reference software for linux

XScanMaster is a program to control intelligent lights using DMX512, based on the fixture library from GrandMA-firmware. The DMX512 output is done using DMX4Linux, which offers support for most common interfaces and many DMX512 lines.

Also included are functions to control fixtures movements in calibrated reference environments. More than one reference setting can be added to any fixture, and any fixture can be selected to run in one of its reference environments or not.

In the environment the user can control the fixture in different coordinate systems. Sceens and cues can be recorded on a fixture:feature base.

Both can be included in other sceens or cues. Playing sceens/cues can be done from one or more "replay units"; each replay unit can run any program at a given speed (beatcounters are included).

LinkBrowser is a program for browsing the links in HTML documents and downloading the files that they reference.
Basically, this program is like a normal Web browser, but instead of rendering the HTML it just shows a table of all the files that the html references. The files can be downloaded in batches.
Enhancements:
- URL parsing has been enhanced and build issues with Java 1.5 have been fixed.

OpenGrok is a fast source code search and cross reference engine.

It helps you search, cross-reference and navigate your source tree. It can understand various program file formats and version control histories like SCCS, RCS and CVS.

In other words it lets you grok (profoundly understand) the open source, hence the name OpenGrok. It is written in Java.

URI is Uniform Resource Identifiers (absolute and relative). This module implements the URI class. Objects of this class represent "Uniform Resource Identifier references" as specified in RFC 2396 (and updated by RFC 2732).

A Uniform Resource Identifier is a compact string of characters that identifies an abstract or physical resource. A Uniform Resource Identifier can be further classified as either a Uniform Resource Locator (URL) or a Uniform Resource Name (URN). The distinction between URL and URN does not matter to the URI class interface. A "URI-reference" is a URI that may have additional information attached in the form of a fragment identifier.

An absolute URI reference consists of three parts: a scheme, a scheme-specific part and a fragment identifier. A subset of URI references share a common syntax for hierarchical namespaces. For these, the scheme-specific part is further broken down into authority, path and query components. These URIs can also take the form of relative URI references, where the scheme (and usually also the authority) component is missing, but implied by the context of the URI reference. The three forms of URI reference syntax are summarized as follows:

< scheme >:< scheme-specific-part >#< fragment >
< scheme >://< authority >< path >?< query >#< fragment >
< path >?< query >#< fragment >

The components into which a URI reference can be divided depend on the scheme. The URI class provides methods to get and set the individual components. The methods available for a specific URI object depend on the scheme.

CfgTie::TieNet is a Perl module to tie in the net database.

SYNOPSIS

tie %net,CfgTie::TieNet

This is a straightforward hash tie that allows us to access the net database sanely.

Ties

There are two ties available for programmers:

tie %net,CfgTie::TieNet

$net{$name} will return a hash reference of the named net information

tie %net_addr,CfgTIe::TieNet_addr

$net_addr{$addr} will return a hash reference for the specified network address.

Structure of hash

Any given net entry has the following information assoicated with it:

Name

net name

Aliases

A list reference for other names for this net

AddrType

The type of address

Addr

The address

Additionally, the programmer can set any other associated key, but this information will only available to the running Perl script.

Convert::Scalar is a Perl module that can convert between different representations of perl scalars.

SYNOPSIS

use Convert::Scalar;

This module exports various internal perl methods that change the internal representation or state of a perl scalar. All of these work in-place, that is, they modify their scalar argument. No functions are exported by default.

The following export tags exist:

:utf8 all functions with utf8 in their name
:taint all functions with taint in their name
:refcnt all functions with refcnt in their name
:ok all *ok-functions.
utf8 scalar[, mode]

Returns true when the given scalar is marked as utf8, false otherwise. If the optional mode argument is given, also forces the interpretation of the string to utf8 (mode true) or plain bytes (mode false). The actual (byte-) content is not changed. The return value always reflects the state before any modification is done.

This function is useful when you "import" utf8-data into perl, or when some external function (e.g. storing/retrieving from a database) removes the utf8-flag.

utf8_on scalar

Similar to utf8 scalar, 1, but additionally returns the scalar (the argument is still modified in-place).

utf8_off scalar

Similar to utf8 scalar, 0, but additionally returns the scalar (the argument is still modified in-place).

utf8_valid scalar [Perl 5.7]

Returns true if the bytes inside the scalar form a valid utf8 string, false otherwise (the check is independent of the actual encoding perl thinks the string is in).

utf8_upgrade scalar

Convert the string content of the scalar in-place to its UTF8-encoded form (and also returns it).

utf8_downgrade scalar[, fail_ok=0]

Attempt to convert the string content of the scalar from UTF8-encoded to ISO-8859-1. This may not be possible if the string contains characters that cannot be represented in a single byte; if this is the case, it leaves the scalar unchanged and either returns false or, if fail_ok is not true (the default), croaks.

utf8_encode scalar

Convert the string value of the scalar to UTF8-encoded, but then turn off the SvUTF8 flag so that it looks like bytes to perl again. (Might be removed in future versions).

utf8_length scalar

Returns the number of characters in the string, counting wide UTF8 characters as a single character, independent of wether the scalar is marked as containing bytes or mulitbyte characters.

unmagic scalar, type

Remove the specified magic from the scalar (DANGEROUS!).

weaken scalar

Weaken a reference. (See also WeakRef).

taint scalar

Taint the scalar.

tainted scalar

returns true when the scalar is tainted, false otherwise.

untaint scalar

Remove the tainted flag from the specified scalar.

grow scalar, newlen

Sets the memory area used for the scalar to the given length, if the current length is less than the new value. This does not affect the contents of the scalar, but is only useful to "pre-allocate" memory space if you know the scalar will grow. The return value is the modified scalar (the scalar is modified in-place).

refcnt scalar[, newrefcnt]

Returns the current reference count of the given scalar and optionally sets it to the given reference count.

refcnt_inc scalar

Increments the reference count of the given scalar inplace.

refcnt_dec scalar

Decrements the reference count of the given scalar inplace. Use weaken instead if you understand what this function is fore. Better yet: dont use this module in this case.

refcnt_rv scalar[, newrefcnt]

Works like refcnt, but dereferences the given reference first. This is useful to find the reference count of arrays or hashes, which cnanot be passed directly. Remember that taking a reference of some object increases its reference count, so the reference count used by the *_rv-functions tend to be one higher.

refcnt_inc_rv scalar

Works like refcnt_inc, but dereferences the given reference first.

refcnt_dec_rv scalar

Works like refcnt_dec, but dereferences the given reference first.

ok scalar

uok scalar

rok scalar

pok scalar

nok scalar

niok scalar

Calls SvOK, SvUOK, SvROK, SvPOK, SvNOK or SvNIOK on the given scalar, respectively.

Convert::Bencode_XS is a Perl module for faster conversions to/from Bencode format.
SYNOPSIS
use Convert::Bencode_XS qw(bencode bdecode);
use Data::Dumper;
print "Serializing:n", bencode([123, [], "XXX"]), "nn";
print Dumper bdecode(d3:fool3:bar4:stube6:numberi123ee);
__END__
Serializing:
li123el0:e3:XXXe
$VAR1 = {
number => 123,
foo => [
bar,
stub
]
};
bencode($stuff)
Returns a bencoded string representing whats in $stuff. $stuff can be either a scalar, an array reference or a hash reference. Every nesting of these data structures is allowed, other ones will croak.
bdecode($bencoded)
Returns a Perl data structure: it could be either a scalar, array reference or hash reference depending on whats in $bencoded. Dictionaries are converted in hashes, lists in arrays, scalars in strings. If $COERCE (see below) is set to a false value then scalars encoded like integers will be cleanse() before being returned so that a re-serialization of the structure will give back exactly the same bencoded string.
Enhancements:
- Perl

Rubilicious project is a set of Del.icio.us bindings for Ruby.

Youll need to create an account at Delicious in order to use Rubilicious. An RDoc-generated API reference is in doc/, and some simple examples are in examples/.