Free protection symbols software for linux

LaTeX Symbols Selector project is a symbol browser to help creating LaTeX documents with many math symbols.
All symbols are grouped into categories and user can copy symbol name to system-wide clipboard (or insert it directly to first running copy of gVIM) by selecting symbol icon from list. Many non-standard (and unsupported in LSS) symbols can be found in the comprehensive LATEX symbol list here.
Main features:
- Built-in 478 LaTeX symbols
- Most of AMS symbols are supported
- Easy integration with gVIM editor
- Selected symbol name can be copied into clipboard for use with your favourite editor

Lingua::Phonology::Symbols is a Perl module for associating symbols with segment prototypes.

SYNOPSIS

use Lingua::Phonology;
$phono = new Lingua::Phonology;

# Load the default features
$phono->features->loadfile;

# Load the default symbols
$symbols = $phono->symbols;
$symbols->loadfile;

# Make a test segment
$segment = $phono->segment;
$segment->labial(1);
$segment->voice(1);

# Find the symbol matching the segment
print $symbols->spell($segment); # Should print b

When using Lingua::Phonology, you usually manipulate Segment objects that have various feature values that specify the phonetic qualities of the segment. However, it is difficult to print those feature values, and a list of feature values can be difficult to interpret anyway. This is where Symbols comes in--it provides a way to take a Segment object and get a phonetic symbol representing the properties of that segment.

In Symbols, you may use add_symbol() to define text symbols that correlate to "prototypes", which are special Segment objects that represent the ideal segment for each symbol. After you have defined your symbols and prototypes, you may use spell() to find which prototype is the most similar to a segment in question, and get the symbol for that prototype.

As of v0.2, Symbols also includes diacritics. A diacritic is a special symbol that begins or ends with a *, and which is used to modify other symbols. If the best symbol match for a segment you are trying to spell is an imperfect match, Symbols will then attempt to use diacritics to indicate exactly how the segment is pronounced. For compatibility reasons, however, this feature is off by default. It can be turned on with set_diacritics.

You will probably want to read the add_symbol, spell, and loadfile sections, because these describe the most widely-used functions and the algorithm used to score potential matches. If youre not getting the results you expect, you probably need to examine the way your prototype definitions are interacting with that algorithm.

Symbolica is a remake of the C-64 game of the same name. The project is targeted to the Linux-based handhelds gp2x and N800, with a Linux/386 binary also provided. It should compile under any operating system supported by SDL, SDL_image, and SDL_ttf.

The symbols on the screen represent a numeric value in the order they are displayed on the right. As you move over a symbol, it decrements to the next lower symbol or disappears. Your job is to clear the screen and move to the E symbol.

Your job is to clear the screen and move to the E symbol.

Ofcourse all is in favour to save the world from some evil space mutants that have captured your girlfriend to take over the world... or something like that.

It tries to select best screen resolution for your system, to change default, see symbolica -h

Keys:

GP2X: SELECT quits - rest should be obvious
Linux: ESC quits - 1/2 adjusts volume - rest should be obvious

ProSum is a terminal based program that protects your files, sys_call_table and IDT like tripwire way (All in user space, without kernel modules).
In addition, database with files etc. could be encrypted with Blowfish algorythm and files that are protected could be store at any secure/bastion host to later replace them. You can disable sys_call_table and IDT support for Non-Linux systems. ProSum could be run on any UNIX system, at least with file protect mode (without IDT and sys_call_table support). ProSum was designed for if you run it on Linux x86 platform, kernel havent LKM support or have any type of protection against load and unload LKM, for many protection. Anyway this is not neccesary, but is recommended.
Main features:
- - IDT, Kernel Symbols and Syscall hacking protection throught /dev/kmem for Linux x86 (developing protection for Linux sparc).
- File protection in a Tripwire way on any UNIX POSIX compliant.
- Database encryption with Blowfish algorythm on any UNIX.
- Recover files which are protected from a bastion/secure host.
- Syscall hacking by method described on http://www.big.net.au/~silvio/stealth-syscall.txt protection.
Enhancements:
- INSTALL.es translated to english on INSTALL.en Support for extended flags on Linux.
- To run program you need password that you define in config_prosum.h
- User could be specify random seed for ivec to encrypt BBDD.
- Now encryption support works, tested on Linux, *BSD and Solaris.
- Fixed removing absolute path on snd_tcp_serv.c
- Now you can compile program without gettext support with --disable-nls
- OpenSSL API have been removed for encryption support because there are many problems with it and non-Linux systems, and API of GnuPG 1.0.7 have been added.
- Fixed malfunctions with GNU make.
- Now you can protect files from different hosts in an unique bastion host.
- Now you can protect files that starting by a point (.).
- Added protection against kernel symbols hacking on Linux x86.
- Fixed BUG on big endianess architecture machines with htons() and md5.
- Fixed BUG with getopt().
- Fixed BUG when program comprobes if file were symbolic link.
- Internal code reestructuration.
- Fixed return type of signal() for portability.
- Changed way for handling errors.
- Added lock file for prevent that more than one ProSum can be running at the same me.

RPM::Constants is a Perl module with groups of RPM-defined symbols.

SYNOPSIS

use RPM::Constants qw(:rpmerr :rpmtype);

This package is a collection of the constants defined by rpm itself that may be of use to those developing with the RPM Perl bindings.

Alphabet Soup project attempts to determine a number of things about the shapes of letters in several different writing systems.

First, it hypothesizes a set of basic building blocks that all letters are built up from.

Second, it hypothesizes a set of rules, a grammar or syntax, which defines how those pieces combine to make different letters.

It can generate individual letters, randomize letters in an input string to create weird but readable text, or generate random strings of symbols.

Devel::Constants is a Perl module that translates constants back to named symbols.

SYNOPSIS

# must precede use constant
use Devel::Constants flag_to_names;

use constant A => 1;
use constant B => 2;
use constant C => 4;

my $flag = A | B;
print "Flag is: ", join( and , flag_to_names($flag) ), "n";

Declaring constants is very convenient for writing programs, but as Perl often inlines them, retrieving their symbolic names can be tricky. This worse with lowlevel modules that use constants for bit-twiddling.

Devel::Constants makes this much more manageable.

It silently wraps around the constant module, intercepting all constant declarations. It builds a hash, associating the values to their names, from which you can retrieve their names as necessary.

Note that you must use Devel::Constants before constant, or the magic will not work and you will be very disappointed. This is very important, and if you ignore this warning, the authors will feel free to laugh at you (at least a little.

By default, Devel::Constants only intercept constant declarations within the same package that used the module. Also by default, it stores the constants for a package within a private (read, otherwise inaccessible) variable. You can override both of these.

Passing the package flag to Devel::Constants with a valid package name will make the module intercept all constants subsequently declared within that package. For example, in the main package you might say:

use Devel::Constants package => NetPacket::TCP;
use NetPacket::TCP;

All of the TCP flags declared within NetPacket::TCP are now available.
It is also possible to pass in a hash reference in which to store the constant values and names:

my %constant_map;
use Devel::Constants %constant_map;

use constant NAME => 1;
use constant RANK => 2;
use constant SERIAL => 4;

print join( , values %constant_map), "n";