Free variable software for linux

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.

libvarexp is a C++ library that allows its users to detach any kind of information from the representation of that information by providing a simple-to-use but powerful text-template mechanism.

Similar mechanisms have been available in tools like sh(1), make(1), or perl(1) forever and have proven to be very useful.

The basic idea is that the relevant information is made available in variables, which the author of the template can than use within the text itself as he or she sees fit.

Consider, for example, a tool that will calculate the monthly financial reports of a small company.

Such a program should only calculate the required values, it should not worry about writing the resulting reports into an HTML file, a CSV file, or whatever format is desired. Instead, it should make the results of the calculation available in the variables "$TURNOVER", "$PROFIT", and "$INCREASE".

Then, using libvarexp, it could load an arbitrary template file and have the actual values inserted at the apropriate positions. Without changing a single line of code, one could generate the monthly report in HTML

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

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.

Libconfig is a configuration file processing library that saves you from having to write your own configuration parsers and routines.
This project supports callback functions, automatic variable assignment, and many different configuration file types such as Apache-like, Windows INI-like, and whitespace separated.
Configuration is processed in a logical manner: global configuration files, local configuration files, environment variables, and finally command line options.
Enhancements:
- This release adds functions to set a user-specified error string from callback handlers.
- It exposes functions to convert from a string to a specified type.
- The documentation has been slightly cleaned up.

wmgmail is a Gmail inbox checker dockapp with preview.
Main features:
- check gmail inbox mail count
- Quick Mail Preview (snippets of email you just got)
- QMP can self-timeout (variable delay)
- can launch a program (play a sound) on new mail.
- dark and light colorschemes available.
- GTK interface is optional

CGIParse project is a C++ class library for parsing the input of a cgi program.

Starting

To start using CGIParse you first have to include the cgiparse.h header:

#include < cgiparse.h >

Thereafter you have to define the CGIParse object:
CGIParse cgi;

The CGIParse object then automatically reads the headers and the variables parsed to the program using environment variables and (if using POST or PUT) standard input.

Now the library has been initialized and we are ready to use it.

Header

The headers parsed to CGIParse is easily available to the programmer after the library has been initialized. To retrieve them CGIParse provides functions named after the environment variable it retrieves. Fx. to retrieve the SERVER_SOFTWARE environment variable, you use the function server_software(). The functions providing these environment variables are:

char* server_software(void);
char* server_name(void);
char* gateway_interface(void);
char* server_protocol(void);
int server_port(void);
int request_method(void);
char* request_methodc(void);
char* path_info(void);
char* path_translated(void);
char* script_name(void);
char* query_string(void);
char* remote_host(void);
char* remote_addr(void);
char* auth_type(void);
char* remote_user(void);
char* remote_ident(void);
char* content_type(void);
int content_length(void);
char* http_accept(void);
char* http_user_agent(void);
char* http_referer(void);
char* input(void);

It is important to note that if the environment variable you are trying to access doesnt exist, the function will return NULL if you were trying to retrieve a char* and -1 if its a int.

Variables

The variables from the browser can of course also be accessed by CGIParse.

To retrieve the number of variables, you can use the int num() function, and to retrieve the variable names and parameters number i, you user the functions:

char* name ( int i );
char* parm ( int i );

You can also use the function char* parm ( const char *n ); to retrieve the parameter of the variable with name n.

Debugging

When debugging your CGI application it can sometimes be useful to see what is transfered to the CGI application. You could of course program this yourself, but for your ease some functions for it has been provided the function htable() draws a html table with the header retrieved from CGI.

CGIParse also provide you with a function called ptable() which prints the variables sent to the CGI application.

mod_include is a post processing of SSI variables, Apache module.

Doesnt sound too helpful ? Well, maybe not, but I found that during construction of this site that I was frequently replicating 5 lines of text with only a single word altered (the left menu). This was both inefficient and awkward to debug, and didnt lend itself to keeping a common look and feel for the site as a whole. This extension allows large blocks of text to be stored as a variable, and for the small changable part to be altered just before the result is displayed.

Whats wrong with set anyway ?

When a variable is used in the value entry of a set command the system searches for the current value of the variable and substitutes it immediately. This fixes the value of the variable created so that it never changes, which is good for some applications, but lousy for dynamic content.

Usage

This module is an extension of the normal Apache behaviour, and should be read as an addendum to the basic mod_include commands.

define

This command sets up a variable in the same way as the set directive, except that any variable names used are not parsed at this time, but stored as names until displayed with the macro directive.

var

The name of the variable (macro) to define.

value

The value of the variable (macro).

macro

This command will expand a previously defined variable and replace any instances of the variable named in var in the variable def with the value given in value. Note that like other mod_include commands, the order of the variables is important, and should be declared in the sequence shown below:

var

The name of the variable to replace inside the macro.

value

The value to replace the variable with.

def

The previously defined macro to seach through.