Arbeitsgruppe Compilerbau und CAD

Manfred Rosendahl

Prof.Dr. Manfred Rosendahl

E-mail: r o s at u n i-k o b l e n z. de
FB-Informatik | Tel : +49-261-287-2725
Universitaet Koblenz | Fax : +49-261-287-100-2725
Postfach 201602 D56016 Koblenz | http://www.uni-koblenz.de/~ros

Pascal nach C++ Konverter pas2cpp

Die Konvertierung eines Pascal Programms in ein C++ Programm erfordert nicht nur eine syntaktische Umsetzung sondern die semantischen Unterschiede zwischen Pascal (Delphi, Freepascal) und C++ müssen berücksichtigt werden.

In Pascal stellen mit Ausnahme der Klasseninstanzen (Objekte) alle Variablen einen Speicherbereich dar, nur die Objekte geben die Adresse der Instanz an. In C++ repräsentieren nur die Basistypen, wie int, char,double,boolean und Rekords den Speicherbereich, bei allen anderen wie Arrays und Objekte ist der Inhalt der Variablen die Adresse des Datenbereichs auf der Halde.

Hat man Pascal eine Deklaration a,b:array[0..9]of integer so wird bei der Zuweisung a:=b der Speicherbereich von b nach a kopiert.Hat man bei C++ die Deklaration

int[10] a und int[10] b so erhält man bei der Anweisung a=b, einen Fehler. Um eine Zuweisung mit der Semantik von Pascal zu erhalten muss man den Array in einen Rekord verpacken.

struct{int[10] a;};

Der Umsetzer erzeugt für alle im Programm vorkommenden Arrays automatisch einen solchen Rekord.

Für mehrdimensionale Arrays ist das analog.

Aus

type tmatrix=array[0..9,0..9]of integer

wird

using tmatrix=struct{int a[3][3];};

Generell wird eine Typdeklaration in Pascal in eine using Anweisung umgesetzt.

using tvektor=struct{int a[3];};

using tmatrix=struct{tvektor a[3];};

Für Strings gibt es in C++ die Klasse string und stringBuffer.

Bei der Übertragung von Strings nach C++ wird die Klasse string benutzt. Die Instanzen der Klasse können aber nicht geändert werden. Für die Pascal Anweisung

s[3]:='A'

muss erzeugt werden

put(s,(3)-1,'A');

Die Funktion put ist in myini.cpp definiert:

void put(string& str, int pos, char ch) {

if (pos == 0) str = ch + str.substr(1);

else str = str.substr(0, pos) + ch + str.substr(pos + 1);

}

Es wird ein neuer String erzeugt, der der Stringvariablen zugewiesen wird.

