Free dream moods software for linux

DREAM Tool is a generic framework that aims at providing a common semantic domain which can express several (real-time, power consumption, resource) constraints.
The semantic domain has an executable C++ model which has been semantically anchored to the hybrid automata formalism. Although the model of computation corresponds to hybrid automata, so far we have been successful in analyzing the models by conservative approximation using timed automata on moderate size systems.
To deal with large-scale examples the user has the ability to use the simulation/testing interface on the executable C++ model before implementing the system. We plan to extend the genetic algorithms to solve a large number of problems.
DREAM is a simulation and verification framework which provides a formal model and analysis of your system in less than a day. Systems in DREAM are specified using XML in a straightforward way. I hope you find it useful.
Real-time middleware provides dependable and efficient platforms supporting key functional and quality of service (QoS) needs of distributed real-time embedded (DRE) systems.
Key challenges in DRE system developments include safe composition of system components and mapping the functional specifications onto the target platform. Model-based technologies help address these issues by enabling design-time analysis and providing the means for the rapid evaluation of design alternatives with respect to end-to-end QoS properties, predictability and performance measures before committing to a specific platform.
The Distributed Real-time Embedded Analysis Method DREAM is an open-source tool and method for optimizing multiple quality of service (QoS) properties of distributed real-time embedded (DRE) systems. The project focuses on the practical application of formal analysis methods to real-time middleware to automate the verification, development, configuration, and integration of middleware-based DRE systems.
Enhancements:
- This version implemented several optimizations for improved model checking performance, resulting in impressive performance gains of at least 2-3 times.
- There are no known memory leaks present in the current release.
- Balanced AVL trees are now used, resulting in exponential speedups in several steps of the model checking method.
- XML Schema validation was implemented.
- Verification time reporting was upgraded to include data on the simulation speeds.
- Random simulation-based testing now provides an execution trace when a deadline is missed.

Digital Radio Mondiale, also known as DRM, is a new digital radio standard for the long-, medium- and short-wave ranges.

The standard was formed by a consortium in co-operation with the International Telecommunication Union (ITU). The new system offers the radio stations and new service providers access to the multimedia age with small bit rates for large target areas and long distances.

The bandwidth of a DRM bandpass signal is less than 20 kHz and the number of carriers used in the OFDM-modulation is relatively small (max. 460). These features motivate a real-time software implementation of a DRM-receiver on a conventional personal computer (PC) using the sound card as the input and output device. A long, medium and short wave front-end with an intermediate frequency (IF) between 5 kHz and 15 kHz is used to receive the DRM signal.

Any commercial front-end with an IF of 455 kHz should be usable by adding a 455 kHz to 12 kHz adaptor (assumed the receiver bandwidth is sufficient for a DRM signal).

With this software project we intend to implement a working software receiver with, at least, the basic features. Since this project is created at a university and the fundamental idea of such an institution is to teach and stimulate the creativity, this source-code is free under the GNU-General Public License (GPL).

Dream is a development project which uses the open source model to improve DRM technology. The main aim of this project is to implement and test new research results on an existing system, whereby the synchronization and channel estimation is of special interest.

The programming-language is C++. The code runs under Microsoft Windows and Linux. Start of the project was June 2001.

Although this software is going to be distributed as free software under the terms of the GPL this does not mean that its use is free of rights of others. The use may infringe third party IP and thus may not be legal in some countries.

The intended audience of the Dream software are people who are interested in how to decode a DRM stream and want to learn from the algorithms used in this software and people who want to help us improving the performance of the receiver and the source code.

Zeta is the name of a virtual platform, or "architecture". You can find the specifications in the released source.
On top of those specifications, an emulator has been developed under linux. Its a direct implementation of the specs.
Zetas purpose is to boot/use linux on this new target. Hence, the GNU binutils and the GNU gcc have been ported to zeta. Using those tools (as "cross-compilers"), the real work can now begin : porting linux to zeta. This is still work in progress. This kernel is called ZetaLinux.
Porting linux to a new platform has always been one of my dreams. Nowadays (19/12/2000), almost all the platforms I can think of already run linux (or will soon).
As I dont have time to look for specs and/or be really useful for any port being done, Ive decided to create my own virtual platform to port linux to. This way, Ill be able to learn linux kernel internals without bothering any other project.
Enhancements:
- The kernel used is 2.6.22. gcc was updated to 4.1.2.
- A new handbook was added.
- The usual minor fixes were made.

