Free applies software for linux

GPP is a general-purpose preprocessor with customizable syntax, suitable for a wide range of preprocessing tasks. Its independence from any programming language makes it much more versatile than cpp, while its syntax is lighter and more flexible than that of m4.

GPP is targeted at all common preprocessing tasks where cpp is not suitable and where no very sophisticated features are needed. In order to be able to process equally efficiently text files or source code in a variety of languages, the syntax used by GPP is fully customizable. The handling of comments and strings is especially advanced.

Initially, GPP only understands a minimal set of built-in macros, called meta-macros. These meta-macros allow the definition of user macros as well as some basic operations forming the core of the preprocessing system, including conditional tests, arithmetic evaluation, wildcard matching (globbing), and syntax specification.

All user macro definitions are global—i.e., they remain valid until explicitly removed; meta-macros cannot be redefined. With each user macro definition GPP keeps track of the corresponding syntax specification so that a macro can be safely invoked regardless of any subsequent change in operating mode.

In addition to macros, GPP understands comments and strings, whose syntax and behavior can be widely customized to fit any particular purpose. Internally comments and strings are the same construction, so everything that applies to comments applies to strings as well.

Syntax

gpp [-{o|O} outfile] [-I/include/path] [-Dname=val ...]
[-z|+z] [-x] [-m] [-C|-T|-H|-X|-P|-U ... [-M ...]]
[-n|+n] [+c str1 str2] [+s str1 str2 c]
[-c str1] [--nostdinc] [--nocurinc]
[--curdirinclast] [--warninglevel n]
[--includemarker str] [--include file]
[infile]

gpp --help

gpp --version

Castle is a server distribution from the ALT Linux Team in Russia. Installation instructions and some other documentation is available in English.

Brief RSBAC instructions:

1. During installation process you will have to create security officer account. This is a user that can setup RSBAC security configuration.
2. Installer applies to RSBAC kernel two special parameters "rsbac_auth_enable_login" and "rsbac_softmode". Please, dont remove it. You need it for correct installation process.
3. Run RSBAC kernel just after system installation.
4. After reboot RSBAC will function in normal mode. If you need soft mode again, use rsbac_softmode kernel parameter during boot.
5. After finishing system configuration please reboot your server.
6. RSBAC will work in normal mode at all future startups of the system. You can boot RSBAC kernel in "soft" mode again using "rsbac_softmode" kernel parameter.
7. Login as security officer you have created during installation process and run main RSBAC configuration utility "rsbac_admin".

Default security configuration:

* All system directories are in "read only" and "execute only" mode.
* Base system configuration files (e.g /etc/lilo.conf /etc/fstab) are also in read only mode.
* Home directory is available only for users and security officer (but he has no access to users home directories).Security Officers home is situated in the root directory (/secoff) and is open only for the owner. You can also create trusted environment for security officer by putting special files into the home.
* There are some useful scripts in security officers home: to enable/disable useradd, to enable/disable install and an example script for http protection.

Algorithm::Diff::Apply is a Perl module to apply one or more Algorithm::Diff diffs.

SYNOPSIS

## Single-diff form:
use Algorithm::Diff::Apply qw{apply_diff};
my @ary = ...;
my @diff = ...; # some call to Algorithm::Diff::diff()

my @changed_ary = apply_diff(@ary, @diff);
my $changed_ary = apply_diff(@ary, @diff);


## To apply >1 diff at once, use the plural form:
use Algorithm::Diff::Apply qw{apply_diffs};

@newary = apply_diffs(@ary,
diff1_name => @diff1,
diff2_name => @diff2,
...
diffN_name => @diffN);

# Alternatively:
@newary = apply_diffs(@ary, %named_diffs);

# Scalar context:
$newary = apply_diffs(@ary, %named_diffs);

# Extension argument syntax:
$newary = apply_diffs(@ary, {
resolver => &some_sub,
optimisers => [&foo, &bar],
key_generator => &anothersub,
opt4 => ...,
opt5 => ...,
}, %named_diffs);