In Pascal sind sowohl String- als auch Char-Konstanten in jeweils einfache Anführungszeichen (') eingefasst. Daher ist ein String der Länge 1 nicht von einem Charakter zu unterscheiden. Bei Pascal sorgt der Compiler für die richtige Interpretation. Bei C++ haben String doppelte Anführungszeichen und Zeichenliterale einfache. Bei der Umsetzung muss dies berücksichtigt werden. Entsprechend den formalen Parametern oder dem Ziel der Zuweisung werden Strings der Länge 1 in Zeichen oder Strings umgewandelt.

Ein großes Problem besteht auch bei der Umsetzung der Prozeduren bzw. Funktionsaufrufen. Die var Parameter von Pascal müssen durch Übergabe der Adresse realisiert werden, wie das intern auch in Pascal gemacht wird.

Aus:

function p(var s:integer):integer;

begin

s:=1;

result:=2;

end;

function f(var s:integer):integer;

begin

result:=p(s);

end;

wird:

int p(int* s){

int result;

*s=1;

result=2;

return result;

}

int f(int* s){

int result;

result=p(&(*s));

return result;

}

In der Prozedur wird dem Zeiger int* s mit *s=1; ein Wert zugewiesen.

Beim Aufruf wird mit &a die Adresse der variablen a übergeben.

Wird ein var Parameter wieder als var Parameter übergeben, entsteht der Konstrukt:

result=p(&(*s));

Um zu Erkennen dass ein var Parameter vorliegt, müssen bei einem Prozeduraufruf die aktuellen Parameter mit den formalen verglichen werden. Da außerdem ein Overloading, d.h. mehrere verschiedene Prozeduren haben den gleichen Namen, aber nur unterschiedliche Parameter, müssen die Prozeduren und auch die Methoden in einer Datenstruktur gehalten werden, damit beim Prozeduraufruf die richtige Prozedur ausgewählt wird um dann entscheiden zu können für welche Parameter die Adresse übergeben werden muss.

Hat man in Pascal eine Deklaration a,b:array[1..10]of integer so sind a und b nur untereinander kompatibel aber zu keinem anderen Typ. Hier muss man eine implizite Typdefinition erstellen.

using mytype1=struct{int[10] a;};

mytype1 a,b;

In Pascal können die unteren und oberen Grenzen eines Arrays beliebige ganze Zahlen sein. In C# beginnt jeder Array beim Index 0 und geht bis zum Index Länge-1.

Bei einem Indexausdruck muss daher jeweils die untere Grenze abgezogen werden, wenn sie nicht 0 ist.

In Pascal kann man auch Arrays über einem Ordinalbereich definieren z.B:

array[char]of integer;

In C++ würde daraus int[256], da der maximale Wert eines Zeichen 255 ist.

In Pascal gibt den Aufzählungstyp, z.B:

type farbe=(rot,gelb,gruen);

Die Elemente des Aufzählungstyp haben von 0 an aufsteigende Werte und die Namen müssen im Gültigkeitsbereich einmalig sein. Daher kann dies in C++ realisiert werden durch:

int rot=0;int gelb=1;int gruen=2;

Ferner gibt es in Pascal den Unterbereichstyp. Hier wird ein Ordinal Typ wie Integer oder char eingeschränkt. Bei den Variablen kann auch der Grundtyp benutzt werden, wird ein Unterbereich in einer Typdefinition angegeben,

z.B. type t=10..20;

Daraus wird using t=struct{int a[11];};

Aus

var aa:ta;

und

for i:=10 to 20 do aa[i]:=10*i;

wird:

for( i=10; i<=20; i++)

aa.a[i-10]=10*i;

In Pascal kann über jeden Ordinal Bereich der maximal 256 Elemente enthält ein Set gebildet werden.

z.B. type t=set of 0..255;

Bei var v:t;i:integer kann gebildet werden i in v;

In C++ kann man dies simulieren durch:

struct myset { bool wert[256]; };

und wert[i] gibt an ob i in v ist.

In myini.cpp werden für die Mengen Initialisierungen definiert.

myset fmyset()

{

return myset();

}

erzeugt die leere Menge.

myset fmyset(string a)

{

myset s = myset();

for (int i = 0; i < a.length(); i++) s.wert[(int)a[i]] = true;

return s;

}

erzeugt einen set of char, der alle Zeichen aus a enthält.

Bei der Definition der Mengen können auch Bereiche angegeben werden, etwa 1..10 oder 'A'..'Z'. dies wird umgesetzt mit den Prozeduren:

myset fmyset(vector<int> a)

{

myset res = myset();

int start = 0;

int ende = 0;

int b;

int von = 0;int bis = 0;

for (int i = 0; i < a.size(); i++) {

b = a[i];

if (b < 0) von = b;

else

{

if (von < 0) von = bis + 1;

else von = b;

bis = b;

for (int j = von; j <= bis; j++)

res.wert[j] = true;

von = b;

}

return res;

}

myset initset(vector<char> a)

{

myset res = myset();

int start = 0;

int ende = 0;

char cb;

int b;

int von = 0;int bis = 0;

for (int i = 0; i < a.size(); i++) {

cb = a[i];

if (cb == '?') b = -1;

else b = ord(cb);

if (b < 0) von = b;

else

{

if (von < 0) von = bis + 1;

else von = b;

bis = b;

for (int j = von; j <= bis; j++)

res.wert[j] = true;

von = ord(b);

}

return res;

}

In myini.cpp werden für die Mengenoperationen wie Vereinigung, Durchschnitt, Differenz und Enthalten-sein (in) jeweils Funktionen deklariert, die dann bei den Operationen aufgerufen werden.

Klassen

Es können Klassen definiert werden, auch eine Vererbung ist möglich.

Aus:

type tint=class

x:integer;

constructor create(ax:integer);

constructor summe(a,b:tint);

end;

constructor tint.create(ax:integer);

begin

x:=ax;

end;

constructor tint.summe(a,b:tint);

begin

create(a.x+b.x);

end;

wird:

class tint:public tobject{

public: tint(){}

int x;

tint(int ax){

x=ax;

}

tint(tint* a,tint* b):tint(a->x+b->x){

}

In Pascal sind die Klassen Variablen jeweils Zeiger auf die Instanz, die auf dem Heap liegt. Daher muss in C++ die Klassen Variable auch jeweils ein Zeiger sein. Um auf die Komponenten zuzugreifen wird -> benutzt. In Pascal kann ein Konstruktor einen beliebigen Namen haben, in C++ ist es jeweils der Name der Klasse. In dem Pascal Programm dürfen daher nicht 2 Konstruktoren die gleichen Parameter haben.

Wird in einem Konstruktor ein Konstruktor aufgerufen, wie im Beispiel bei tint.summe, so wird der Aufruf im Kopf hinter dem Doppelpunkt hinzu gefügt. Ähnlich wird auch bei einem inherited Aufruf verfahren.

Von Pascal werden die Klassen tstringlist und tlist implementiert. Bei tlist können die Elemente aber nur Referenzen auf Objekt Instanzen sein.

Es werden folgende Prozeduren von Pascal unterstützt:

succ

pred

inc

dec

chr

ord

strtoint

inttostr

Bei Strings die Prozeduren:

copy

delete

insert

pos

length

Für die Kommandozeile:

paramcount

paramstr

Es wird nur eine Text Ein- Ausgabe unterstützt. Dabei die Prozeduren:

write

writeln

readln

assign

rewrite

reset

append

eof

Die Ein- Ausgabe kann dabei sowohl von der Konsole als auch von einer Textdatei erfolgen. Es können auch die Format Angaben wie i:6 oder X:10:3 angegeben sein.

Es werden alle Anweisungen von Pascal unterstützt, mit Ausnahme der Case Anweisung. Die with Anweisungen von Pascal werden aufgelöst, aus

with a do x:=5;

wird

a.x=5;

wenn a ein Rekord ist. Ist a eine Klassenvariable wird daraus:

a->x=5;

Die with können auch geschachtelt werden.

Ein Pascal Programm oder auch eine Pascal Unit kann units benutzen.

Zu einem sind dies die Pascal Standard Units wie sysutil oder classes. Die dort benutzten Funktionen werden, soweit implementiert, automatisch übersetzt. Andere selbst geschriebene Units können eingebunden werden.

Beispiel:

Aus dem Pascal Program:

{$apptype console}

program demo;

var x:integer=1;y:integer=2;

i:integer;

procedure p(var a:integer);

begin

a:=a*2;

end;

begin

x:=1;

for i:=1 to 5 do begin

p(x);

writeln(x);

end;

readln;

end.

wird folgendes C++ Programm erzeugt:

//{$apptype console}

int x=1;

int y=2;

int i;

void p(int* a){

*a=(*a)*2;

}

int main(int argc, char* argv[]){

myparamcount = argc-1;

myparamstr =argv;

x=1;

for( i=1; i<=5; i++){

p(&x);

{write(x);writeln();}

}

readln();

}

Benutzung:

(1) In der Eingabeaufforderung mit folgenden Aufruf:

pas2cpp <Pascal-Quelle> <C++ Ziel> [Optionen]

Das Ziel liegt in einem Visual Studio Projektverzeichnis für eine Konsolenanwendung.

Optionen:

-d Debugmodus an

-q Quietmodus an

-f Nur die Pascal Datei formatieren

-n Die C++ Datei nicht formatieren

-e Alle benutzten Units neu übersetzen. Sonst werden die Units nur übersetzt,

wenn die Pascal Quelldatei jünger als die C# Zieldatei ist.

(2) Mit Hilfe des Programms Pas2cppIDE.exe

Das Installationsprogramm kann heruntergeladen werden unter:

Pas2cppinst

<Pascal-Quelle> <C# Ziel> [Optionen] pas2cs

Das Ziel liegt in einem Visual Studio Projektverzeichnis für eine Konsolenanwendung.

Optionen:
-d Debugmodus an
-q Quietmodus an
-i keine Initdatei erzeugen. Sie muss dann schon im Zielverzeichnis sein. Sonst
wird die Initdatei kopiert, wenn die Quelle im Programmverzeichnis jünger als
die Kopie im Zielverzeichnis ist, bzw. sie dort noch nicht vorhanden ist
-f Nur die Pascaldatei formatieren
-n Die C# Datei nicht formatieren
-e Alle benutzten Units neu übersetzen. Sonst werden die Units nur übersetzt,
wenn die Pascal Quelldatei jünger als die C# Zieldatei ist.

Pascal nach C# Konverter pas2cs

Die Konvertierung eines Pascal Programms in ein c# Programm erfordert nicht nur eine syntaktische Umsetzung sondern die semantischen Unterschiede zwischen Pascal (Delphi, Freepascal) und c# müssen berücksichtigt werden.

In Pascal stellen mit Ausnahme der Klasseninstanzen (Objekte) alle Variablen einen Speicherbereich dar, nur die Objekte geben die Adresse der Instanz an. In c# repräsentieren nur die Basistypen, wie int, char,double,boolean und Rekords den Speicherbereich, bei allen anderen wie Arrays und Objekte ist der Inhalt der Variablen die Adresse des Datenbereichs auf der Halde.

Hat man Pascal eine Deklaration a,b:array[0..9]of integer so wird bei der Zuweisung a:=b der Speicherbereich von b nach a kopiert.Hat man bei c# die Deklaration

int[] a=new int[10] und int[] b=new int[10] so wird bei der Anweisung a=b nur der Zeiger b nach a kopiert. Danach zeigt b auf den gleichen Speicherbereich wie a.Um eine Zuweisung mit der Semantik von Pascal zu erhalten muss man eine Kopie erzeugen:

static int[] mycopy(int[] a){

int d0=a.GetUpperBound(0)+1;

int[]a1=new int[d0];

for (int k0=0;k0<d0;k0++)

a1[k0]=a[k0];

return a1;

}

Der Verweis auf die Kopie kann später dem Ziel zugewiesen werden.

Der Umsetzer erzeugt für alle im Programm vorkommenden Arrays automatisch eine solche Funktion. Da in C# ein overloading erlaubt ist, können sie alle den Namen mycopy haben.

Für mehrdimensionale Arrays ist das analog.

static int[,] mycopy(int[,] a){

int d0=a.GetUpperBound(0)+1;

int d1=a.GetUpperBound(1)+1;

int[,]a1=new int[d0,d1];

for (int k0=0;k0<d0;k0++)

for (int k1=0;k1<d1;k1++)

a1[k0,k1]=a[k0,k1];

return a1;

}

Bei Pascal sind die Arrays jeweils bereits initialisiert, bei C# sind dies lediglich Null Zeiger. Daher benötigt man jeweils eine Funktion um einen Array zu initialisieren.

Daher erzeugt der Umsetzer für alle vorkommenden Arrays eine Initialisierung.

Für ein 2-dimensionales Integer Array sieht das wie folgt aus:

static int[,] myinit(int d0,int d1,int b){

int[,]a=new int[d0,d1];

for (int k0=0;k0<d0;k0++)

for (int k1=0;k1<d1;k1++)

a[k0,k1]=b;

return a;

}

Für Strings gibt es in C# die Klasse String und StringBuffer.

Bei der Übertragung von Strings nach c# wird die Klasse String mit dem alias string benutzt. Die Instanzen der Klasse können aber nicht geändert werden. Für die Pascal Anweisung

s[3]:='A'

muss erzeugt werden

put(ref s,(3)-1,'A');

Die Funktion put ist in myini.cs definiert:

static void put(ref string str, int pos, char ch){

if (pos==0) str=ch+str.Substring(1);

else str = str.Substring(0,pos)+ch+str.Substring(pos+1);

}

Es wird ein neuer String erzeugt, der der Stringvariablen zugewiesen wird.

Ein großes Problem besteht auch bei der Umsetzung der Prozeduren bzw. Funktionsaufrufen. Im Gegensatz zu Java oder C können in C# zwar Parameter den Zusatz ref bekommen, was einen Call-by-Reference bewirkt, aber im Gegensatz zu Pascal muss auch beim Aufruf der Zusatz ref angegeben werden. Daher müssen bei einem Prozeduraufruf die aktuellen Parameter mit den formalen verglichen werden. Da außerdem ein Overloading, d.h. mehrere verschiedene Prozeduren haben den gleichen Namen, aber nur unterschiedliche Parameter, müssen die Prozeduren und auch die Methoden in einer Datenstruktur gehalten werden, damit beim Prozeduraufruf die richtige Prozedur ausgewählt wird um dann entscheiden zu können welche Parameter mit ref übergeben werden.

Werden Parameter, die als Referenzen gehalten werden mit call-by-value übergeben, so muss eine Kopie des Parameters übergeben werden, da ansonsten eine Änderung des formalen Parameters in der Prozedur auch eine Änderung des aktuellen Parameters bewirken würde. Hierzu werden die automatisch erzeugten Copy Prozeduren, wie bei der Zuweisung benutzt.

In C# gibt es keine Typdefinitionen außer der Definition von Klassen und Rekords , hier struct.

Hat man in Pascal eine Deklaration a,b:array[1..10]of integer so sind a und b nur untereinander kompatibel aber zu keinem anderen Typ. Ansonsten muss man

type ta=array[1..10]of integer definieren und alle Variablen vom Typ ta sind untereinander kompatibel. In Pascal gilt die Namensäquivalenz. In C# gilt dagegen die Strukturäquivalenz d.h. alle Variablen von Typ int[] sind kompatibel.

Deswegen wird bei einem Array als Prozedur Parameter auch keine Länge angegeben. Bei einer Variablen Deklaration wird jeweils der Typ eingesetzt. Hat man in Pascal var a,b:ta; so wird daraus in C#:

int[]a=new int[11];int[]b=new int[11];

In Pascal können die unteren und oberen Grenzen eines Arrays beliebige ganze Zahlen sein. In C# beginnt jeder Array beim Index 0 und geht bis zum Index Länge-1.

Bei einem Indexausdruck muss daher jeweils die untere Grenze abgezogen werden, wenn sie nicht 0 ist.

In Pascal kann man auch Arrays über einem Ordinalbereich definieren z.B:

array[char]of integer;

In C# würde daraus int[256], da der maximale Wert eines Zeichen 255 ist.

In Pascal gibt den Aufzählungstyp, z.B:

type farbe=(rot,gelb,gruen);

Die Elemente des Aufzählungstyp haben von 0 an aufsteigende Werte und die Namen müssen im Gültigkeitsbereich einmalig sein. Daher kann dies in C# realisiert werden durch:

int rot=0;int gelb=1;int gruen=2;

z.B. type t=1..10, so muss, wenn dieser Typ in einer Array Deklaration auftaucht, in C# der Maximalwert+1 eingesetzt werden.

In Pascal kann über jeden Ordinal Bereich der maximal 256 Elemente enthält ein Set gebildet werden.

z.B. type t=set of 0..255;

Bei var v:t;i:integer kann gebildet werden i in v;

In C# kann man dies simulieren durch:

boolean[] v=new boolean[256]; und v[i] gibt an ob i in v ist.

In myini.cs werden für die Mengenoperationen wie Vereinigung, Durchschnitt, Differenz und Enthalten-sein (in) jeweils Funktionen deklariert, die dann bei den Operationen aufgerufen werden.

Klassen

Von Pascal werden die Klassen tstringlist und tlist implementiert. Bei tlist können die Elemente aber nur Objekt Instanzen sein, da pointer in C# nicht definiert sind. Auch die Operationen addr (Adresse einer Variablen, Pointer ) und ^ (dereferenzieren) sind nicht unterstützt.

Pas2Java

Pascal nach Java Konverter pas2java

Die Konvertierung eines Pascal Programms in ein Java Programm erfordert nicht nur eine syntaktische Umsetzung sondern die semantischen Unterschiede zwischen Pascal (Delphi, Freepascal) und Java müssen berücksichtigt werden.

Der Konverter beachtet diese Unterschiede und erzeugt ein Java Programm, dass sich möglichst eng an die Pascal Vorlage hält. Nicht unterstützt werden geschachtelte Prozeduren, da dies in Java nicht möglich ist.

Es werden die Standard Prozeduren und Funktionen von Pascal unterstützt, von den Systembibliotheken aber nur tlist und tstringlist.

Es wird auch bisher nur eine Datei mit dem Projekt unterstützt, keine mit uses eingebunden Module.

In Pascal stellen mit Ausnahme der Klasseninstanzen (Objekte) alle Variablen einen Speicherbereich dar, nur die Objekte geben die Adresse der Instanz an. In Java repräsentieren nur die Basistypen, wie int, char,double,boolean den Speicherbereich, bei allen anderen wie Arrays,Rekords und Objekte ist der Inhalt der Variablen die Adresse des Datenbereichs auf der Halde.

In Java gibt es keine records. Rekords müssen durch Klassen ersetzt werden. Dabei hat man wieder das Problem dass die Klassenvariablen Zeiger sind während die Rekord Variablen in Pascal den Speicherbereich darstellen. Damit bei einer Zuweisung a=b ein nachträgliche Änderung von a keine Auswirkung auf b hat muss a auf eine Kopie von b zeigen. Für jede Klasse, die einen Rekord darstellt muss eine Funktion für eine deepcopy mycopy definiert werden. Ebenso für die Zuweisung ass eine Funktion zum kopieren des Speicherbereichs.

Für Strings gibt es in Java die String und StringBuffer.

Bei der Übertragung von Strings nach Java wird eine eigene Klasse string benutzt,

Die Klasse string hat als Komponente eine Instanz von StringBuilder. Der Zugriff auf die Zeichen des Strings erfolgt durch die Methoden get und put. Diese werden umgesetzt auf die Methoden charAt und setCharAt von StringBuilder. Dabei wird auch jeweils der Index um 1 erniedrigt, da in Pascal das erste Zeichen den Index 1 hat.

Ein großes Problem besteht auch bei der Umsetzung der Prozeduren bzw. Funktionsaufrufen. In Java sind alle Parameter durch call by value realisiert. D.h. bei den Basis Typen werden wie Werte kopiert und bei den anderen Typen die Zeiger.

In Pascal gibt es ein Aufruf mit call-by-value, dabei wird eine Kopie des Speicherbereichs des aktuellen Parameters als formaler Parameter in der Prozedur benutzt. Steht vor dem formalen Parameter in der Prozedurdefinition ein var so hat man ein call-by-reference. Hier wird die Adresse des aktuellen Parameters übergeben. In der Prozedur wird beim Auftreten des Parameters die Adresse automatisch dereferenziert. Bildet man die Basistypen von Pascal (z.B. integer) einfach auf die entsprechenden Typen in Java ab (z.B. int) hat man keine Möglichkeit einen call-by-refrence zu machen. Um den aktuellen Parameter in der Prozedur verändern zu können muss man eine Adresse übergeben.

Dazu können die Basistypen wie integer auf eine entsprechende Klasse myint umgesetzt werden.

Pas2Java (Beschreibung PDF)

Das Programm kann hier heruntergeladen werden

Bedienung

Kurzbeschreibung

Forschungsgebiete

Compilerbau und Computer Aided Design (CAD)

Ein besonderer Schwerpunkt in den letzten Jahren war die Entwicklung des Systems KOGGE.
Kogge ist ein Constraint basiertes 2D CAD System, das als VarioCAD Zusatzprogramm realisiert ist. Das System hat 2 besondere Fähigkeiten. Zu einem dient es als Constraint basiertes 2D CAD System. Ähnlich wie bei den Sketch Editoren können dabei geometrische Elemente mit Beziehungen definiert werden. Ändert man einzelne Elemente in Position oder Wert so verändert sich die Zeichnung bzw. das Modell nur so, dass diese Beziehungen erhalten bleiben. Ist das nicht möglich wird die Operation nicht ausgeführt und ein Fehler gemeldet.
Der zweite Schwerpunkt ist die Erstellung von Diagrammen. Diese Diagramme bestehen aus Knoten und Kanten. Die Kanten stellen jeweils eine Verbindung zwischen 2 Knoten dar. Für die Knoten gibt es verschiedene vordefinierte Formen, u.a. Punkte, Kreise, Ovale, Rechtecke. Man kann auch eigene Formen definieren. Diese Formen können mit editierbaren Texten, auch mehrzeilig, gefüllt werden. Für die Kanten gibt es ebenfalls vordefinierte Typen, wie einfache Linien, Pfeile, Doppelpfeile, Ovale als auch selbst definierte Kantenarten. Für den Anschluss der Kanten an die Knoten gibt es auch mehrere vordefinierte Arten. Die Kanten können auf die Mitten der Knoten zulaufen und werden dabei jeweils am Knotenrand abgeschnitten. Sie können aber auch als Manhattan Kanten ausgebildet werden. Dabei läuft ein Teil waagrecht und der andere Teil senkrecht. Die dritte Form sind orthogonale Kanten. Dabei werden 2 senkrechte Teile durch einen waagrechten Teil verbunden, wenn der senkrechte Abstand der Knoten größer als der waagrechte Abstand ist oder umgekehrt, wenn der waagrechte Abstand größer ist. Die Position der orthogonal einlaufenden Kanten am Knoten wird dabei so platziert, dass es keine Überschneidungen gibt. Werden Knoten verschoben, so wird diese Platzierung automatisch angepasst.
Für die Positionierung der Knoten kann wiederum auch auf das Constraint System zurück gegriffen werden. So können z.B. Knoten senkrecht, waagrecht oder mit gleichem Abstand ausgerichtet werden. Diese Kombination von Diagramm Erstellung und Constraint System erlaubt es Diagramme nicht nur einfach zu erstellen sondern sie auch einfach und konsistent zu modifizieren.

Beschreibung(PDF)

Überblicks Artikel: Parametrische Modellierung als PDF

Download des Systems