generate

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.

Generate Numly Copyright description
Generate Numly Copyright is a Firefox extension that allows you to register documents for Numly copyright Generate Numly Copyright allows you to register documents and blogs for Numly copyright.

Numly Numbers are unique identifiers of electronic media and recognized worldwide by electronic publishing companies and electronic content providers.

Numly Numbers are simple and quick to generate and serve as branded identifier for individuals or companies authoring or distributing electronic content and media.

Generate Numly Copyright is a Firefox extension that registers documents and blogs for Numly copyright. Numly Numbers are unique identifiers of electronic media and recognized worldwide by electronic publishing companies and electronic content providers. Numly Numbers are simple and quick to generate and serve as branded identifier for individuals or companies authoring or distributing electronic content and media.

Generate Em description
Generate Em! is a small tool for automatically creating "good passwords" Generate Em! is a little application which will help you to automatically create "good passwords". A "good password" is a password, that is not a word and contains numbers and letters. The program also copies the new password to the clipboard automatically. Written in Delphi/VB.

Data::Generate allows you to create various types of synthetic data by parsing "regex-like" data creation rules.

This module generates data by parsing given text statements (data creation rules). These statements are flexible and powerful regex-like way to control the production of synthetic data. Think about a program that instead of selecting data which matches a regex filter expression, produces it. For example, from the rule [a-c], the generator would produce the array a,b,c. The module works as following:

Specify data creation rules.
my $generator= Data::Generate::parse(VC(24) [0-9][2-3]);
At this step first you define one kind of output datatype (for ex. VC(24)= "output is a string with max length 24") and then with the rest of the expression define what it should look like. If parsing is successful a Data Generator object is instantiated.

Get data
my $Data= $generator->get_unique_data(10);
To really get the data, users must call the get_unique_data method by indicating the desired number of output values. The generator returns the values contained in an array reference. Please remark that output format is fixed according to the data type.

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.

Generate Monte Carlo Simulation is an AppleScript that will generate a Monte Carlos simulation (as drawing) in OmniGraffle. Works with and requires OmniGraffle 3.0. You may specify parameters like number of path, time steps, size of time step etc.

Generate Style Sheet Report is a QuarkXPress AppleScript that generates a report of all paragraph styles used in frontmost Quark document.

Completly feeware for non-comercial use.

Generate Speakable Time String is a handler for taking the time and generating a string that you can use with the say command to have it speak the time like so: Twelve Thirty Five AM.

Completly freeware for non-commercial use.

Numly assigns electronic serial numbers or Numly Numbers to all things digital. Numly Numbers can be used as proof of copyright or as a digital rights management solution by assigning unique Numly Numbers to copies (licenses) of your digital works.

Numly Numbers are recognized worldwide by electronic publishing companies and electronic content providers. Numly Numbers are simple and quick to generate and serve as branded identifier or copyright for individuals or companies developing electronic content and media.

Whats New in This Release:

· Added several new checkboxes: Mark Private; Include Barcode; Include Rating System.