Free language of flowers software for linux

Language::Zcode::Parser is a Perl module that reads and parses a Z-code file into a big Perl hash.

SYNOPSIS

# Create a Pure Perl Parser
my $pParser = new Language::Zcode::Parser "Perl";

# If they didnt put ".z5" at the end, find it anyway
$infile = $pParser->find_zfile($infile) || exit;

# Read in the file, store it in memory
$pParser->read_memory($infile);

# Parse header of the Z-file
$pParser->parse_header();

# Get the subroutines in the file (LZ::Parser::Routine objects)
my @subs = $pParser->find_subs($infile);

For finding where the subroutines start and end, you can either depend on an external call to txd, a 1992 C program available at ifarchive.org, or a pure Perl version.

Everything else is done in pure Perl.

new (class, how to find subs, args...)

This is a factory method. Called with Perl or TXD (or txd) as arguments, it will create Parsers of LZ::Parser::Perl or LZ::Parser::TXD, which are subclasses of LZ::Parser::Generic.

That class new method will be called with any other passed-in args.

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.

Language::XSB is a Perl module that allows you to use XSB from Perl.

SYNOPSIS

use Language::XSB :query;
use Language::Prolog::Types::overload;
use Language::Prolog::Sugar vars=>[qw(X Y Z)],
functors=>{equal => =},
functors=>[qw(is)],
chains=>{plus => +,
orn => ;};

xsb_set_query( equal(X, 34),
equal(Y, -12),
is(Z, plus( X,
Y,
1000 )));

while(xsb_next()) {
printf("X=%d, Y=%d, Z=%dn",
xsb_var(X), xsb_var(Y), xsb_var(Z))
}

print join("n", xsb_find_all(orn(equal(X, 27),
equal(X, 45)), X)), "n";

ABSTRACT

Language::XSB provides a bidirectional interface to XSB (http://xsb.sourceforge.net/).

From the XSB manual:

XSB is a research-oriented Logic Programming and Deductive
Database System developed at SUNY Stony Brook. In addition to
providing all the functionality of Prolog, it contains
features not usually found in Logic Programming Systems such
as evaluation according to the Well Founded Semantics through
full SLG resolution, constraint handling for tabled programs,
a compiled HiLog implementation, unification factoring and
interfaces to other systems such as ODBC, C, Java, Perl, and
Oracle

This package implements a bidirectional interface to XSB, thats means that Perl can call XSB that can call Perl back that can call XSB again, etc.:

Perl -> XSB -> Perl -> XSB -> ...

(Unfortunately, you have to start from Perl, XSB->Perl->... is not possible.)
The interface to XSB is based on the objects created by the package Language::Prolog::Types. You can also use Language::Prolog::Sugar package, a front end for the types package to improve the look of your source (just some syntactic sugar).

To make queries to XSB you have to set first the query term with the function xsb_set_query, and then use xsb_next and xsb_result to iterate over it and get the results back.

Only one query can be open at any time, unless when Perl is called back from XSB, but then the old query is not visible.

ADML language is a server-side scripting language with Mysql database suport.

About Apache:

Apache HTTP Server is a free software/open source HTTP web server for Unix-like systems (BSD, Linux, and UNIX systems), Microsoft Windows, Novell NetWare and other platforms. Apache is notable for playing a key role in the initial growth of the World Wide Web, and continues to be the most popular web server in use, serving as the reference platform against which other web servers are designed and judged.

Apache features highly configurable error messages, DBMS-based authentication databases, and content negotiation. It is also supported by several graphical user interfaces (GUIs) which permit easier, more intuitive configuration of the server.
The Apache HTTP Server is developed and maintained by an open community of developers under the auspices of the Apache Software Foundation.

. Its syntax is almost identical to that of the Interactive Data Language (IDL).
Main features:
- all language elements are supported
- multithreaded operators
- array operations use MMX/SSE/SSE2, if available
- module profiling
- line profiling
- about 300 library functions (more or less usable)
- true-color (24 bit) direct graphics devices: X, WIN, PS, PDF, Z
- run-time performance: for many programs, FL is faster than IDL (eg. the empty loop is three times faster in FL :-)
Installation:
- create a directory (INSTDIR), where you want to install FL
- unpack the archive into this directory
- create an FL_DIR environment variable, which points to INSTDIR/fl/fl_0.61
- run FL_DIR/bin/fl
Enhancements:
- This release introduces Distributed FL, and can be started as a TCP/IP daemon (Linux only), waiting for requests from other hosts (masters) and working for them as a slave.

Apache::Language is a Perl transparent language support for Apache modules and mod_perl scripts.

SYNOPSIS

In YourModule.pm:

sub handler {
my $r = shift;
use Apache::Language;
my $lang = Apache::Language->new($extra_args);
#$lang is now a hash ref that will automacigally pick the right language

print $lang->{Error01} if exists $lang->{Error01};

foreach ( keys %$lang ){
print "$_ is " . $lang->{$_};
}

[...]
}

The goal of this module is to provide a simple way for mod_perl module writers to include support for multiple language requests.

This is version 0.03, and its a complete rewrite from the ground-up of the previous release. Its still backward-compatible with the other releases, but now its much more advanced.

An Apache::Language object acts like a language-aware hash. It stores key/language/values triplets. Using the Accept-Language: field sent by the web-client, it can pick the best fit language for that specific client. Its usage is transparent and should prove to be quite convenient (and hopefully, efficient).

The method used to store/fetch information is now completely modular and will allow easy creation of new storage methods thru a simple API (see the API section).

Language::Frink::Eval is a Perl module that acts as a simple wrapper around the Frink interpreter written by Alan Eliasen. As such, it requires a local copy of the Java interpreter and the frink.jar file. For more information on Frink, please see http://futureboy.homeip.net/frinkdocs/.

This module works by starting a JVM as a child process, and sending Frink expressions to it via a pipe, and retrieving the results the same way. Also, this module has the ability to function in a restricted mode it attempts to filter "dangerous" expressions, such as functions that read files from local disk, the network, and also commands that may persistantly change the interpreter state.

The list of "dangerous" functions and expressions was derived by reading the Frink documentation, and probably is not complete. If you find commands that get through the filter that should, please report them.

The following functions are not allowed in restricted mode:

lines[]
read[]
eval[]
input[]
select[]
callJava[]
newJava[]
staticJava[]

The following language constructs are not allowed in restricted mode:

Regexes
Function Declarations
Unit display format
Loops
Time display format
Procedure blocks
File inclusion
Class Declaration