Free generates software for linux

B::Generate is a Perl module which you can create your own op trees.


SYNOPSIS

use B::Generate;
# Do nothing, slowly.
CHECK {
my $null = new B::OP("null",0);
my $enter = new B::OP("enter",0);
my $cop = new B::COP(0, "hiya", 0);
my $leave = new B::LISTOP("leave", 0, $enter, $null);
$leave->children(3);
$enter->sibling($cop);
$enter->next($cop);
$cop->sibling($null);
$null->next($leave);
$cop->next($leave);

# Tell Perl where to find our tree.
B::main_root($leave);
B::main_start($enter);
}

WARNING

This module will create segmentation faults if you dont know how to use it properly. Further warning: sometimes I dont know how to use it properly.

There are lots of other methods and utility functions, but they are not documented here. This is deliberate, rather than just through laziness. You are expected to have read the Perl and XS sources to this module before attempting to do anything with it.
Patches welcome.

Malcolm Beatties B module allows you to examine the Perl op tree at runtime, in Perl space; its the basis of the Perl compiler. But what it doesnt let you do is manipulate that op tree: it wont let you create new ops, or modify old ones. Now you can.
Well, if youre intimately familiar with Perls internals, you can.

B::Generate turns Bs accessor methods into get-set methods. Hence, instead of merely saying

$op2 = $op->next;

you can now say

$op->next($op2);

to set the next op in the chain. It also adds constructor methods to create new ops. This is where it gets really hairy.

new B::OP ( type, flags )
new B::UNOP ( type, flags, first )
new B::BINOP ( type, flags, first, last )
new B::LOGOP ( type, flags, first, other )
new B::LISTOP ( type, flags, first, last )
new B::COP ( flags, name, first )

In all of the above constructors, type is either a numeric value representing the op type (62 is the addition operator, for instance) or the name of the op. ("add")
(Incidentally, if you know about custom ops and have registed them properly with the interpreter, you can create custom ops by name: new B::OP("mycustomop",0), or whatever.)

first, last and other are ops to be attached to the current op; these should be B::OP objects. If you havent created the ops yet, dont worry; give a false value, and fill them in later:

$x = new B::UNOP("negate", 0, undef);
# ... create some more ops ...
$x->first($y);

In addition, one may create a new nextstate operator with

newstate B::op ( flags, label, op)

in the same manner as B::COP::new - this will also, however, add the lineseq op.
Finally, you can set the main root and the starting op by passing ops to the B::main_root and B::main_start functions.

This module can obviously be used for all sorts of fun purposes. The best one will be in conjuction with source filters; have your source filter parse an input file in a foreign language, create an op tree for it and get Perl to execute it. Then email me and tell me how you did it. And why.

Class::Generate is a Perl module that can generate Perl class hierarchies.

SYNOPSIS

use Class::Generate qw(class subclass delete_class);

# Declare class Class_Name, with the following types of members:
class
Class_Name => [
s => $, # scalar
a => @, # array
h => %, # hash
c => Class, # Class
c_a => @Class, # array of Class
c_h => %Class, # hash of Class
&m => body, # method
];

# Allocate an instance of class_name, with members initialized to the
# given values (pass arrays and hashes using references).
$obj = Class_Name->new ( s => scalar,
a => [ values ],
h => { key1 => v1, ... },
c => Class->new,
c_a => [ Class->new, ... ],
c_h => [ key1 => Class->new, ... ] );

# Scalar type accessor:
$obj->s($value); # Assign $value to member s.
$member_value = $obj->s; # Access members value.

# (Class) Array type accessor:
$obj->a([value1, value2, ...]); # Assign whole array to member.
$obj->a(2, $value); # Assign $value to array member 2.
$obj->add_a($value); # Append $value to end of array.
@a = $obj->a; # Access whole array.
$ary_member_value = $obj->a(2); # Access array member 2.
$s = $obj->a_size; # Return size of array.
$value = $obj->last_a; # Return last element of array.

# (Class) Hash type accessor:
$obj->h({ k_1=>v1, ..., k_n=>v_n }) # Assign whole hash to member.
$obj->h($key, $value); # Assign $value to hash member $key.
%hash = $obj->h; # Access whole hash.
$hash_member_value = $obj->h($key); # Access hash member value $key.
$obj->delete_h($key); # Delete slot occupied by $key.
@keys = $obj->h_keys; # Access keys of member h.
@values = $obj->h_values; # Access values of member h.

$another = $obj->copy; # Copy an object.
if ( $obj->equals($another) ) { ... } # Test equality.

subclass s => [ ], -parent => class_name;

The Class::Generate package exports functions that take as arguments a class specification and create from these specifications a Perl 5 class. The specification language allows many object-oriented constructs: typed members, inheritance, private members, required members, default values, object methods, class methods, class variables, and more.

CPAN contains similar packages. Why another? Because object-oriented programming, especially in a dynamic language like Perl, is a complicated endeavor. I wanted a package that would work very hard to catch the errors you (well, I anyway) commonly make. I wanted a package that could help me enforce the contract of object-oriented programming. I also wanted it to get out of my way when I asked.

QOF Generator is a project that generates C object source code from HTML/PHP or Perl/XML.

Generating new objects for the Query Object Framework is repetitive, tedious, and time consuming.

Qof Generator automates this process in PHP to build a working test program linked against QOF.

Objects are created from an HTML form using a temporary MySQL cache and exported with Makefile, ./autogen.sh, ChangeLog, README, C source code, and doxygen mark-up comments in a tarball built by the PHP code.

Firewall Generator is a CGI script that generates a bash shell script that contains a list of commands for configuring a set of firewall rules.

It is the best solution to know something about system security.

NetMap Generator is a project used to generate a graphical map of your connection with the Internet.

It first uses traceroute to make a list of all routers and their interconnections, after which it generates a .dot file.

You need the Dotty program to view the graphical representation of you network.

logindpostgres is a script that reads SQL select statements from PostgreSQL logs and generates all the indices to optimize the database for each request.

logindpostgres has been tested on 1.2 GB of logs.

Fraqtive is a program for drawing Mandelbrot and Julia fractals. It uses a very fast algorithm and generates high quality, smooth images.

It is fully interactive, allowing for real-time mouse navigation and dynamic generation of the Julia fractal preview. OpenGL-rendered 3D view of the fractals is also supported.

The Ming Server generates Web pages statically or dynamically. As a local executable, it generates a static site from a directory tree of simple text files.
Installed in cgi-bin, it creates those same pages on demand in response to browser requests. Parsing of different source types, the creation, and the writing of pages are separated, making it easy to extend The Ming Server to new data types or delivery methods.
Enhancements:
- A bug in Logger was fixed along with a problem in ming.cgi.