Free cm software for linux

cm Compilation Manager is a new tool for build automation and compilation management. cm Compilation Manager addresses a number of shortcomings I see in make.
Main features:
- A clean syntax based on a context-free language description
- Whitespace insensitivity
- Distinct macros and variables
- Separate procedure and production namespaces
- Many native programming constructs such as foreach loops for easy iteration, and more powerful tools such as anonymous functions with static scoping.
- Built-in support for recursive directory handling without additional invocations of cm.
- An intelligent, automatic configuration file generator
- Pre-generated functions for handling common build tasks in a platform-independent manner
- Support for multiple build configurations and multi-pass builds over complicated directory hierarchies
Installation instructions:
Download cm, classib, and gc.
Install the garbage collector per the included instructions. (Basically ./configure; make; sudo make install.) When running configure, you will need to pass it the parameters: --prefix=/usr/lib --with-threads=posix.
Unzip classlib (tar vzxf classlib.tar.gz).
Configure classlibs Makefile with any paths you need to modify.
Build and install classlib with make && sudo make install.
Unzip cm (tar vzxf cm.tar.gz).
Build and install cm with make && sudo make install.
Configure cm by executing: cd /usr/local/etc && sudo cminit
To verify your cm installation, you can rebuild it with the included Cmrules files by typing cm @clean && cm -m opt in the same directory you built cm in with make.
Enhancements:
- The license was changed to the GPL.
- This release includes a dynamic module/plugin system and two initial plugin modules.
- It supports non-root installation, additional command line options, and caches parsed files for quick retrieval during multi-pass builds.
- Several bugfixes are also included.

VCS::CMSynergy::Changes is a list of changes to VCS::CMSynergy.

