Free macro software for linux

Ooo-macro is a toolkit for OpenOffice.org or StarOffice including macros written in StarBasic, associated shortcuts, the template SPECIAL.stw, and the Perl script.
It is a complete kit of macros and shortcuts for everyday usage of StarWriter and OpenOffice.org Writer. (English version.)
Enhancements:
- This release includes a shell script and a Midnight Commander plug-in for fast dumping and viewing of the contents of OpenOffice.org 2.x ODT and ODS files and version 1.x SXW and SXC files.

HTML::Macro can process HTML templates with loops, conditionals, macros and more!

SYNOPSIS

use HTML::Macro;
$htm = new HTML::Macro (template.html);
$htm->print;

sub myfunc {
$htm->declare (var, missing);
$htm->set (var, value);
return $htm->process;
}

( in template.html ):

< html >< body >
< eval expr="&myfunc" >
< if def="missing" >
Message about missing stuff...
< else / >
Vars value is #var#.
< /if >
< /eval >
< /body >< /html >

HTML::Macro is a module to be used behind a web server (in CGI scripts). It provides a convenient mechanism for generating HTML pages by combining "dynamic" data derived from a database or other computation with HTML templates that represent fixed or "static" content of a page.

There are many different ways to accomplish what HTML::Macro does, including ASP, embedded perl, CFML, etc, etc. The motivation behind HTML::Macro is to keep everything that a graphic designer wants to play with *in a single HTML template*, and to keep as much as possible of what a perl programmer wants to play with *in a perl file*. Our thinking is that there are two basically dissimilar tasks involved in producing a dynamic web page: graphic design and programming. Even if one person is responsible for both tasks, it is useful to separate them in order to aid clear thinking and organized work. I guess you could say the main motivation for this separation is to make it easier for emacs (and other text processors, including humans) to parse your files: its yucky to have a lot of HTML in a string in your perl file, and its yucky to have perl embedded in a special tag in an HTML file.

HTML::Macro began with some simple programming constructs: macro expansions, include files, conditionals, loops and block quotes. Since then weve added very little: only a define tag to allow setting values and an eval tag to allow perl function calls in a nested macro scope. Our creed is "less is more, more or less."

HTML::Macro variables will look familiar to C preprocessor users or especially to Cold Fusion people. They are always surrounded with single or double hash marks: "#" or "##". Variables surrounded by double hash marks are subject to html entity encoding; variables with single hash marks are substituted "as is" (like single quotes in perl or UNIX shells). Conditionals are denoted by the and tags, and loops by the tag. Quoting used to be done using a tag, but we now deprecate that in favor of the more familiar CFML quoting syntax: < !--- --- >.

mod_macro is a third-party module to the Apache Http Server, distributed with a BSD-style license like Apache.

mod_macro allows the definition and use of macros within apache runtime configuration files. The syntax is a natural extension to apache html-like configuration style.

Examples

Here is a sample use of mod_macro within a configuration file:
## Define a VHost Macro.

< Macro VHost $host $port $dir >
Listen $port
< VirtualHost $host:$port >

DocumentRoot $dir

< Directory $dir >
# do something here...
< /Directory >

# limit access to intranet subdir.
< Directory $dir/intranet >
order deny,allow
deny from all
allow from 10.0.0.0/8
< /Directory >
< /VirtualHost >
< /Macro >

## Use of VHost with different arguments.

Use VHost www.apache.org 80 /projects/apache/web
Use VHost www.perl.com 8080 /projects/perl/web
Use VHost www.ensmp.fr 1234 /projects/mines/web

## Done.

Text::MacroScript is a macro pre-processor with embedded perl capability.

SYNOPSIS

use Text::MacroScript ;

# new() for macro processing

my $Macro = Text::MacroScript->new ;
while( ) {
print $Macro->expand( $_ ) if $_ ;
}

# Canonical use (the filename improves error messages):
my $Macro = Text::MacroScript->new ;
while( ) {
print $Macro->expand( $_, $ARGV ) if $_ ;
}

# new() for embedded macro processing

