Free scalar variables software for linux

MySQL Global User Variables UDF is a MySQL extension to store persistent variables.

This shared library adds simple user functions to MySQL in order to keep persistent shared variables in memory. These variables and their values are available to all clients. Any data can be stored into these persistent variables, including BLOBs. Since updates are atomic and way faster than MEMORY tables, this is an easy and efficient way to handle counters and sequences.

Usage:

Storing a value

An unlimited number of user variables can be created, as long as memory is available.
The GLOBAL_STORE(, ) stores a new shared global variable.

Examples:

mysql> DO GLOBAL_STORE("online_users", 42);
mysql> DO GLOBAL_STORE("secret_key", "pajfUyfnd");

The GLOBAL_STORE() function always returns 1 unless an error occurred.

Fetching a value

Reading the value of a variable is the job of the GLOBAL_GET() function.
The value is returned, or NULL is the variable is undefined.

Example:

mysql> SELECT GLOBAL_GET("online_users;);
42

mysql> SELECT id FROM pxs WHERE secret_key = GLOBAL_GET("secret_key");
1

Atomic increments

A single function call can read the previous value, add an integer (that can be negative), and store the new value into the variable.

The function is GLOBAL_ADD(, ) and the return value is the new value of the variable.
Updates are always atomic, if the old value is 18 and you add 1, you will always get back 19.

Example:

mysql> DO GLOBAL_ADD("online_users", 1);
mysql> SELECT GLOBAL_ADD("online_users", -4);
39

If the value of a variable was a string, the new value is the increment:

mysql> SELECT GLOBAL_ADD("secret_key", 12);
12

Adding a value to an undefined variable returns NULL.
A handy variant is GLOBAL_ADDP(, ). GLOBAL_ADDP() is similar to GLOBAL_ADD() but returns the PREVIOUS value of the variable instead of the new one.

Example:

mysql> DO GLOBAL_SET("xxx", 10);
mysql> SELECT GLOBAL_ADDP("xxx", 1);
10
mysql> SELECT GLOBAL_ADDP("xxx", 1);
11

Installation:

On most systems, compiling and installing the library should be as simple as typing (as root):

make install

The shared library is installed as /usr/local/lib/udf_global_user_variables.so

If the base directory of your MySQL installation is not in /usr/local, just type:

make

and then copy udf_global_user_variables.so to the right location for UDFs on your system (maybe /usr/lib/).

The name of a variable is limited to 256 bytes. If that limit is too low for your specific application, just edit the MAX_NAME_LENGTH variable on top of the .c file and reinstall. Variable names can contain binary characters.

Values are limited to 65536 bytes. If that limit is too low for you, edit the MAX_VALUE_LENGTH variable and reinstall.

Scalar is an addictive cross-platform puzzle game written in C++ using SDL library.

The goal of the game is to assemble the picture from pieces. Each picture is divided into pieces which are shuffled. You need to get each piece back to its original position. You accomplish that by swapping pieces (exchanging their positions).

You have a limited number of swappings for each picture. The game is over when you complete 3 images, and for each one you get the points. If you have a hard time playing this, you can look at the images directory and see what the final picture looks like.

Feel free to add more pictures to images directory and play with them (images can be in .jpg, .gif, .png, .bmp, any many other formats).

Variable::Alias is a Perl module created to alias any variable to any other variable.

SYNOPSIS

use Variable::Alias alias;
my $src;
my $a;
our $b;
my @c;
our @d;

alias $src => $a;
alias $a => $b;
alias $b => $c[0];
alias @c => @d;

$src=src;
# All the other variables now have the string
# src in the appropriate places.

There are various ways to alias one variable to another in Perl. The most popular is by assigning to typeglobs. This is quite efective, but only works with globals. Another method is to use a module like Lexical::Alias or Devel::LexAlias, but as their names suggest, these only work with lexicals. Theres no way to alias an element of an array or hash.

Variable::Alias changes all that. It uses a tie to provide One True Way to alias a variable.

Interface

Variable::Alias may export any or all of five functions. If youve used Lexical::Alias, the interface is virtually identical.

alias(VAR, VAR)

alias takes two variables of any type (scalar, array or hash) and aliases them. Make sure they have the sigil you want on the front.

This function is only available in Perl 5.8.0 and later, because the prototype tricks it uses were first implemented in that version.

alias_s(SCALAR, SCALAR)

alias_s takes two scalars and aliases them.

alias_a(ARRAY, ARRAY)

alias_a takes two arrays and aliases them. Note that this is actual arrays, not array elements, although you can alias references in elements, like so:

alias_a(@short, @{$some->sequence->{of}->calls->{thats}[2]{long}});

alias_h(HASH, HASH)

alias_h takes two hashes and aliases them.

alias_r(REF, REF)

alias_r takes two references and aliases them. The referents must be of the same type.

Scalar::Number is a Perl module with numeric aspects of scalars.

SYNOPSIS

use Scalar::Number qw(scalar_num_part);

$num = scalar_num_part($scalar);

use Scalar::Number qw(sclnum_is_natint sclnum_is_float);

if(sclnum_is_natint($value)) { ...
if(sclnum_is_float($value)) { ...

use Scalar::Number qw(sclnum_val_cmp sclnum_id_cmp);

@sorted_nums = sort { sclnum_val_cmp($a, $b) } @floats;
@sorted_nums = sort { sclnum_id_cmp($a, $b) } @floats;

This module is about the numeric part of plain (string) Perl scalars. A scalar has a numeric value, which may be expressed in either the native integer type or the native floating point type. Many values are expressible both ways, in which case the exact representation is insignificant. To fully understand Perl arithmetic it is necessary to know about both of these representations, and the differing behaviours of numbers according to which way they are expressible.
This module provides functions to extract the numeric part of a scalar, classify a number by expressibility, and compare numbers across representations.

Set::Scalar Perl module contains a basic set of operations.

SYNOPSIS

use Set::Scalar;
$s = Set::Scalar->new;
$s->insert(a, b);
$s->delete(b);
$t = Set::Scalar->new(x, y, $z);

Creating

$s = Set::Scalar->new;
$s = Set::Scalar->new(@members);

$t = $s->clone;
$t = $s->copy; # clone of clone

Modifying

$s->insert(@members);
$s->delete(@members);
$s->invert(@members); # insert if hasnt, delete if has

$s->clear; # removes all the elements

Note that clear() only releases the memory used by the set to be reused by Perl; it will not reduce the overall memory use.

Slay::Makefile is a wrapper to Slay::Maker that reads the rules from a file.

SYNOPSIS

Slay::Maker is a make engine that uses perl declaration syntax for rules, including regular expressions for targets and anonymous subs for targets, dependencies, and actions. This Slay::Makefile wrapper allows for the rules to be contained within a SlayMakefile file whose syntax is similar to that of a normal Makefile.

FILE SYNTAX

The file syntax is a series of statements where each statement is one of:

< perl-block >

< target(s) > : < dependencies >
< actions >

[-] include < filename >

# Comment
< perl-block > has the syntax:
{
< perl-statement(s) >
}
where < perl-statement(s) > is any series of perl statements.
< target(s >) is either a space-delimited set of targets, each of which is either a literal string or a < perl-block > which returns an array, each of which is either a literal string or a regular expression (Regexp) reference (qr/.../). A literal string can contain a % character to act as a wild-card, just as with GNU make.

However, the Regexp feature is more general, since it can capture more than one substring and use the values $!, $2, ... inside the dependencies. Note that only one target can realistically contain wildcards, whether in a Regexp or using %, since there is only one set of $1, $2, ... variables.

The colon separating a < perl-block > for < target(s) > must be on the same line as the closing brace of the < perl-block >.

< dependencies > is either a space-delimited set of dependency strings or a < perl-block > which returns an array of dependencies (or a combination). The dependency string can contain $1, $2, ..., or %, which is synonymous with $1 and ${TARGET}, which gets the target name. They can also use any scalar global variables previously defined in a < perl-block >. A dependency < perl-block > receives an array @_ with the values ($make, $target, $matches), where $make is a Slay::Maker object, $target is the target name, and $matches is a reference to an array containing the captured values from that targets Regexp (if any).

The colon separating a < perl-block > for must be on the same line as the opening brace of the < perl-block >.

< actions > is a series of zero or more action "lines", where each action is either a string, which will be executed inside a shell, a perl anonymous array, which is executed without a shell (see IPC::Run), or a < perl-block >. For purposes of this discussion, a "line" continues as long as the lines of string action end with "" or as long as a perl anonymous array or < perl-block > do not have their closing punctuation. A string action can use the strings $1, $2, ..., for the matches, $DEP0, $DEP1, ..., for the dependencies, and $TARGET, which represents the target being built. For make enthusiasts, $* can be used for $1. A string action can also use any scalar global variables previously defined in a < perl-block >.

An include line includes the content of a file with < filename > as a SlayMakefile file. If there is no such file, Slay::Makefile will try to build it using rules that have already been presented. If there is no such rule, Slay::Makefile exits with an error unless there was a - before the "include".

The equivalent of makes defines are handled by setting perl global variables. Each main < perl-block > is executed in the order it appears in the file, but any that is part of a dependency or action is evaluated lazily, so that all the global variables will have been set.

Comments begin with a # and extend to the end of line.

Continuation lines can be specified by putting a backslash at the end of the previous line, provided however, that continuation lines are unnecessary (automatic) within a perl block or perl anonymous array.

METHODS

new

Class method. Creates a new Slay::Makefile object.

maker

Method. Returns the Slay::Maker object used by this Slay::Makefile object.
make (@targets)

Method. Calls the Slay::Maker objects make method to build the list of targets. If no targets are given, makes the targets of the first rule with constant targets.

parse ($filename)

Method. Parses file $filename as a SlayMakefile and populates the Slay::Maker object with its rules. Returns a reference to an array of parse errors.

parse_string ($string, [$filename, [$lineno]])

Method. Parses $string as a SlayMakefile. If $filename and/or $lineno arguments are provided, they are used for more detailed error reporting. Returns a reference to an array of parse errors.

Variable::Strongly::Typed is a Perl module to let some variables be strongly typed.

SYNOPSIS

use Variable::Strongly::Typed;
my $int :TYPE(int); # must have an int value
my $float :TYPE(float); # must have a float value
my $string :TYPE(string); # must not be a reference
my $file :TYPE(IO::File); # must be an IO::File
my @array_of_ints :TYPE(int); # Each slot must contain
# an int
my %hash_of_floats :TYPE(float); # Each value must be a float

my $int_own_error :TYPE(int, &my_own_error_handler);
# Roll my own error handler

my @array_of_rgb :TYPE(&red_green_blue); # my enumerated type

# For subs!!
sub return_an_int :TYPE(int) {
# .. do some stuff ..
return $something;
}

# ... and later ...

$int = 23; # All is well
$int = howdy!; # This line will croak with a good error message

$float = 3.23; # All is well, nothing to see here
$float = new XML::Parser; # croak!

$array_of_ints[23] = 44; # Groovy
$array_of_ints[12] = yah; # croak!

$hash_of_floats{pi} = 3.14159; # no problem
$hash_of_floats{e} = new IO::File; # croak!

# Return 1 if this val is RED, BLUE, or GREEN
# 0 otherwise
sub red_green_blue {
local $_ = shift;

/A RED z/xms || /A BLUE z/xms || /A GREEN z/xms;
}

$array_of_my_very_own_types[23] = 99; # croak!
$array_of_my_very_own_types[2] = BLUE; # OK!

$int_own_error = lksdklwe; # The sub my_own_error_hanlder
# will be # called with the
# offending value

my $got_it = return_an_int(); # Will croak (or call your error
# function) # if this sub doesnt
# return an int

This modules allow you to strongly type your variables. Also known as the no fun module - it can greatly enhance you codes quality and robustness.

By enforcing types on some (or all) of your variables you will eliminate a large class of careless (& not so careless) errors.

This could also aid an editor or code-browsing tools to verify code correctness without having to execute the script.

Variable::Strongly::Typed::Scalar is Perl module for strongly typed scalar.

SYNOPSIS

This class is utilized by Variable::Strongly::Typed - you dont access this directly
=head1 DESCRIPTION