Free assembled software for linux

B::Assembler is a Perl module created to assemble Perl bytecode.

SYNOPSIS

use B::Assembler qw(newasm endasm assemble);
newasm(&printsub); # sets up for assembly
assemble($buf); # assembles one line
endasm(); # closes down

use B::Assembler qw(assemble_fh);
assemble_fh($fh, &printsub); # assemble everything in $fh

The P65 assemblers are assemblers for the 6502 microprocessor (such as is used in the Commodore 64, Apple II, and Nintendo Entertainment System).
They are designed to be able to support a wide variety of output formats, both to support multiple target platforms and to produce code for emulators.
The eventual goal of P65 is to be as expressive as the more powerful assemblers of the late 80s, such as DASM. Its not there yet, but its getting there.
Main features:
- Highly portable - All versions of P65 are written in portable scripting languages. The original releases were done in Perl. While P65-Perl 1.1 is stable and reasonably powerful, it lacks some major features, such as modules and macros. P65-Ophis, the Python port, will run on slightly fewer architectures, but will still run on all current major systems.
- Flexible output format - P65 allows for very flexible control over data and assemble points. Output file formats are completely independent of the final memory maps.
- Multiple file support - libraries may be kept as seperate files and included seperately, facilitating code reuse.
- Temporary label support - source may contain "anonymous labels" that help decrease namespace pollution. P65-Ophis also supports named temporary labels that only exist within a well-defined scope.
- Assemble-time expressions - P65-Ophis supports High-byte/low-byte computations along with bitmasking and traditional arithmetic operations in code and data statements. Access to the current PC is also supported. P65-Perls expressions are more limited but are generally sufficient.
- Symbol table management - Allows for creating labels and data constants outside of the code, and for allocating RAM symbolically. This includes full support for segments.
- Optimal instruction selection - Compresses as many instructions as possible into zero page format. If this compression permits other instructions to become zero page instructions, it will compress those as well.

Z80-ASM is a compiler/assembler and monitor(including disassembler) for the Z80 CPU. It runs under Linux (probably also under other UNIX-flavours) and DO$ (DJGPP version 2.03 checked). Its written in C and source-code availible!
Each Z80-ASM package contains a compiler for the Z80 assembling language and a monitor including an interactive debugger. Compiler is a two-pass one, which knows all documented Z80 instructions. It has labels, comments and since 2.1 can even evaluate constant arithmetic expressions.
Debugger is interactive, it shows content of all registers, memory, stack, program. You can trace program, trace it step by step, modify program, registers and content of memory, load and save parts of memory.
Installation:
Everything you need to run the Z80-ASM is Linux or DO$ system (it should also work on other Unixes) and GCC/DJGPP compiler.
To install the Z80-ASM you must do following:
- download and unpack the archive
- cd to the just created z80-asm directory
- read the INSTALL file
- according to instructions youve read install the Z80-ASM :) but typically a make will do what you want.

WaveMixer is a multitrack sample editor.
WaveMixer is a multitrack wave editor. It can mix mutliple sound together to make some music.
We want to do an audio software that is simple to use for anyone, and not only by profesionnal users.
Main features:
- Can load many sound format like: wave file, mp3, ogg.
- Show up the file in the sound editor
- You can apply some cool effect on a sample like: fade-in/out, echo, high and low pass filter, ...
- Can save a modified sample to mp3, ogg or wave format
- Can edit Metadata (id3 tag) thanks to TagLib...
- Handles very large file !
- Use esound to write the sound to the sound card
- Zoom in and out on a sample
- Wavemixer got a powerfull file explorer! All is done with dragn drop.
- You can drop files from konqueror or nautilus.
- You can put many samples on the track editor to assemble them and create some very cool music !
- Unimited tracks!
- On each track, you can play with volume and pan
- When playing, a very great Vumeter is drawn to show up the peak volume of the sound/music! Thats cool !
- Wavemixer can save an entire project in xml file for further load...

Class::MakeMethods::Template package contains extensible code templates.

SYNOPSIS

package MyObject;
use Class::MakeMethods::Template::Hash (
new => new,
string => foo,
number => bar,
);

my $obj = MyObject->new( foo => "Foozle", bar => 23 );
print $obj->foo();
$obj->bar(42);