my $Macro = Text::MacroScript->new( -embedded => 1 ) ;
# Delimiters default to
# or
my $Macro = Text::MacroScript->new( -opendelim => [[, -closedelim => ]] ) ;
while( ) {
print $Macro->expand_delimited( $_, $ARGV ) if $_ ;
}

# Create a macro object and create initial macros/scripts from the file(s)
# given:
my $Macro = Text::MacroScript->new(
-file => [ local.macro, ~/.macro/global.macro ]
) ;

# Create a macro object and create initial macros/scripts from the
# definition(s) given:
my $Macro = Text::MacroScript->new(
-macro => [
[ MAX_INT => 32767 ],
],
-script => [
[ DHM2S =>
[
my $s = (#0*24*60*60)+(#1*60*60)+(#2*60) ;
"#0 days, #1 hrs, #2 mins = $s secs"
],
],
-variable => [ *MARKER* => 0 ],
) ;

# We may of course use any combination of the options.

my $Macro = Text::MacroScript->new( -comment => 1 ) ; # Create the %%[] macro.

# define()

$Macro->define( -macro, $macroname, $macrobody ) ;

$Macro->define( -script, $scriptname, $scriptbody ) ;

$Macro->define( -variable, $variablename, $variablebody ) ;

# undefine()

$Macro->undefine( -macro, $macroname ) ;

$Macro->undefine( -script, $scriptname ) ;

$Macro->undefine( -variable, $variablename ) ;

# undefine_all()

$Macro->undefine( -macro ) ;

$Macro->undefine( -script ) ;

$Macro->undefine( -variable ) ;

# list()

@macros = $Macro->list( -macro ) ;
@macros = $Macro->list( -macro, -namesonly ) ;

@scripts = $Macro->list( -script ) ;
@scripts = $Macro->list( -script, -namesonly ) ;

@variables = $Macro->list( -variable ) ;
@variables = $Macro->list( -variable, -namesonly ) ;

# load_file() - always treats the contents as within delimiters if we are
# doing embedded processing.

$Macro->load_file( $filename ) ;

# expand_file() - calls expand_embedded() if we are doing embedded
# processing otherwise calls expand().

$Macro->expand_file( $filename ) ;
@expanded = $Macro->expand_file( $filename ) ;


# expand()

$expanded = $Macro->expand( $unexpanded ) ;
$expanded = $Macro->expand( $unexpanded, $filename ) ;

# expand_embedded()

$expanded = $Macro->expand_embedded( $unexpanded ) ;
$expanded = $Macro->expand_embedded( $unexpanded, $filename ) ;

This bundle also includes the macro and macrodir scripts which allows us to expand macros without having to use/understand Text::MacroScript.pm, although you will have to learn the handful of macro commands available and which are documented here and in macro. macro provides more documentation on the embedded approach.

The macroutil.pl library supplied provides some functions which you may choose to use in HTML work for example.

AML Cartography provides AML and C code and documentation for cartography within the ARC/INFO geographic information system.

The ARC Macro Language and C programs discussed in this guideline are available by anonymous ftp from sdcdg01.sdc.epa.gov and are in the files:

/pub/readme.cart
/pub/map_amls.tar.Z
/pub/map_design.tar.Z
/pub/map_post.Z
/pub/color_post.tar.Z
/pub/baw_post.tar.Z

cdp-tools is a software that provides tools to work with the Cisco Discovery Protocol (CDP).
They were written because of a particular hosting center that insisted on learning routes using CDP, and thusly required Cisco Switches for doing their dirty work.
cdp-listen/cdp-routemgr are proof-of-concepts that may be useful if you want to implement a similarly brain-damaged proposal.
cdp-send is a must-have tool if you are in that situation. It can pretend to be just about any kind of Cisco hardware you can imagine.
The source is a bit difficult to follow as a requirement was that it build under both the ancient libnet and the new libnet code. hence, much nasty macro-ing.
Enhancements:
- DESCRIPTION, README: More docs...

Exact Build project is a sane GNU Auto replacement. For portable build systems nowadays normally GNU autoconf and the associated companiens such as automake and libtool. However albeit portable they are rather crufty to use. The various macro expansion and generation steps extremely blow up the initial definitions and make execution slow and debugging a nightmare.

Even with the enourmous code bloat, it does not have a wide feature set and neither allows to maximize the gain of parallel builds nor other state-of-the-art compiler features. Manual tinkering is needed in such cases.

Mostly due the code bloat but also to obtain features such as mximal parallel build and object output seperated cleanly from the source, we create our own set of Makefiles for the non-recursive build system and shell scripts for configuration, if required by the software module (some straight forware code does come without a configure script at all).

Parrot::OpTrans is a Perl module that can transform Ops to C Code.

Parrot::OpTrans is the abstract superclass for the Parrot op to C transforms. Each transform contains various bits of information needed to generate the C code, and creates a different type of run loop. The methods defined here supply various default values and behaviour common to all transforms.

The subclass hierarchy is as follows:

OpTrans
|_________________________
| | |
C CGoto Compiled
| |
CPrederef |
| | |
| |_________|
| |
CSwitch CGP

Class Methods

new()

Returns a new instance.

Instance Methods

prefix()

Returns the default Parrot_ prefix.

Used by Parrot::Ops func_name() to individuate op function names.

suffix()

Implemented in subclasses to return a suffix with which to individuate variable names. This default implementation returns an empty string.

defines()

Implemented in subclasses to return the C #define macros required.

opsarraytype()

Returns the type for the array of opcodes. By default here its an array opcode_t, but the prederef runops core uses an array of void* to do its clever tricks.

core_type()

Implemented in subclasses to return the type of core created by the transform. This default implementation raises an exception indicating that the core type is missing. See the Parrot_Run_core_t enum in include/parrot/interpreter.h for a list of the core types.

core_prefix()

Implemented in subclasses to return a short prefix indicating the core type used to individuate core function names.

run_core_func_decl($base)

Optionally implemented in subclasses to return the C code for the run core function declaration. $base is the name of the main ops file minus the .ops extension.

ops_addr_decl($base_suffix)

Optionally implemented in subclasses to return the C code for the ops address declaration. $base_suffix is the name of the main ops file minus the .ops extension with suffix() and an underscore appended.

run_core_func_decl($base)

Optionally implemented in subclasses to return the C code for the run core function declaration. $base is the same as for run_core_func_decl().

run_core_func_start()

Implemented in subclasses, if run_core_func_decl() is implemented, to return the C code prior to the run core function.

run_core_after_addr_table($base_suffix)

Optionally implemented in subclasses to return the run core C code for section after the address table. $base_suffix is the same as for ops_addr_decl().

run_core_finish($base)

Implemented in subclasses to return the C code following the run core function. $base is the same as for run_core_func_decl().

init_func_init1($base)

Optionally implemented in subclasses to return the C code for the cores init function. $base is the same as for run_core_func_decl().

init_set_dispatch($base_suffix)

Optionally implemented in subclasses to return the C code for initializing the dispatch mechanism within the cores init function. $base_suffix is the same as for ops_addr_decl().

Macro Substitutions

The following methods are called by Parrot::OpFile to perform ops file macro substitutions.

access_arg($type, $value, $op)

Implemented in subclasses to return the C code for the specified op argument type and value. $op is an instance of Parrot::Op.

gen_goto($where)

The various goto_X methods below call this method with the return value of an expr_X method (implemented in subclass).

restart_address($address)

Implemented in subclasses to return the C code for restart ADDRESS($address).

restart_offset($offset)

Implemented in subclasses to return the C code for restart OFFSET($offset).

goto_address($address)

Transforms the goto ADDRESS($address) macro in an ops file into the relevant C code.

goto_offset($offset)

Transforms the goto OFFSET($offset) macro in an ops file into the relevant C code.

goto_pop()

Transforms the goto POP($address) macro in an ops file into the relevant C code.

expr_offset($offset)

Implemented in subclasses to return the C code for OFFSET($offset). Called by goto_offset().

expr_address($address)

Implemented in subclasses to return the C code for ADDRESS($address). Called by goto_address().