Free ras hiperarc 1.03 software for linux

RAS::HiPerARC.pm is a Perl Interface to 3Com/USR Total Control HiPerARC.

SYNOPSIS

RAS::HiPerARC is a PERL 5 module for interfacing with a 3Com/USR Total Control HiPerARC remote access server. Using this module, one can very easily construct programs to find a particular user in a bank of ARCs, disconnect users, get usage statistics, or execute arbitrary commands on a ARC.

DrawView displays Draw files created by the "Draw" RISC OS application and other compatible applications.

Drawings can be exported to PDF or PostScript format for printing or use in other applications.

Installation:

DrawView is built and installed in the same way as most other open-source applications. First of all, download and install the Qt 4 library if it is not already available on your system.

Then, after unpacking the source archive and changing to the source directory, configure and install the application by doing:

$ ./configure [OPTIONS...]
$ make
$ su root -c make install

Some useful OPTIONS that it may be necessary to give to configure are:

--prefix=DIRECTORY Base DIRECTORY for the installation, default is /usr/local.
--with-qt4=LOCATION The LOCATION where the Qt 4 library is installed (containing the bin, include and lib subdirectories). If not specified, this is searched for on PATH, in /usr/qt/4 and /usr/lib/qt4, and in prefix.
--with-kde=yes Install KDE desktop integration (application, icons and MIME types); this is the default if its kde-config program is found on PATH. Specify --with-kde=LOCATION to install to a different place, or --with-kde=no to not install anything.
--with-desktop=yes Install freedesktop/GNOME desktop integration (application and icons); this is the default if the KDE integration is not installed. Specify --with-desktop=LOCATION to install to a different place (the default is /usr/share), or --with-desktop=no to not install anything.

There are some other, less useful, options; use configure --help to list them.

AntTweakBar allows programmers to quickly add a light and intuitive graphical user interface into graphic programs to interactively tweak them. AntTweakBar is a small and easy to use library that can be readily integrated into OpenGL and DirectX applications.
Program variables can be linked to a graphical control that allows users to modify them. Thus, parameters exposed by programmers can be easily modified. They are displayed into the graphical application through one or more embeded windows called tweak bars.
Design and integration:
The library is designed to minimize programmer work while offering a fast, clean, intuitive and non-invasive graphical interface. For instance, numerical values are automatically mapped to a RotoSlider control for rapid editing.
It is composed of few functions. Common variables like booleans, integers, floats and enums can be directly mapped to a graphic control through pointers or callback functions. Additionnal editing informations like min and max values can be provided. Keyboard shortcuts can also be associated to controls and an help window which summurizes these shortcuts can be displayed. Programmers are not required to design the graphical interface by providing coordinates or by using a visual UI editor. Controls are automatically organized following an optional given hierarchy. In most cases, only one line of code is needed to add a new variable to a tweak bar.
The AntTweakBar library mainly targets graphical programs that need an easy way to tweak parameters and see the result in real-time like 3D demos, light inline game editors, small 3D applications, prototypes, debug facilities of weighter graphical programs, etc.
While the library itself is written in C++, its programming interface is a C interface, and then it can be directly integrated in any C++ or C program.
It has been designed with performance in mind. Embeded in a typical 3D application, its rendering time is almost insignificant. Bars can also be iconified to fully minimize their rendering time.
Enhancements:
- The medium font is antialiased.
- The code now compiles on 64-bit x86 platforms.
- A problem which occurred if the library was initialized or uninitialized more than once was fixed.
- Some other minor fixes were done.

Readonly is a Perl module that offers the facility for creating read-only scalars, arrays, hashes.

SYNOPSIS

use Readonly;

# Read-only scalar
Readonly::Scalar $sca => $initial_value;
Readonly::Scalar my $sca => $initial_value;

# Read-only array
Readonly::Array @arr => @values;
Readonly::Array my @arr => @values;

# Read-only hash
Readonly::Hash %has => (key => value, key => value, ...);
Readonly::Hash my %has => (key => value, key => value, ...);
# or:
Readonly::Hash %has => {key => value, key => value, ...};

# You can use the read-only variables like any regular variables:
print $sca;
$something = $sca + $arr[2];
next if $has{$some_key};

