Free condition software for linux

Sub::PatMat can call a version of subroutine depending on its arguments.
SYNOPSIS
use Sub::PatMat;
# basics:
sub fact : when($_[0] $b) { 1 }
print join ", ", sort mysort (3,1,2);
# intuiting parameter names:
sub dispatch : when($ev eq "help") { my ($ev) = @_; print "helpn" }
sub dispatch : when($ev eq "blah") { my ($ev) = @_; print "blahn" }
dispatch("help");
dispatch("blah");
# no fallback, this will die:
dispatch("hest"); # dies with "Bad match"
# silly
sub do_something : when(full_moon()) { do_one_thing() }
sub do_something { do_something_else() }
The Sub::PatMat module provides the programmer with the ability to define a subroutine multiple times and to specify what version of the subroutine should be called, depending on the parameters passed to it (or any other condition).
This is somewhat similar to argument pattern matching facility provided by many programming languages.
To use argument pattern matching on a sub, the programmer has to specify the when attribute. The parameter to the attribute must be a single Perl expression.
When the sub is called, those expressions are evaluated consequitively until one of them evaluates to a true value. When this happens, the corresponding version of a sub is called.
If none of the expressions evaluates to a true value, a Bad Match exception is thrown.
It is possible to specify a fall-back version of the function by doing one of the following:
specifying when without an expression
specifying when with an empty expression
not specifying the when attribute at all
Please note that it does not make sense to specify any non-fall-back version of the sub after the fall-back version, since such will never be called.
There is an additional limitation for the last form of the fall-back version (the one without the when attribute at all), namely, it must be the last version of the sub defined.
It is possible to specify named sub parameters in the when-expression. This facility is highly experimental and is currently limited to scalar parameters only. The named sub parameters are extracted from expressions of the form
my (parameter list) = @_;
anywhere in the body of the sub.
Version restrictions:
- The ability to intuit parameter names is very limited and without doubts buggy.
- The when attribute condition is limited to a single Perl expression.
Enhancements:
- Perl

CryptNET Keyserver is an effort to develop an openPGP (RFC2440) compliant public keys server which is licensed under the terms of the GNU GPL.
It is written in C, and runs on Linux. It uses PostgreSQL for key storage, and supports the hkp protocol (it can interface with GnuPG and NAI PGP). The keyserver is mostly functional, and there is a link to a running copy on the homepage.
Main features:
- openPGP (RFC2440) compatible (version 3 and version 4 packets)
- Validate keys packets and subpackets
- Tied to free RDBMS (postgreSQL)
- Interface with programs through standard keyserver interface
- Capable of updating previously stored keys
- Key caching
- Fully multi-threaded
- Fully (cryptographically) validate signatures
- Handle signature expiration
- Handle key expiration and revocation
- Allow users to submit and retrieve keys through web browser
- Allow users to submit and retrieve multiple keys as key ring through web browser
- Synchronize with other keyservers through HTTP protocol (PKS)
Enhancements:
- Feature Request Completed: [ 1000332 ] sigalm to prevent cpu throttle (vab)
- Feature Request Completed: [ 1192629 ] (Optional) Large File Support (vab)
- Fixed Bug: [ 999662 ] Legacy gcc compatibility (pacoje)
- Fixed Bug: [ 999656 ] tcpwrappers problems in-addr.arpa (pacoje)
- Fixed Bug: [ 999925 ] cks import problems (vab)
- Fixed Bug: [ 969089 ] cks_import skips last pubkey in keyring (vab)
- Fixed Bug: [ 999676 ] cks import problems (vab)
- Fixed Bug: [ 966767 ] cks_import race condition on import error (vab)
- Fixed Bug: [ 969739 ] Valgrind: parse_attribute_sub_packets (vab)
- Fixed Bug: [ 969734 ] Valgrind: Memory Violation (vab)
- A context was created to handle state information (vab)
- sql updates (tab vs. spaces bug in formatting of cks.sql.in) (vab)
- General code clean-up (Function Signature Changes) (vab)
- cks_install.pl removed (Integrated into Autoconf/Automake) (vab)
- Fixes to correct most -Wall warnings (vab)
- Fix for memory leak in parse.c (vab)
- Code to force cksd to exit if it is running with root privileges (vab)
- cksd.init rewritten (vab)
- Support of storage of pid in /var/run for init system usage (vab)
- CGI processing code clean-up (vab)
- Creation of etc dir in project root w/ separate Makefile (vab)
- Clean-up of HTML pages (vab)
- Removal of db2 hooks - no longer have access to the software (vab)
- Removal of some out dated documentation (vab)
- Fix for potential read_line race condition (vab)
- Default user for keyserver changed to "cks" (vab)
- Default user for webserver changed to "apache" for Gentoo (vab)
- New hook HTML page for Web Of Trust Information (vab)
- HTML Layout bug fix in keys.c print_uid: echo_signatures (vab)
- SIGPIPE in now ignored. SIGTERM and SIGHUP are now caught (vab)