This module is a Perl interface to CM Synergy (formerly known as Continuus CM), a change and configuration management system from Telelogic AB (http://www.telelogic.com). It is implemented on top of the CM Synergy CLI, hence you must have the command client ("ccm")
installed to use it.

Class::Meta is a Perl class automation, introspection, and data validation.

SYNOPSIS

Generate a class:
package MyApp::Thingy;
use strict;
use Class::Meta;
use Class::Meta::Types::String;
use Class::Meta::Types::Numeric;

BEGIN {

# Create a Class::Meta object for this class.
my $cm = Class::Meta->new( key => thingy );

# Add a constructor.
$cm->add_constructor(
name => new,
create => 1,
);

# Add a couple of attributes with generated methods.
$cm->add_attribute(
name => uuid,
authz => Class::Meta::READ,
type => string,
required => 1,
default => sub { Data::UUID->new->create_str },
);
$cm->add_attribute(
name => name,
is => string,
required => 1,
default => undef,
);
$cm->add_attribute(
name => age,
is => integer,
default => undef,
);

# Add a custom method.
$cm->add_method(
name => chk_pass,
view => Class::Meta::PUBLIC,
);
$cm->build;
}
Then use the class:
use MyApp::Thingy;

my $thingy = MyApp::Thingy->new;
print "ID: ", $thingy->id, $/;
$thingy->name(Larry);
print "Name: ", $thingy->name, $/;
$thingy->age(42);
print "Age: ", $thingy->age, $/;
Or make use of the introspection API:
use MyApp::Thingy;

my $class = MyApp::Thingy->my_class;
my $thingy;

print "Examining object of class ", $class->package, $/;

print "nConstructors:n";
for my $ctor ($class->constructors) {
print " o ", $ctor->name, $/;
$thingy = $ctor->call($class->package);
}

print "nAttributes:n";
for my $attr ($class->attributes) {
print " o ", $attr->name, " => ", $attr->get($thingy), $/;
if ($attr->authz >= Class::Meta::SET && $attr->type eq string) {
$attr->get($thingy, hey there!);
print " Changed to: ", $attr->get($thingy), $/;
}
}

print "nMethods:n";
for my $meth ($class->methods) {
print " o ", $meth->name, $/;
$meth->call($thingy);
}

Class::Meta provides an interface for automating the creation of Perl classes with attribute data type validation. It differs from other such modules in that it includes an introspection API that can be used as a unified interface for all Class::Meta-generated classes. In this sense, it is an implementation of the "Facade" design pattern.

SCLive is a complete Linux-based SystemC Development Environment, which boots directly off a CD or USB memory stick, allowing you to use SystemC without having to install any software.
The SystemC Live-CD is under 128MB and can be burned to a CD, mini-CD (8 cm) or a USB key. You can boot your machine off the CD or key and have a great SystemC based Linux distribution, for free and without commitment.
The LiveCD contains a complete Linux-based SystemC development environment, including:-
- OCSI SystemC 2.1 Simulator Kernel
- XFCE4 windows manager
- Firefox Internet browser
- GNU C and C++ compilers
- xffm File manager
- Geany Development environment
- GTKWave Waveforms Viewer
- GDB Debugger
- SystemC Tutorials
This distribution is developed by Esperan (www.esperan.com) and maintained at: sclive.blogsite.org
Enhancements:
This new release features the latest SystemC 2.2 library / simulation kernel, The SCV 1.0 library, the TLM 1.0 library all integrated.
In addition, a few programs have been added to the previous version:
- gdb: command line debugger
- ddd: graphical debugger
- vim: powerful editor
- xpdf: pdf viewer
- slapt-get and gslapt: package management

Class::Meta::Express is a Perl module for concise, expressive creation of Class::Meta classes.

Synopsis

package My::Contact;
use Class::Meta::Express;

class {
meta contact => ( default_type => string );
has name;
has contact => ( required => 1 );
}

This module provides an interface to concisely yet expressively create classes with Class::Meta. Although I am of course fond of Class::Meta, Ive never been overly thrilled with its interface for creating classes:

package My::Thingy;
use Class::Meta;

BEGIN {
# Create a Class::Meta object for this class.
my $cm = Class::Meta->new( key => thingy );

# Add a constructor.
$cm->add_constructor( name => new );

# Add a couple of attributes with generated accessors.
$cm->add_attribute(
name => id,
is => integer,
required => 1,
);

$cm->add_attribute(
name => name,
is => string,
required => 1,
);

$cm->add_attribute(
name => age,
is => integer,
);

# Add a custom method.
$cm->add_method(
name => chk_pass,
code => sub { return code },
);
$cm->build;
}

This example is relatively simple; it can get a lot more verbose. But even still, all of the method calls were annoying. I mean, whoever thought of using an object oriented interface for declaring a class? (Oh yeah: I did.) I wasnt alone in wanting a more declarative interface; Curtis Poe, with my blessing, created Class::Meta::Declare, which would use this syntax to create the same class:

package My::Thingy;
use Class::Meta::Declare :all;

Class::Meta::Declare->new(
# Create a Class::Meta object for this class.
meta => [
key => thingy,
],
# Add a constructor.
constructors => [
new => { }
],
# Add a couple of attributes with generated accessors.
attributes => [
id => {
type => $TYPE_INTEGER,
required => 1,
},
name => {
required => 1,
type => $TYPE_STRING,
},
age => { type => $TYPE_INTEGER, },
],
# Add a custom method.
methods => [
chk_pass => {
code => sub { return code },
}
]
);

This approach has the advantage of being a bit more concise, and it is declarative, but I find all of the indentation levels annoying; its hard for me to figure out where I am, especially if I have to define a lot of attributes. And finally, everything is a string with this syntax, except for those ugly read-only scalars such as $TYPE_INTEGER. So I cant easily tell where one attribute ends and the next one starts. Bleh.

Continuus is a Perl interface to Continuus CM.

SYNOPSIS

use Continuus;

Check out a file:

use Continuus;

$ccm = new Continuus;

$ccm->start(database => /proj/Continuus4/rig,
host => stoxserv01);

$ccm->checkOut(file => main.c,
version => 2);

$ccm->stop();

METHODS

new:

The new method creates a new Continuus object.
start:
The start method starts a new Continuus session.

Parameters:

database: Database to open.

host: Hostname to start the engine on.

iniFile: Ini file to read.

Example:

$ccm->start(database => "/proj/Continuus0/rig/", host => "stoccm01");
command:
The command method acts as a interface to all other Continuus functions
not implemented in the Continuus module.

Parameters:

command: The command to be executed by Continuus

Example:

$ccm->command(status);
stop:
The stop command quits the current Continuus session.

Parameters:

None.
query:
The query command is a interface to the Continuus query command.

Parameters:

query: The query string
flags: Flags to pass to Continuus.
Format: Formatting options.

Example:

$ccm->query(query => "status=released", flags => "-u", format => "%objectname");
checkOut:
Checks out a file.

Parameters:

file: The file to check out.
version: The version to set on the new file.

Example:

$ccm->checkOut(file => "main.c", version => "1.1");
checkIn:
Checks in a file.

Parameters:

file: The file to check out.
comment: The comment to set on the new file.

Example:

$ccm->checkIn(file => "main.c", comment => "Created");
reconfigure:
Reconfigure command

Parameters:

project: The project to reconfigure.
parameters: Other parameters to pass to the reconfigure command.

Example:

$ccm->checkOut(file => "main.c", version => "1.1");
debugOn:
Sets the debugging information on.
debugOff:
Sets the debugging information off.

SLAX is a small bootable CD containing the Linux operating system. SLAX distirbution runs Linux directly from the CD (or USB) without installing.
The Live CD described here is based on the Slackware Linux distribution and is downloadable from this website as an ISO image.
The primary goal of SLAX is to provide a wide collection of useful software while keeping the cds image small enough to be written to a 185 MB CD-R(W) medium (small 8 cm CD). SLAX boots directly from the CD or USB devices and it provides a full featured Linux operating system.
All your available partitions and data storage devices (CD-ROM, USB storage devices, etc.) should be recognized at boot and should be mounted to /mnt/xx. As an example, "disc0part1" may be assigned to the first partition on your primary hard drive, "disc1part1" for your USB storage device, or "cdrom0" for your CD-ROM drive. SLAX will never write anything to the mounted devices. Mounting is safe and does not change the data.
After booting, you should be able to login as a "root", with the password "toor"; both without quotes, of course.
When logged in, you have many options. At the shell prompt, you may start Midnight Commander (type "mc" to the console), play some music from your hard drive (type "play /mnt/path/file.mp3"), adjust your audio volume (type "alsamixer"), configure IP address (type "netconfig") or browse web pages with the text-based browser (type "lynx http://url").
To start the graphical environment included with SLAX, type "gui" (for graphical user interface). It will attempt to autoconfigure your graphics card, monitor, keyboard and mice, and if successful it will run an X session with KDE. Im pretty sure that you will know how to get around at this point. :-) Use "guisafe" instead of "gui" for safe-mode (VESA framebuffer) without autodetection.
In the unfortunate case your mouse doesnt work, try to move it for a few seconds to see if it will be autodetected. If it isnt, shut down Xwindow (press Ctrl+Alt+Backspace) and start it again. If this wont help then you are using something I have not included in the autoconfiguration process (COM2 mouse?). If you are comfortable with bash, or you atleast understand how to make your favorite mouse function under Linux, try to modify the symbolic link /dev/mouse manually.
If you dont like the autoconfigured screen resolution, refresh rate, or the K Desktop Environment, start "gui" with some additional options. Try for example "gui 800x600 60", where 800x600 is the desired screen resolution and 60 is the desired refresh rate. Fluxbox is one of the other window managers included and may be called with "guifast" or "gui fluxbox". In any event, type "gui --help" for more information.
All scripts and source code are available and can be used to build your own Live CD.
SLAX is available as an ISO image of the CD. It fits on small 8cm CD-R(W). Burn it with your favorite cd-writing software and then boot from the CD.
You might want to check your BIOS to assure its set to boot the CD prior the disc.
SLAX CD contains:
- Linux Kernel 2.4.28-pre4 with SATA support
- X.org 6.8.1
- KDE 3.3.1
- KOffice 1.3.3
- KDE games
- MPlayer 1.0pre5 with KPlayer
- kopete ICQ/AIM/Y!/IRC
- midnight commander
- rdesktop (rscp in KDE)
- hotplug support
- cdrtools
- k3b burning GUI for KDE
- mutt email client
- wget
- and much more...