Commit 22a8d12c authored by petter's avatar petter

initial VAM checkin


git-svn-id: https://www2.in.tum.de/repos/vam@1 e840d55b-1d80-4f23-a9d8-6aec749d046a
parents
<project name="VAM" default ="all" basedir=".">
<property name="java" location="java" />
<property name="classes" location="bin" />
<property name="dist" location="dist"/>
<property name="etc" location="etc" />
<property environment="env" />
<path id="sources">
<fileset dir="${src}">
<include name="**/**.java" />
</fileset>
</path>
<!-- initialize the workspace -->
<target name="init">
<mkdir dir="${classes}" />
<mkdir dir="${dist}" />
</target>
<!-- deletes all build-related directories -->
<target name="clean">
<delete>
<fileset dir="." defaultexcludes="no" includes="**/*~"/>
<fileset dir="." defaultexcludes="no" includes="**/#*#"/>
</delete>
<delete dir="${classes}" />
<delete dir="${dist}" />
</target>
<!-- Compiles the .java files to the classes directory -->
<target name="classes" depends="init">
<depend srcdir="${java}" destdir="${classes}" cache="${etc}" />
<javac srcdir="${java}" destdir="${classes}" verbose="off" listfiles="off"
source="1.4" target="1.4" debug="off">
</javac>
</target>
<!-- Packs the classes into single .jar files -->
<target name="pack" depends="classes">
<jar jarfile="${dist}/vam.jar" basedir="${classes}">
<manifest>
<attribute name="Main-Class" value="Starter" />
<!--attribute name="Class-Path" value="derby.jar jna.jar" /-->
</manifest>
</jar>
<copy todir="${dist}"><fileset dir="${etc}"></fileset></copy>
<zip destfile="./vam.zip" basedir="${dist}" update="true"/>
</target>
<!-- build the whole project -->
<target name="all" depends="pack" />
<target name="run" depends="pack">
<java jar="${dist}/vam.jar" fork="true">
<assertions><disable /></assertions>
</java>
</target>
</project>
-----------------------------------
- VAM - Ein System zur
Visualisierung Abstrakter Maschinen
-----------------------------------
Starten:
java.bat (Windows)
oder
java.sh (Linux)
oder
java -jar vam.jar
Programm auswhlen:
"Program"-Button
oder
Men "VAM -> Open Program ..."
Maschine auswhlen:
Men "VAM -> Select Machine"
(Auswahl der Maschine erfolgt auch automatisch ber Dateiendung)
Verzeichnisse:
vam.jar : Java-Klassen und Quellen
examples: enthlt Beispiel-Programme
verschiedener Maschinen
-----------------------------------
Peter Ziewer
TU Mnchen
ziewer@in.tum.de
Lehrstuhl Informatik II
Prof. Dr. Helmut Seidl
http://www2.in.tum.de/
-----------------------------------
java -jar vam.jar
#!/bin/bash
java -jar vam.jar
import vam.base.*;
import vam.util.*;
public class Starter
{
static private void printUsage() {
System.out.println("Usage : java Starter <options>");
System.out.println("options : ");
System.out.println(" -load <file>\t\tProgramm einladen");
System.out.println(" -nohistory\t\tHistory-Funktion ausschalten");
System.out.println(" -stackbound n\t\tGibt max. Anzahl der sichtbaren Stack-Zellen an");
System.out.println("\t\t\t(Maximum : 30; n = 0 : unbegrenzt)");
System.out.println(" -usage\t\tGibt diesen Text aus");
System.exit(0);
}
static public void main ( String args[] )
{
boolean nohistory = false;
int stackBound = 25;
String file=null;
// Parameter abarbeiten
if (args.length == 1 && args[0].equals("-usage")) {
printUsage();
}
else {
for(int i = 0; i < args.length; i++) {
if(args[i].equals("-nohistory")) {
nohistory = true;
System.out.println("Starter : History-Funktion ausgeschaltet");
}
else if(args[i].equals("-stackbound") && args.length >= i+2) {
try {
stackBound = Integer.parseInt(args[i+1]);
}
catch(NumberFormatException ex) {
System.out.println("<<< Parameter ungueltig >>>");
printUsage();
}
i++;
}
//else if(args[i].equals("-load") && args.length >= i+2) {
// file = args[++i];
//}
else {
System.out.println("<<< Parameter ungueltig >>>");
printUsage();
}
}
}
ViewMachine vam = new ViewMachine();
//if(file!=null) vam.setFile(file);
if(nohistory == true) {
vam.nohistory();
}
vam.setStackBound(stackBound);
vam.run();
System.exit(0);
}
}
This diff is collapsed.
package vam.base;
import java.awt.Point;
import java.util.*;
/**
Dient zur Gruppierung von Zellen.
*/
public class CellGroup extends ArrayList
{
class CellComp implements Comparator {
public int compare(Object o1, Object o2) {
int addr1 = ((Cell)o1).address;
int addr2 = ((Cell)o2).address;
if(addr1 < addr2) {
return -1;
}
else if(addr1 > addr2) {
return 1;
}
else {
return 0;
}
}
}
String name;
/**
Erzeugt neue Gruppierung.
@param name Name der Gruppierung
*/
public CellGroup( String name )
{
super();
this.name = name;
}
/**
Erzeugt neue Gruppierung.
*/
public CellGroup()
{
this( "untitled" );
}
/**
Fgt der Gruppierung eine Zelle hinzu.
@param cell Hinzuzufgende Zelle
*/
public void add( Cell cell )
{
super.add( cell );
cell.group = this;
}
/*************
* Animation *
*************/
/**
Visualisierung einer Bewegung der Zellengruppe.
@param destination Zielkoordinaten der Zellengruppe
*/
public void moveTo( Point destination )
{
moveTo( destination.x,destination.y );
}
public void moveToNoSync( Point destination )
{
moveToNoSync( destination.x,destination.y );
}
/**
Visualisierung einer Bewegung der Zellengruppe.
@param x x-Zielkoordinate der Zellengruppe
@param y y-Zielkoordinate der Zellengruppe
*/
public void moveTo( int x, int y )
{
// AD : zuerst nach addresse sortieren
Collections.sort(this, new CellComp());
Iterator i = iterator();
if ( i.hasNext() )
{ // erste Zelle zur Positionsbestimmung
Cell c = (Cell)i.next();
System.out.println("MOVETO FIRST CELL : " + c.address);
Point location = c.getLocation();
moveBy( x-location.x, y-location.y );
}
}
public void moveToNoSync( int x, int y )
{
// AD : zuerst nach addresse sortieren
Collections.sort(this, new CellComp());
Iterator i = iterator();
if ( i.hasNext() )
{ // erste Zelle zur Positionsbestimmung
Cell c = (Cell)i.next();
Point location = c.getLocation();
moveByNoSync( x-location.x, y-location.y );
}
}
/**
Visualisierung einer Bewegung der Zellengruppe.
@param destination Zielzelle zu der diese Zelle bewegt werden soll
*/
public void moveTo( Cell destination )
{
moveTo( destination.getLocation() );
}
/**
Visualisierung einer Bewegung der Zellengruppe.
@param x x-Abstand zu den Zielkoordinaten der Zellengruppe
@param y y-Abstand zu den Zielkoordinaten der Zellengruppe
*/
public void moveBy( int x, int y )
{
moveByNoSync(x, y);
Cell.syncAll();
}
public void moveByNoSync(int x, int y) {
Collections.sort(this, new CellComp());
Iterator i = iterator();
while( i.hasNext() )
{
Cell c = (Cell)i.next();
Point location = c.getLocation();
location.translate( x,y );
c.moveTo( location );
}
}
/**
Visualisierung einer Bewegung der Zellengruppe.
@param distance Abstand zu den Zielkoordinaten der Zellengruppe
*/
public void moveBy( Point distance )
{
moveBy( distance.x,distance.y );
}
/**
Erzeugt und entfernt optische Hervorhebung der Zellengruppe
@param highlight 'true' falls die Zelle optisch hervorgehoben werden soll
*/
public void highlight( boolean highlight )
{
Iterator i = iterator();
while ( i.hasNext() ) ((Cell)i.next()).highlight( highlight );
}
/**
Die Zellengruppe wird eingeblendet.
*/
public void fadeIn()
{
Iterator i = iterator();
while ( i.hasNext() ) ((Cell)i.next()).fadeIn();
Cell.syncAll();
}
/**
Die Zellengruppe wird ausgeblendet.
*/
public void fadeOut()
{
Iterator i = iterator();
while ( i.hasNext() ) ((Cell)i.next()).fadeOut();
Cell.syncAll();
}
/**
Zellengruppe sichtbar oder nicht
@param visible true fr sichtbar
*/
public void setVisible( boolean visible )
{
Iterator i = iterator();
while ( i.hasNext() ) ((Cell)i.next()).setVisible( visible );
}
/**********************************
* Positionwechsel ohne Animation *
**********************************
/**
Setzt die neue Position fr diese Gruppe relative zur alten ohne Animation.
@param x x-Abstand zu den Zielkoordinaten der Zellengruppe
@param y y-Abstand zu den Zielkoordinaten der Zellengruppe
*/
public void translate( int x, int y )
{
Iterator i = iterator();
while ( i.hasNext() )
{
Cell c = (Cell)i.next();
c.setLocation( c.getX()+x, c.getY()+y );
}
Pointer.updateAll();
}
/**
Setzt die neue Position fr diese Gruppe relative zur alten ohne Animation.
@param distance Entfernung zur aktuellen Position
*/
public void translate( Point distance )
{
translate( distance.x, distance.y );
}
/**
Setzt die neue Position fr diese Gruppe ohne Animation.
@param x X-Koordinate der neuen Position
@param y Y-Koordinate der neuen Position
*/
public void setLocation( int x, int y )
{
Iterator i=iterator();
if( i.hasNext() )
{ // Position des ersten Elements bestimmen um Translation zu berechnen
Cell c = (Cell)i.next();
translate( x-c.getX(), y-c.getY() );
}
}
/**
Setzt die neue Position fr diese Gruppe ohne Animation.
@param location Entfernung zur aktuellen Position
*/
public void setLocation( Point location )
{
setLocation( location.x, location.y );
}
}
\ No newline at end of file
package vam.base;
/**
Gerüst für Befehle der zu visualisierenden Maschinen
*/
public class Command
{
// benötigte Daten
protected String command; // Name des Befehls
// eigen Daten einfügen .......
// DatentypX argumentX;
// DatentypY argumentY;
// .....
/**
Generiert neuen Befehl.
@param command Name des Befehls
*/
public Command( String command /* ,Datentyp1 argument1 ,Datentyp2 argument2 ,..... */ )
{ // Daten initialisieren
// sollte um benötigte Argumente und deren Verarbeitung erweitert werden
this.command = command;
}
/**
Wird aufgerufen, wenn die Abstrakte Maschine gestartet werden soll.
Hier sollten sämtliche statischen Strukturen erzeugt werden
(z.B. wenn vam.util.Stack verwendet wird.)
@param viewMachine Gibt die zugehörige 'ViewMachine' an
*/
public void initialize( ViewMachine viewMachine )
{
ViewMachine.output( "initializing" );
}
/**
Wird aufgerufen um den Befehl auszuführen.
*/
public void execute()
{
if( !command.equals("HALT") )
ViewMachine.output( "unkown command: "+command );
}
/**
Wird für die Ausgabe des Listings verwendet.
Sollte um Ausgabe der Argumente des Befehls erweitert werden.
@return Ausgabe
*/
public String toString()
{
return command /* +" "+Argument1+" "+Argument2+... */;
}
}
package vam.base;
import java.awt.Color;
/**
Animation zum Ein- und Ausblenden einer Zelle.
*/
class FadeAction extends VisualizationAction
{
boolean fadeIn;
int rf,gf,bf,rb,gb,bb,alpha;
/**
Erzeugt Animation fr Ein- bzw. Ausblenden einer Zelle.
@param cell Zelle fr Animation
@param fadeIn true fr einblenden, false fr ausblenden
*/
FadeAction( Cell cell, boolean fadeIn )
{
cell.vm.view.moveToFront(cell);
this.cell = cell;
this.fadeIn = fadeIn;
alpha = fadeIn ? 0 : 255;
Color c = cell.getBackground();
rb = c.getRed();
gb = c.getGreen();
bb = c.getBlue();
cell.setBackground( new Color( rb,gb,bb, alpha ) );
c = cell.getForeground();
rf = c.getRed();
gf = c.getGreen();
bf = c.getBlue();
cell.setForeground( new Color( rf,gf,bf, alpha ) );
cell.setVisible(true);
}
/**
Wird aufgerufen, um den nchste Schritt der Animation zu berechnen.
Schrittweise nderung des Alpha-Werts der Farbe der Zelle.
*/
void nextFrame()
{
if( fadeIn )
{
alpha = Math.min( 255, alpha+cell.vm.optionFadeStep );
if( alpha == 255 ) cell.vm.removeVisualization( this );
}
else
{
alpha = Math.max( 0, alpha-cell.vm.optionFadeStep );
if ( alpha == 0 )
{
cell.setVisible(false);
cell.vm.removeVisualization( this );
}
}
cell.setBackground( new Color( rb,gb,bb, alpha ) );
cell.setForeground( new Color( rf,gf,bf, alpha ) );
}
}
// AD : realisiert die History-Funktion
package vam.base;
import java.util.*;
import javax.swing.*;
import java.awt.*;
class CellState {
String value;
String type;
int address;
Point location;
Rectangle bounds;
Color background;
Color foreground;
int pointerOutMode;
int pointerInMode;
boolean isPointer;
boolean visible;
CellGroup group;
public CellState(Cell c) {
value = c.getValue();
type = c.getType();
address = c.address;
location = c.getLocation();
bounds = c.getBounds();
background = c.getBackground();
foreground = c.getForeground();
pointerOutMode = c.pointerOutMode;
pointerInMode = c.pointerInMode;
isPointer = c.isPointer;
visible = c.isVisible();
group = c.group;
}
public Cell createCell() {
Cell newCell = new Cell( value, type, location, Cell.INVISIBLE );
newCell.setBounds( bounds );
newCell.setBackground( background );
newCell.setForeground( foreground );
newCell.pointerOutMode = pointerOutMode;
newCell.pointerInMode = pointerInMode;
newCell.isPointer = isPointer;
newCell.setVisible( visible );
newCell.setAddress(address);
group.add(newCell);
return newCell;
}
}
class State {
private History history;
private LinkedList regValues;
private HashMap mem;
private java.util.Stack trailCopy;
private int addressForNewHeapObjects;
private int hiddenStackCells;
private Point newHeapObjectLocation;
public State(History history) {
this.history = history;
if(history.trail != null) {
trailCopy = (java.util.Stack)(history.trail.clone());
}
// store values of all registers
regValues = new LinkedList();
ListIterator it = history.regs.listIterator();
while(it.hasNext()) {
Register reg = (Register)it.next();
regValues.add(new Integer(reg.value));
}
mem = new HashMap();
Iterator it2 = history.vm.memory.memory.keySet().iterator();
while(it2.hasNext()) {
Object key = it2.next();
Cell c = (Cell)(history.vm.memory.memory.get(key));
CellState cs = new CellState(c);
mem.put(key, cs);
}
addressForNewHeapObjects = history.vm.memory.addressForNewHeapObjects;
newHeapObjectLocation = new Point(history.vm.memory.newHeapObjectLocation);
hiddenStackCells = history.vm.hiddenStackCells;
}
public void restore() {
Iterator it3 = history.vm.memory.memory.values().iterator();
while(it3.hasNext()) {
Object c = it3.next();
((Cell)c).group.remove(c);
((Cell)c).removeToPointers();
((Cell)c).remove();
}
history.vm.memory.memory = new HashMap();
Iterator it1 = mem.keySet().iterator();
while(it1.hasNext()) {
Object key = it1.next();
CellState cs = (CellState)mem.get(key);
Cell c = cs.createCell();