# But if you try to modify a value, your program will die:
$sca = 7;
push @arr, seven;
delete $has{key};
# The error message is "Modification of a read-only value
attempted"

# Alternate form (Perl 5.8 and later)
Readonly $sca => $initial_value;
Readonly my $sca => $initial_value;
Readonly @arr => @values;
Readonly my @arr => @values;
Readonly %has => (key => value, key => value, ...);
Readonly my %has => (key => value, key => value, ...);
# Alternate form (for Perls earlier than v5.8)
Readonly $sca => $initial_value;
Readonly my $sca => $initial_value;
Readonly @arr => @values;
Readonly my @arr => @values;
Readonly %has => (key => value, key => value, ...);
Readonly my %has => (key => value, key => value, ...);

This is a facility for creating non-modifiable variables. This is useful for configuration files, headers, etc. It can also be useful as a development and debugging tool, for catching updates to variables that should not be changed.
If any of the values you pass to Scalar, Array, or Hash are references, then those functions recurse over the data structures, marking everything as Readonly. Usually, this is what you want: the entire structure nonmodifiable. If you want only the top level to be Readonly, use the alternate Scalar1, Array1 and Hash1 functions.

Please note that most users of Readonly will also want to install a companion module Readonly::XS. See the "CONS" section below for more details.

Ansilove/PHP is a set of tools to convert ANSi and artscene related file formats into PNG images, supporting ANSi (.ANS), BiNARY (.BIN), and ADF (.ADF) formats.
Ansilove/PHP project includes an all purposes command line converter, along with a library to use on web pages for doing "on the fly" conversions.
Main features:
- ANSi (.ANS) format support
- BiNARY (.BIN) format support
- ADF (.ADF) format support
- Small output file size (4-bit PNG)
- SAUCE (Standard Architecture for Universal Comment Extentions) support
- 80x25 font support
- 80x50 font support
- Amiga font support
- iCE colors support

pvswitch is a very tiny program which makes it possible to use different program installations on one machine flawlessly.
Its flexibility is intended for people who need to run programs against different interpreter versions.
But it can also be used for different purposes like switching the version of a compiler, text editor, mail reader, browser, whatever.
It is most useful for developers of interpreter based programs which are started via a hash-bang line (#!).
The following example explains the usage for perl programs, but the very same is true for all other interpreter languages.
If you install two or more different perl versions on your machine, you could just call the respective perl binary you want to use..
perl myscript.pl
/path/to/another/perl myscript.pl
This works fine, although it isnt very convenient. However if you are starting your program using the hash-bang line like
#! /usr/bin/perl
and then just start it by
./myscript.pl
you would need to change the file itself to use another perl version. Again it is possible, but not very convenient.
And here comes pvswitch: its purpose is to make such situations convenient. Further it solve some problems which come up if multiple people want to use different perl versions. pvswitch allows even to run one program in two shells with different perl versions.
This is possible because pvswitch uses a environment variable to select the interpreter version to use. This environment variable can be set in different sessions independently.
pvswitch is installed as new program binary (e.g. perl) the old one will be renamed to program.pvswitch.
Now every time you execute a this program (e.g. perl), pvswitch is executed. It doesnt matter how you start the program...
perl myscript.pl
./myscript.pl # if it has a hash-bang #! /usr/bin/perl
for both cases the pvswitch binary will be executed, pvswitch will than check for the environment variable PVSWITCH_PERL_BINARY (if you are running perl), if it is found it tries to find this key in the configuration file pvswitch.conf and execute the program which is configured for the version configured set in the environment variable (e.g. perl.pvswitch).
So it just executes the real program (e.g. perl interpreter). Depending on the environment a different version might be selected.
There are some convenient tools (e.g. perlver, pvconfig) to configure this.
Enhancements:
- Fixed a bug which could cause segmentation violation.

RAS::PortMaster.pm is a Perl Interface to Livingston PortMaster 2.

SYNOPSIS

RAS::PortMaster is a PERL 5 module for interfacing with a Livingston PortMaster remote access server. Using this module, one can very easily construct programs to find a particular user in a bank of PMs, disconnect users, get usage statistics, or execute arbitrary commands on a PM.

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.