Free compile software for linux

Blatte::Compiler is a Perl module to compile a Blatte document into Perl.

SYNOPSIS

use Blatte::Compiler;

&Blatte::Compiler::compile($file_handle, &callback);

&Blatte::Compiler::compile_sparse($file_handle, &callback);

sub callback {
my($val, $src) = @_;

if (defined($src)) {
...Blatte expression...
} else {
...plain text...
}
}

This is a convenient interface for parsing a file full of Blatte code. A file handle and a callback are passed to compile() or compile_sparse() (see below for the difference between the two). The callback is then invoked for each top-level item parsed from the input.

The compile() function treats its entire input as a sequence of Blatte expressions, including plain text at the top level, which is divided up into Blatte "words," each of which is one Blatte expression. The callback is called once for each expression, with two arguments: the Perl string resulting from parsing the Blatte expression; and the Blatte source string itself.

The compile_sparse() function works the same way, except that plain text at the top-level of the input is not divided into words. Only Blatte expressions beginning with a Blatte metacharacter are parsed as described above. All text in between such expressions is passed as a single string to the callback, with no second argument.

Filter::Simple::Compile is a drop-in replacement to Filter::Simple.

SYNOPSIS

Drop-in replacement for Filter::Simple:
package MyFilter;
use Filter::Simple::Compile;
FILTER { ... };

This way also works:
use Filter::Simple::Compile sub { ... };

This module lets you write Module::Compile extensions that are compatible with Filter::Simples API.

Additionally, no Filter::Simple::Compile does the same thing as use Filter::Simple::Compile, except the meaning for use and no will be reversed for your filter:

package MyFilter;
no Filter::Simple::Compile sub { ... }

# "no MyFilter" begins filtering
# "use MyFilter" terminates it

XML::Compile::Schema::XmlReader Perl module contains bricks to translate XML to HASH.

SYNOPSIS

my $schema = XML::Compile::Schema- >new(...);
my $code = $schema- >compile(READER = > ...);

The translator understands schemas, but does not encode that into actions. This module implements those actions to translate from XML into a (nested) Perl HASH structure.

DETAILS

Processing Wildcards

If you want to collect information from the XML structure, which is permitted by any and anyAttribute specifications in the schema, you have to implement that yourself. The problem is XML::Compile has less knowledge than you about the possible data.

anyAttribute

By default, the anyAttribute specification is ignored. When TAKE_ALL is given, all attributes which are fulfilling the name-space requirement added to the returned data-structure. As key, the absolute element name will be used, with as value the related unparsed XML element.

In the current implementation, if an explicit attribute is also covered by the name-spaces permitted by the anyAttribute definition, then it will also appear in that list (and hence the handler will be called as well).

Use XML::Compile::Schema::compile(anyAttribute) to write your own handler, to influence the behavior. The handler will be called for each attribute, and you must return list of pairs of derived information. When the returned is empty, the attribute data is lost. The value may be a complex structure.

Example: anyAttribute in XmlReader

Say your schema looks like this:

< schema targetNamespace="http://mine"
xmlns:me="http://mine" ... >
< element name="el" >
< complexType >
< attribute name="a" type="xs:int" / >
< anyAttribute namespace="##targetNamespace"
processContents="lax" >
< / complexType >
< / element >
< simpleType name="non-empty" >
< restriction base="xs:NCName" / >
< / simpleType >
< / schema >

Then, in an application, you write:

my $r = $schema- >compile(READER = > {http://mine}el
, anyAttribute = > ALL
);

my $h = $r- >( < < __XML );
< el xmlns:me="http://mine" >
< a >42< /a >
< b type="me:non-empty" >
everything
< / b >
< / el >
__XML

use Data::Dumper Dumper;
print Dumper $h;
__XML__
The output is something like
$VAR1 =
{ a = > 42
, {http://mine}a = > ... # XML::LibXML::Node with < a >42< /a >
, {http://mine}b = > ... # XML::LibXML::Node with < b >everything< /b >
};

You can improve the reader with a callback. When you know that the extra attribute is always of type non-empty, then you can do

my $read = $schema- >compile
( READER = > {http://mine}el
, anyAttribute = > &filter
);

my $anyAttRead = $schema- >compile
( READER = > {http://mine}non-empty
);

sub filter($$$$)
{ my ($fqn, $xml, $path, $translator) = @_;
return () if $fqn ne {http://mine}b;
(b = > $anyAttRead- >($xml));
}

my $h = $r- >( see above );
print Dumper $h;
Which will result in
$VAR1 =
{ a = > 42
, b = > everything
};

The filter will be called twice, but return nothing in the first case. You can implement any kind of complex processing in the filter.

XML::Filter::Dispatcher::Compiler can compile rulesets in to code.

SYNOPSIS

use XML::Filter::Dispatcher::Compiler qw( xinline );

my $c = XML::Filter::Dispatcher::Compiler->new( ... )

my $code = $c->compile(
Package => "My::Filter",
Rules => [
a/b/c => xinline q{warn "found a/b/c"},
],
Output => "lib/My/Filter.pm", ## optional
);

Most of the options from XML::Filter::Dispatcher are accepted.

NOTE: you cannot pass code references to compile() if you want to write the $code to disk, they will not survive. If you want to eval $code, this is ok.

METHODS

xinline

Hints to X::F::D that the string is inlinable code. This is a requirement when using the compiler and is so far (v.52) ignored elswhere. In xinlined code, $self refers to the current dispatcher and $e refers to the current events data. Or you can get that yourself in $_[0] and $_[1] as in a normal SAX event handling method.

compile

Accepts options that extend and override any previously set for the duration of the compile(), including the ruleset to compile.

Mumble is low-latency, high quality voice chat software primarily intended for use while gaming.

Mumble should compile and run the client out of the box on at least Ubuntu 6.06, and quite likely other distributions as well.

FTP Copy (fcp for short) is a program which currently has the ability to copy single files from your computer into any folder in any ftp site via the command line. Its definetly not the best of its kind, but it gets the job done with minimal fuss. Both active and passive mode are supported.
Active and passive mode are supported. In the future the program may be extended to support wildcard copying, copying from the server, directory listings and other such features. If anyone wishes to add these features to the current codebase, mail me the new code and ill put it up.


To install the code under Linux (or possibly in other POSIX compatible environments), run the script compile.sh (sh compile.sh). That should compile the code into the executable file fcp.

rico_RADIO is a little app for X under linux to listen to the radio.
This is how to install:
type (make sure that you are root) "make install" to compile and copy rico_RADIO to "/usr/bin"
Enhancements:
- volume-control
- mute-button
- many cosmetic changes