Free to 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.

Apache Compile HOWTO is a full-featured Apache compilation HOWTO.
The Apache Compile HOWTO is a simple set of instructions and examples for compiling Apache, mod_ssl, mod_perl, mod_dav, mod_auth_ldap, mod_auth_mysql, mod_dynvhost, mod_roaming, mod_jserv, and mod_php (including MySQL, Postgres, pdflib, and IMAP).
Enhancements:
- Added XML and Sablotron support to PHP
- Dropped support for mod_jserv
- Added mod_jk support
- Enhanced support for Tomcat
- Updated software mentioned in the HOWTO
- Minor SGML enhancements

XML::Compile::Schema is a Perl module to compile a schema.

INHERITANCE

XML::Compile::Schema
is a XML::Compile

SYNOPSIS

# preparation
my $parser = XML::LibXML->new;
my $tree = $parser->parse...(...);

my $schema = XML::Compile::Schema->new($tree);

my $schema = XML::Compile::Schema->new($xml_string);
my $read = $schema->compile(READER => mytype);
my $hash = $read->($xml);

my $doc = XML::LibXML::Document->new(1.0, UTF-8);
my $write = $schema->compile(WRITER => mytype);
my $xml = $write->($doc, $hash);
print $xml->toString;

This module collects knowledge about a schema. The most important method is compile() which can create XML file readers and writers based on the schema information and some selected type.

WARNING: The compiler is implemented in XML::Compile::Schema::Translate, which is NOT FINISHED. See that manual page about the specific behavior and its (current) limitations! Please help to find missing pieces and mistakes.

WARNING: the provided schema is not validated! In some cases, compile-time and run-time errors will be reported, but typically only in cases that the parser has no idea what to do with such a mistake. On the other hand, the processed data is validated: the output should follow the specs closely.

Two implementations use the translator, and more can be added later. Both get created with the compile() method.

XML Reader

The XML reader produces a hash from a XML::LibXML::Node tree, or an XML string. The values are checked and will be ignored if the value is not according to the specs.

XML Writer

The writer produces schema compliant XML, based on a hash. To get the data encoding correct, you are required to pass a document in which the XML nodes may get a place later.

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.

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.

PEditor is an experimental programmers editor. The goal is to create an editor that could be used by a person (most likely a student) with no a priori knowledge of programming. This aims to be a classic "write code, click run" IDE.
Main features:
- tabs
- syntax highlighting
- some form of auto-complete
- ability to compile/run simple programmes
- a code snippets library
PEditor project is aimed at the C/C++ programmer, though support for other languages may be added.

Service Control is a basically it allows you to easily control services. Very very simple.

Currently only for Gentoos service directories, so if you use another distrobution, youll have to edit the initial combo variable to suit your needs.

NEEDS TO BE RUN AS ROOT!

Installation:

The simplest way to compile this package is:

1. `cd to the directory containing the packages source code and type `./configure to configure the package for your system. If youre using `csh on an old version of System V, you might need to type `sh ./configure instead to prevent `csh from trying to execute `configure itself.

Running `configure takes a while. While running, it prints some messages telling which features it is checking for.

2. Type `make to compile the package.

3. Type `make install to install the programs and any data files and documentation.

4. You can remove the program binaries and object files from the source code directory by typing `make clean.

ProxyView is a simple proxy server which relays TCP/IP[v4] connections from an IP:port defined on the commandline to another address:port. It dumps to the console all the data which arrives on the client and server sockets. It is a proxy for programmers designed to makes debugging TCP/IP software easier.

ProxyView will dump any data going between client and server.

Type these to install:
1) run make to compile program
2) run ./ProxyView -?...