PETALS is an ObjectWeb Java Business Integration (JBI) platform. PETALS provides lightweight and packaged integration solutions, based on JSR-208 specifications, with a high focus on distribution and clustering.
PETALS is part of ObjectWeb ESB initiative, and was launched in June 2005 by EBM WebSourcing and Fossil E-Commerce.
The project leverages ObjectWeb architecture and projects like Fractal, JORAM, JOnAS to provide a JBI container with a focus on :
- JBI specification conformance
- Integrate JBI in JOnAS
- Multi JVM, distributed and clustered platform for JBI components with native transport based on existing ObjectWeb middleware : JORAM and Dream
- Propose packaged solutions for process orchestration (with focus on BPEL engine, Transformation engine, Web Services and JMS binding components) and B2B integration (with focus on Transformation and B2B bindng components like EDI, ...)
Enhancements:
- This release contains all the PETALS elements that are useful for integration solutions.
- New features include static definition of the distributed environment (avoiding multicast auto-discovering), an improvement to the Web Administrative console, IBM JVM compatibility, and more Binding components.

Excalibur: Morganas Revenge (EMR) is a unique scenario based upon the Aleph One (Marathon) engine. It is a first-person action adventure game, featuring an epic and in-depth story line. As a Federation Marine resting after your last mission, you start aboard the exploration class Starship Kronos where you learn that your real mission has yet to begin. You are re-acquainted with the AI Merlin, who introduces you to Kronos time traveling technology, and reveals your new mission: to save mankind from the clutches of Morgana and her minions. Through untamed raptor-infested jungles, castle arenas, and war-torn streets of the future, you will wield weapons from all time periods - including the Sword of Power, Excalibur - in an effort to thwart the diabolical plot that unfolds. The EMR adventure, spread across 42 solo levels, weaves a tale of truth and honor, knighthood and bravery, and darkness and treachery. EMR also delivers 27 adrenaline pumped network levels. EMR immerses you in an amazing new world, creating an addictive, fun and unique gaming experience.

For those that played EMR under the old Marathon Infinity engine, EMR 3.0 brings exciting new maps, new high resolution textures and landscapes, a completely new set of weapons, new monsters and friends, new scenery, new 16-bit sounds, original music, and a carefully woven original story line that transcends time. Using the Aleph One engine, EMR now sports loads of new special features using Aleph Ones MML and Lua scripting languages. Please note that the AlephOne engine is old technology improved. Architecture is still simulated 3D, so there are no ramps, bridges, and balconies, nor horizontal doors. The sprites in EMR are made up of 2D images posed in different views, not 3D models. Do not expect the latest state-of-the-art graphics engine, but you can expect an intriguing storyline, creative map architectures, engaging graphics, original spellbinding music, and mood-setting sound effects.

Whats New in This Release:

• Levels with fog and mist
  
• Persistent effects such as poison, earthquakes, fire storm spell, and timed grenades
  
• Original MP3 music
  
• 12 unique weapons, including a new Dragon Flamer and T9000 Railgun
  
• New spells for your wand, including fire storm, teleportation, and raise the
  dead
  
• Beautifully rendered OpenGL textures and landscapes
  
• New graphics for Morgana, the Trex, raven, and Jurassic bug
  
• A huge variety of new hi-res scenery items
  
• New holodeck programs, including driving a Flintstone mobile through Bedrock!
  
• Blood Gulch style net map with 8 simulated net players and a huge battlefield
  
• A basketball court netmap where grenades in a basket win points for your team
  
• A beautiful new future level that lets you drive a Hoverbike!
  
• A total of 5 brand new solo maps and 4 new net maps
  
• Lots of updated maps with new areas, new tasks, new features, and new secrets
  
• New powerups, such as apples, bananas, health kits, emergency kits, and finally
  a use for all those magic scrolls!
  
• And much, much, more...
  

B::Graph is a Perl compiler backend to produce graphs of OP trees.

SYNOPSIS

perl -MO=Graph,-text prog.pl >graph.txt

perl -MO=Graph,-vcg prog.pl >graph.vcg
xvcg graph.vcg

perl -MO=Graph,-dot prog.pl | dot -Tps >graph.ps