PDL::Reduce is Perl module that helps to reduce functions for PDL.

Many languages have a reduce function used to reduce the rank of an N-D array by one. It works by applying a selected operation along a specified dimension. This module implements such a function for PDL by providing a simplified interface to the existing projection functions (e.g. sumover, maximum, average, etc).

SYNOPSIS

use PDL::Reduce;
$a = sequence 5,5;
# reduce by adding all
# elements along 2nd dimension
$b = $a->reduce(add,1);
@ops = $a->canreduce; # return a list of all allowed operations

FUNCTIONS

reduce

reduce dimension of piddle by one by applying an operation along the specified dimension

$a = sequence 5,5;
# reduce by adding all
# elements along 2nd dimension
$b = $a->reduce(add,1);
$b = $a->reduce(plus,1);
$b = $a->reduce(+,1); # three ways to do the same thing
[ As an aside: if you are familiar with threading you will see that this is actually the same as
$b = $a->mv(1,0)->sumover
]

NOTE: You should quote the name of the operation (1st arg) that you want reduce to perform. This is important since some of the names are identical to the names of the actual PDL functions which might be imported into your namespace. And you definitely want a string as argument, not a function invocation! For example, this will probably fail:

$b = $a->reduce(avg,1); # gives an error from invocation of avg

Rather use

$b = $a->reduce(avg,1);

reduce provides a simple and unified interface to the projection functions and makes people coming from other data/array languages hopefully feel more at home.

$result = $pdl->reduce($operation [,$dim]);

reduce applies the named operation along the specified dimension reducing the input piddle dimension by one. If the dimension is omitted the operation is applied along the first dimension. To get a list of valid operations see canreduce.

canreduce

return list of valid named reduce operations Some common operations can be accessed using a number of names, e.g. +, add and plus all sum the elements along the chosen dimension.

@ops = PDL->canreduce;

This list is useful if you want to make sure which operations can be used with reduce.

WAIT Perl module is a rewrite of the freeWAIS-sf engine in Perl and XS.

The central idea of the system is to provide a framework and the building blocks for any indexing and search system the users might want to build. Obviously the framework limits the class of system which can be build.

+------+ +-----+ +------+
==> |Access| ==> |Parse| ==> | |
+------+ +-----+ | |
|| | | +-----+
|| |Filter| ==> |Index|
/ | | +-----+
+-------+ +-----+ | |
1}, "$_n";
} else {
push @result, {}, "$_n";
}
}
return @result; # we dont go for speed
}

Obviously one could implement split via tag. The reason for having two functions is speed. We need to call split for each document when indexing a collection. Therefore speed is essential. On the other hand, tag is called in order to display a single document and may be a little slower. It may care about tagging bold and italic regions. See WAIT::Parse::Nroff how this might decrease performance.

Filter definition

From the Information Retrieval perspective, the hardest part of the system is the filter module. The database administrator defines for each attribute, how the contents should be processed before it is stored in the index. Usually the processing contains steps to restrict the character set, case transformation, splitting to words and transforming to word stems. In WAIT these steps are defined naturally as a pipeline of processing steps. The pipelines are made up by functions in the package WAIT::Filter which is pre-populated by the most common functions but may be extended any time.

The equivalent for a typical freeWAIS-sf processing would be this pipeline:

[ isotr, isolc, split2, stop, Stem]

The function isotr replaces unknown characters by blanks. isolc transforms to lower case. split2 splits into words and removes words shorter than two characters. stop removes the freeWAIS-sf stopwords and Stem applies the Porter algorithm for computing the stem of the words.

The filter definition for a collection defines a set of pipelines for the attributes and modifies the pipelines which should be used for prefix and interval searches.

Several complete working examples come with WAIT in the script directory. It is recommended to follow the pattern of the scripts smakewhatis and sman.