V language is a tiny concatenative language implemented for experimentation.
The source is under Public Domain (un-copyrighted.)
The full featured language is on top of JVM, A native version (in alpha state) is also there in the codebase.
To run it, extract the distribution in any directory and do #gmake run.
gmake
gmake run
V
|
The language is a close relative of postscript, forth and joy. and is stack based. ie:
|2 3 *
=6
|2 3 * 5 +
=11
See status for a tutorial and more info.
The Functions available in V are available in this page: functions
(The releases are out of date and multiple fixes have gone in. Please check out and build rather than use them.)
Example functions in V. getting the roots (with out using the stack shuffling word view)
[quad-formula
[a b c] let
[minisub 0 b -].
[radical b b * 4 a * c * - sqrt].
[divisor 2 a *].
[root1 minisub radical + divisor /].
[root2 minisub radical - divisor /].
root1 root2
].
|2 4 -30 quad-formula ??
=(-5.0 3.0)
using view
[quad-root
[a b c : [0 b - b b * 4 a * c * - sqrt + 2 a * /]] view i
].
|2 4 -30 quad-root ??
=(3)
contrast this with the definition in scheme here
(define quadratic-formula
(lambda (a b c)
(let ([minusb (- 0 b)]
[radical (sqrt (- (* b b) (* 4 ( * a c))))]
[divisor (* 2 a)] )
let ([root1 (/ (+ minusb radical) divisor)]
[root2 (/ (- minusb radical) divisor)])
(cons root1 root2)))))
Definition of Qsort.
[qsort
#definitions
[joinparts [pivot [*list1] [*list2] : [*list1 pivot *list2]] view].
[split_on_first_element uncons [>] split&].
#args starts for binrec. notice that 2 arguments (termination condition
#and its result) are on first line.
[small?] []
[split_on_first_element]
#binrec recurses on the result of split_on_first_element before applying joinparts.
[joinparts]
binrec].
Some explanations.
The first and second lines (terminated by .) are internal function definitions
(Notice how qsort is also terminated by .) . is the definition syntax in V.
The first function joinparts
============================
The function joinpart contains just an application of the operator view.
view is list translator. It takes a list of the form [template : result]
then it tries to apply the template to the current stack. If it can be applied on the
stack, then the arguments named in the template are bound to values in stack. The result is then processed, and all the bound elements in result are replaced by their values.
[pivot [*list1] [*list2] : [*list1 pivot *list2]] view expects 3 arguments on the stack,
the first a single element pivot, then two lists list1 and list2.
It returns a list that is composed of elements of list1 followed by pivot
followed by elements of list2 (as defined in result - RHS of :).
ie:
44 [1 2 3] [5 6 7] [pivot [*list1] [*list2] : [*list1 pivot *list2]] view ??
=> [1 2 3 44 5 6 7]
(The function ?? is used to print out the elements in the stack now.)
The second function split_on_first_element
==========================================
The definition is [uncons [>] split&]
The uncons splits a list into the first element and the rest of the list.
ie:
[1 2 3 4 5] uncons ??
=1 [2 3 4 5]
split& takes two arguments, the first is the function F to split a list with,
and the second the list itself. All elements in the list that passes the function F
is put into the first list, and all that do not are put into the second list.
ie:
[1 2 3 4 5 6 7] [4 >] split& ??
=[5 6 7] [1 2 3 4]
The function F can also take an argument from the stack. so this also works.
4 [1 2 3 4 5 6 7] [>] split& ??
=[5 6 7] [1 2 3 4]
Thus the split_on_first_element takes the first element of a list, and split that
list based on that element as a filter.
binrec
=======
binrec expects 4 arguments,
Arg1 is the terminating condition,
Arg2 is the result if the terminating condition is met.
Arg3 is an executable statement that returns two entities.
The entire binrec statement is performed on each of the
two entities until the terminating condition is met.
Arg4 is what to do with the result of the previous statement.
Algorithm.
Here, the small? checks if the list is empty or contains just one element.
if it is, then the result is arg2 - []
ie:
[] small? ??
=true
[1] small? ??
=true
[1 2 3 4] small? ??
=false
split_on_first_element takes is executed on all lists that are larger than size 1
and as explained above, splits them into two based on the first element.
on the resultent lists, the entire qsort is performed again due to binrec.
The last joinparts takes these elements (pivot list1 list2) which are present now
on the stack, and combines them to produce a single sorted list.
A slightly friendlier function (with out the binrec.)
[qsort
[joinparts [pivot [*list1] [*list2] : [*list1 pivot *list2]] view].
[split_on_first_element uncons [>] split&].
[small?]
[]
[split_on_first_element [list1 list2 : [list1 qsort list2 qsort joinparts]] view i]
ifte].
The binrec and friends are more powerful than the explicit recursion done above, but for people new to concatenative languages, this kind of recursion may look more intuitive.
Enhancements:
- The language has become relatively stable.
- Lots of bugfixes were made in scope handling.
- Tree operations were added.
- Generic combinators were moved out into a separate library.

Qfsm project is a graphical editor for finite state machines written in C++ using Qt the graphical Toolkit from Trolltech.
Finite state machines are a model to describe complex objects or systems in terms of the states they may be in. In practice they can used to design integrated circuits or to create regular expressions, scanners or other program code.
Main features:
- Drawing, editing and printing of diagrams
- Binary, ASCII and "free text" condition codes
- Multiple windows
- Integrity check
- Interactive simulation
- AHDL/VHDL/Verilog HDL/KISS export
- State table export in Latex, HTML and plain text format
- Ragel file export (used for C/C++, Java or Ruby code generation)
Enhancements:
- English user documentation was written.
- The possibility of default transition was introduced.
- Ragel file export was added.
- The input condition "any" was introduced.
- The possibility to invert transition conditions was introduced.
- More arrow types were added.
- The "Free Text" type was added.
- The "print header" option was added.