This module is a backend to the perl compiler (B::*) which, instead of outputting bytecode or C based on perls compiled version of a program, writes descriptions in graph-description languages specifying graphs that show the programs structure. It currently generates descriptions for the VCG tool (http://www.cs.uni-sb.de/RW/users/sander/html/gsvcg1.html) and Dot (part of the graph visualization toolkit from AT&T: http://www.research.att.com/sw/tools/graphviz/). It also can produce plain text output (which is more useful for debugging the module itself than anything else, though you might be able to make cut the nodes out and make a mobile or something similar).

OPTIONS

Like any other compiler backend, this module needs to be invoked using the O module to run correctly:

perl -MO=Graph,-opt,-opt,-opt program.pl
OR
perl -MO=Graph,-opt,obj -e BEGIN {$obj = ["hi"]}; print $obj
OR EVEN
perl -e use O qw(Graph -opt obj obj); print "hi!n";

Obj is the name of a perl variable whose contents will be examined. It cant be a my() variable, and it shouldnt have a prefix symbol ($@^*), though you can specify a package -- the name will be used to look up a GV, whose various fields will lead to the scalar, array, and other values that correspond to the named variable. If no object is specified, the whole main program, including the CV that points to its pad, will be displayed.

Each of the the opts can come from one of the following (each set is mutually exclusive; case and underscores are insignificant):

-text, -vcg, -dot

Produce output of the appropriate type. The default is -text, which isnt useful for much of anything (it does draw some nice ASCII boxes, though).

-addrs, -no_addrs

Each of the nodes on the graph produced corresponds to a C structure that has an address and includes pointers to other structures. The module uses these addresses to decide how to draw edges, but it makes the graph more compact if they arent printed. The default is -no_addrs.

-compile_order, -run_order

The collection of OPs that perl compiles a script into has two different layers of structure. It has a tree structure which corresponds roughly to the synactic nesting of constructs in the source text, and a roughly linked-list representation, essentially a postorder traversal of this tree, which is used at runtime to decide what to do next. The graph can be drawn to emphasize one structure or the other. The former, compile_order, is the default, as it tends to lead to graphs with aspect ratios close to those of standard paper.

-SVs, -no_SVs

If OPs represent a programs compiled code, SVs represent its data. This includes literal numbers and strings (IVs, NVs, PVs, PVIVs, and PVNVs), regular arrays, hashes, and references (AVs, HVs, and RVs), but also the structures that correspond to individual variables (special HVs for symbol tables and GVs to represent values within them, and special AVs that hold my() variables (as well as compiler temporaries)), structures that keep track of code (CVs), and a variety of others. The default is to display all these too, to give a complete picture, but if you arent in a holistic mood, you can make them disappear.

-ellipses, -rhombs

The module tries to give the nodes representing SVs a different shape from those of OPs. OPs are usually rectangular, so two obvious shapes for SVs are ellipses and rhombuses (stretched diamonds). This option currently only makes a difference for VCG (ellipse is the default).

-stashes, -no_stashes

The hashes that perl uses to represent symbol tables are called stashes. Since every GV has a pointer back to its stash, its virtually inevitable for the links in a graph to lead to the main stash. Unfortunately stashes, especially the main one, can be quite big, and lead to forests of other structures -- theres one GV and another SV for each magic variable, plus all of @INC and %ENV, and so on. To prevent information overload, then, the display of stashes is disabled by default.

-fileGVs, -no_fileGVs

Another kind graph element that can be annoying are the pointers from every GV and COP (a kind of OP that occurs for every statement) to the GV that represents the file from which that code came (used for error messages). By default, these links arent shown, to keep them from cluttering the graph. Also, perls internal interfaces changed in a recent version, so in perl 5.005_63 or later you cant see the fileGVs at all.

-SEQs, -no_SEQs

As it is visited in the peephole optimization phase, each OP gets a sequence number, which is currently used by anything (except the peephole optimizer, to avoid visiting OPs twice). If you want to see these, ask for them. (COPs have their own sequence numbers too, but theyre more interesting to look at -- for instance, theyre used to bound the lifetimes of lexicals).

-types, -no_types

B::Graph always gives the type of each OP symbolically (entersub), but it can also print the numeric value of the type field, if you want. The default is no_types.

-float, -no_float

Almost every OP has an op_next and an op_sibling pointer, and B::Graph colors them distinctively (pink and light blue, respectively). Because of this, it isnt strictly necessary to anchor the arrow on a line in the OPs box saying op_next. The float option lets the graph layout engine start these arrows wherever it wants, which can sometimes lead to a more pleasing layout, at the expense of being less obvious. The default is not to float.

-targlinks, -no_targlinks

Lexical (my()) variables and temporary values used by individual OPs are stored in pads, per-code arrays linked to the CV. OPs store indexes into these arrays in the op_targ field, but B::Graph can often also draw links directly from the OP to the SV that stores the name of the variable. These links dont correspond to any real pointers, however, and they can make the graph more complicated, so they are disabled by default.