MOTIVATION

If you compare the source code of some of the closure-generating methods provided by other subclasses of Class::MakeMethods, such as the hash accessors provided by the various Standard::* subclasses, you will notice a fair amount of duplication. This module provides a way of assembling common pieces of code to facilitate support the maintenance of much larger libraries of generated methods.

This module extends the Class::MakeMethods framework by providing an abstract superclass for extensible code-templating method generators.
Common types of methods are generalized into template definitions. For example, Template::Generics new provides a template for methods that create object instances, while Template::Generics scalar is a template for methods that allow you to get and set individual scalar values.

Thse definitions are then re-used and modified by various template subclasses. For example, the Template::Hash subclass supports blessed-hash objects, while the Template::Global subclass supports shared data; each of them includes an appropriate version of the scalar accessor template for those object types.

Each template defines one or more behaviors, individual methods which can be installed in a calling package, and interfaces, which select from those behaviours and indicate the names to install the methods under.

Each individual meta-method defined by a calling package requires a method name, and may optionally include other key-value parameters, which can control the operation of some meta-methods.

Safe::World can create multiple virtual instances of a Perl interpreter that can be assembled together.

SYNOPSIS

See USE section for complexer example and the test.pl script.

use Safe::World ;

my $world = Safe::World->new(
stdout => $stdout , ## - redirect STDOUT to this scalar.
stderr => $stderr , ## - redirect STDERR to this scalar.
flush => 1 , ## - output is flushed, soo dont need to wait exit to
## have all the data inside $stdout.
) ;

## Evaluate some code:
$world->eval(q`
use Data::Dumper ;
print Dumper( {a => 1 , b => 2} ) ;
`);

$world->close ; ## ensure that everything is finished and flushed.

die($stderr) if $stderr ;

print $stdout ;

$world = undef ; ## Destroy the world. Here the compartment is cleanned.

Note that in this example, inside the World is loaded Data::Dumper, but Data::Dumper was loaded only inside of it, keeping the outside normal.

ServingXML is a markup language for expressing XML pipelines, and an extensible Java framework for defining the elements of the language.
ServingXML currently comes with a console app, and also documents an API for imbedding the software in a standard Java or J2EE application.
ServingXML supports reading content as XML files, flat files, SQL queries or dynamically generated SAX events, transforming it with XSLT stylesheets and custom SAX filters, and writing it as XML, HTML, PDF or mail attachments.
This software is especially suited for converting flat file or database records to XML, with its support for namespaces, variant record types, multi-valued fields, segments and repeating groups, hierarchical grouping of records, and record-by-record validation with XML Schema.
ServingXML works as an "inversion of control" container for assembling components from a variety of projects - Apache FOP, Sun MSV and others - and making them work together to process records and XML.
Main features:
- Convert flat files to XML and vice versa.
- Convert database records to XML and vice versa.
- Convert flat files from one layout to another.
- Transform and validate XML with SAX filters, XSLT stylesheets, and schema validation.
Enhancements:
- This release fixes a number of minor bugs and also provides better error messages with more context.

Transcend Game project is a retro-style, abstract, collage-building, musical, shooter game.
The graphics are geometrical, and the pace is sometimes frenzied. Two features set Transcend apart from other games.
First, its dynamic graphical engine, which can smoothly morph from one complex shape to another in realtime, produces striking displays.
Combining these dynamic shapes with subtle randomizations ensures that each new play through a level is visually different from the last.
The second novel feature is the musical power-up system.
As you play through a level, you are simultaneously assembling an abstract visual collage and arranging a unique piece of music.
Enhancements:
- Fixed bugs that caused post-explosion fade factors to become negative, which in turn caused boss explosions to linger on some platforms.
- Fixed zoom behavior when strafing.
- Added fade-in when enemies are created to avoid a visual pop-in.
- Added smooth turning when enemies switch targets.
- Changed so that pieces can be picked up while they are moving as a result of enemy fire. This makes pick up less confusing and frustrating.
- Made bullet fade-out smoothly at end of range to avoid visual pop.
- Doubled piece pick-up radius to make picking up pieces easier.
- Fixed jerky piece pick-up and drop.
- Added mini-explosion graphics to indicate when damage is being done to boss. These graphics also change color to indicate the boss health.