Initial import

31 files changed, 6463 insertions, 0 deletions

diff --git a/app/eudas/4.4/doc/ref-manual/abb.1-1 b/app/eudas/4.4/doc/ref-manual/abb.1-1
new file mode 100644
index 0000000..4f705dc
--- /dev/null
+++ b/app/eudas/4.4/doc/ref-manual/abb.1-1
@@ -0,0 +1,71 @@
+init dgs; 
+window (0.0, 0.0, 13.5, 7.1); (*viewport (0.0,0.0,13.5,7.1); *) 
+scale (1.0,1.0,0.0,0.0);
+(*clear pixels;*)
+ 
+karteikasten (1.0, 3.5, "Kartei A", "Wegner", "Herbert"); 
+karteikasten (5.0, 0.5, "Kartei B", "Regmann", "Karin"); 
+   
+LET myname = "abb.1-1";
+save pixels (myname + ".p"); 
+FILE VAR f := sequential file (modify, myname + ".p"); 
+to line (f, 1); insert record (f); 
+write record (f, "#linefeed (0.8)#"); 
+insert record (f); write record (f, myname); 
+to eof (f); insert record (f); write record (f, myname); 
+to line (f, 1);
+(* 
+pause (10000);
+*)
+PROC karteikasten (REAL CONST x, y, TEXT CONST name, t name, t vorname) : 
+ 
+  move (x - 0.1, y); 
+  draw (x + 3.6, y); 
+  draw (x + 3.6, y + 1.0); 
+  draw (x - 0.1, y + 1.0); 
+  draw (x - 0.1, y); 
+ 
+  move (x + 0.1, y + 1.1); 
+  draw (x + 0.5, y + 1.5); 
+  move (x + 0.1, y + 1.1); 
+  draw (x + 3.6, y + 1.1);
+  move (x - 0.1, y + 1.0); 
+  draw (x + 0.5, y + 1.6); 
+ 
+  move (x + 3.6, y); 
+  draw (x + 5.2, y + 1.6); 
+  draw (x + 5.2, y + 2.6); 
+  draw (x + 3.6, y + 1.0); 
+    move (x + 3.6, y + 1.1); draw (x + 5.0, y + 2.5); 
+    move (x + 5.2, y + 2.6); draw (x + 5.0, y + 2.6); 
+ 
+  move (x + 0.5, y + 1.1); 
+  draw (x + 0.5, y + 2.5); 
+  draw (x + 4.0, y + 2.5); 
+  draw (x + 4.0, y + 1.5); 
+  move (x + 0.5, y + 2.5); 
+  draw (x + 1.5, y + 3.5); 
+  draw (x + 5.0, y + 3.5); 
+  draw (x + 5.0, y + 2.5); 
+  move (x + 5.0, y + 3.5); 
+  draw (x + 4.0, y + 2.5); 
+  REAL VAR x off := 0.1; 
+  WHILE x off < 1.0 REP 
+    move (x + 0.5 + xoff, y + 2.5 + x off); 
+    draw (x + 4.0 + xoff, y + 2.5 + xoff); 
+    draw (x + 4.0 + xoff, y + 1.5 + xoff); 
+    x off INCR 0.1 
+  END REP; 
+  font size (0.5); 
+  font expansion (1.5); 
+  move (x + 0.5, y + 0.2); draw (name); 
+  font size (0.25);
+  move (x + 0.7, y + 2.10); draw ("Name"); 
+  move (x + 0.7, y + 1.65); draw ("Vorname"); 
+  move (x + 0.7, y + 1.20); draw ("Strasse");
+  move (x + 2.1, y + 2.10); draw (": " + t name); 
+  move (x + 2.1, y + 1.65); draw (": " + t vorname); 
+  move (x + 2.1, y + 1.20); draw (":");
+ 
+END PROC karteikasten;
+
diff --git a/app/eudas/4.4/doc/ref-manual/abb.4-1 b/app/eudas/4.4/doc/ref-manual/abb.4-1
new file mode 100644
index 0000000..439e052
--- /dev/null
+++ b/app/eudas/4.4/doc/ref-manual/abb.4-1
@@ -0,0 +1,43 @@
+init dgs; 
+window (0.0, 0.0, 13.5, 3.2);   viewport (0.0,0.0,13.5,3.2);    
+(* scale (2.0,2.0,0.0,0.0); *)
+(*clear pixels;*) 
+ 
+font size (0.25); 
+font expansion (1.5);
+ 
+INT VAR i; 
+FOR i FROM 0 UPTO 4 REP 
+  move (2.0, real (i) * 0.5); 
+  draw (10.0, real (i) * 0.5); 
+  move (2.1, real (i) * 0.5 + 0.1); 
+  draw ("Feld " + code (code ("E") - i)); 
+END REP;
+move (2.0, 2.5); 
+draw (10.0, 2.5); 
+move (2.0, 2.5); 
+draw (2.0, 0.0); 
+move (3.5, 3.0); 
+draw (10.0, 3.0); 
+FOR i FROM 1 UPTO 4 REP 
+  move (2.0 + real (i) * 1.5, 3.0); 
+  draw (2.0 + real (i) * 1.5, 0.0); 
+  move (2.2 + real (i) * 1.5, 2.6); 
+  draw ("Satz " + text (i)) 
+END REP;
+move (9.5, 3.0); 
+draw (9.5, 0.0);
+(* 
+pause (1000);
+*) 
+   
+LET myname = "abb.4-1";
+save pixels (myname + ".p"); 
+FILE VAR f := sequential file (modify, myname + ".p"); 
+to line (f, 1); insert record (f); 
+write record (f, "#linefeed (0.8)#"); 
+insert record (f); write record (f, myname); 
+to eof (f); insert record (f); write record (f, myname); 
+to line (f, 1);
+ 
+
diff --git a/app/eudas/4.4/doc/ref-manual/abb.4-2 b/app/eudas/4.4/doc/ref-manual/abb.4-2
new file mode 100644
index 0000000..a836def
--- /dev/null
+++ b/app/eudas/4.4/doc/ref-manual/abb.4-2
@@ -0,0 +1,46 @@
+init dgs; 
+window (0.0, 0.0, 13.5, 2.0); viewport (0.0,0.0,13.5,2.0); 
+(*scale (1.7,1.7,-1.6,0.0);*) 
+(* 
+clear pixels;
+*)
+ 
+kasten (1.0, 0.0, 3.0, 1.5); 
+kasten (7.0, 0.0, 3.0, 1.5); 
+font size (0.4); font expansion (1.5); 
+move (1.8, 0.6); draw ("Menü"); 
+move (7.9, 0.6); draw ("Hilfe"); 
+move (4.5, 1.0); draw (6.5, 1.0); 
+  draw (6.25, 1.25); move (6.5, 1.0); draw (6.25, 0.75); 
+move (6.5, 0.5); draw (4.5, 0.5); 
+  draw (4.75, 0.75); move (4.5, 0.5); draw (4.75, 0.25); 
+font size (0.25); 
+move (5.0, 1.1); draw ("ESC '?'"); 
+move (5.0, 0.6); draw ("ESC 'q'"); 
+move (10.5, 1.0); draw (11.5, 1.0); draw (11.5, 0.5); draw (10.5, 0.5); 
+  draw (10.75, 0.75); move (10.5, 0.5); draw (10.75, 0.25); 
+move (11.8, 0.9); draw ("ESC 'w'"); 
+move (11.8, 0.4); draw ("ESC 'z'");
+ 
+ 
+LET myname = "abb.4-2";
+save pixels (myname + ".p"); 
+FILE VAR f := sequential file (modify, myname + ".p"); 
+to line (f, 1); insert record (f); 
+write record (f, "#linefeed (0.8)#"); 
+insert record (f); write record (f, myname); 
+to eof (f); insert record (f); write record (f, myname); 
+to line (f, 1);
+(* 
+pause (9000);
+*)
+PROC kasten (REAL CONST x anf, y anf, x l, y l) : 
+ 
+  move (x anf, y anf); 
+  draw (x anf, y anf + y l); 
+  draw (x anf + x l, y anf + y l); 
+  draw (x anf +  x l, y anf); 
+  draw (x anf, y anf) 
+ 
+END PROC kasten;
+
diff --git a/app/eudas/4.4/doc/ref-manual/abb.6-1 b/app/eudas/4.4/doc/ref-manual/abb.6-1
new file mode 100644
index 0000000..fb83242
--- /dev/null
+++ b/app/eudas/4.4/doc/ref-manual/abb.6-1
@@ -0,0 +1,75 @@
+init dgs; 
+window (0.0, 0.0, 13.5, 4.0); viewport (0.0,0.0,13.5,4.0); 
+(*scale (1.0,1.0, 0.0,0.0);*)
+(* 
+clear pixels;
+*)
+ 
+move (2.25, 1.0); draw (4.75, 1.0); 
+move (2.25, 3.0); draw (4.75, 3.0); 
+  move (2.5, 1.0); draw (2.5, 3.3); 
+  move (3.0, 1.0); draw (3.0, 3.3); 
+  move (3.5, 1.0); draw (3.5, 3.3); 
+  move (4.0, 1.0); draw (4.0, 3.3); 
+  move (4.5, 1.0); draw (4.5, 3.3); 
+font size (0.30); font expansion (1.5); 
+move (2.6, 3.1); draw ("4"); 
+move (2.6, 2.0); draw ("M");
+move (3.1, 3.1); draw ("5"); 
+move (3.1, 2.0); draw ("N"); 
+move (3.6, 3.1); draw ("6"); 
+move (3.6, 2.0); draw ("O"); 
+move (4.1, 3.1); draw ("7"); 
+move (4.1, 2.0); draw ("P"); 
+  pfeil (3.75, 0.75); 
+ 
+move (5.0, 2.0); draw (7.0, 2.0); draw (6.75, 2.25); 
+  move (7.0, 2.0); draw (6.75, 1.75); 
+move (5.0, 2.1); draw ("Einfügen"); 
+ 
+move (7.25, 1.0); draw (8.5, 1.0); move (9.0, 1.0); draw (10.25, 1.0); 
+move (7.25, 3.0); draw (8.5, 3.0); move (9.0, 3.0); draw (10.25, 3.0); 
+  move (7.5, 1.0); draw (7.5, 3.3); 
+  move (8.0, 1.0); draw (8.0, 3.3); 
+  move (8.5, 1.0); draw (8.5, 3.3); 
+  move (9.0, 1.0); draw (9.0, 3.3); 
+  move (9.5, 1.0); draw (9.5, 3.3); 
+  move (10.0, 1.0); draw (10.0, 3.3); 
+move (7.6, 3.1); draw ("4"); 
+move (7.6, 2.0); draw ("M"); 
+move (8.1, 3.1); draw ("5"); 
+move (8.1, 2.0); draw ("N"); 
+move (8.6, 3.1); draw ("6"); 
+move (9.1, 3.1); draw ("7"); 
+move (9.1, 2.0); draw ("O"); 
+move (9.6, 3.1); draw ("8"); 
+move (9.6, 2.0); draw ("P"); 
+ 
+pfeil (8.75, 0.75);
+ 
+PROC pfeil (REAL CONST x spitze, y spitze) : 
+ 
+  move (x spitze, y spitze); 
+  draw (x spitze + 0.25, y spitze - 0.25); 
+  draw (x spitze + 0.1, y spitze - 0.25); 
+  draw (x spitze + 0.1, y spitze - 0.5); 
+  draw (x spitze - 0.1, y spitze - 0.5); 
+  draw (x spitze - 0.1, y spitze - 0.25); 
+  draw (x spitze - 0.25, y spitze - 0.25); 
+  draw (x spitze, y spitze) 
+ 
+END PROC pfeil; 
+ 
+ 
+LET myname = "abb.6-1";
+save pixels (myname + ".p"); 
+FILE VAR f := sequential file (modify, myname + ".p"); 
+to line (f, 1); insert record (f); 
+write record (f, "#linefeed (0.8)#"); 
+insert record (f); write record (f, myname); 
+to eof (f); insert record (f); write record (f, myname); 
+to line (f, 1);
+(* 
+pause (9000)
+*)
+
diff --git a/app/eudas/4.4/doc/ref-manual/abb.6-2 b/app/eudas/4.4/doc/ref-manual/abb.6-2
new file mode 100644
index 0000000..7771a29
--- /dev/null
+++ b/app/eudas/4.4/doc/ref-manual/abb.6-2
@@ -0,0 +1,77 @@
+init dgs; 
+window (0.0, 0.0, 13.5, 5.0); viewport (0.0,0.0,13.5,5.0); 
+(*scale (1.4,1.4, 0.0,0.0);*) 
+(*clear pixels;*) 
+ 
+move (2.5, 4.5); draw (12.4, 4.5); draw (12.4, 4.0); draw (11.0, 4.0); 
+  draw (11.0, 3.5); move (10.5, 3.5); draw (10.5, 4.0); draw (2.5, 4.0); 
+move (13.5, 4.5); draw (12.5, 4.5); draw (12.5, 3.5); move (13.0, 3.5); 
+  draw (13.0, 4.0); draw (13.5, 4.0); 
+move (2.5, 3.5); draw (13.5, 3.5); move (13.5, 3.0); draw (10.0, 3.0); 
+  draw (10.0, 2.5); move (9.5, 2.5); draw (9.5, 3.0); draw (2.5, 3.0); 
+move (10.5, 3.0); draw (10.5, 2.5); move (11.0, 2.5); draw (11.0, 3.0); 
+move (12.5, 2.5); draw (12.5, 3.0); move (13.0, 3.0); draw (13.0, 2.5); 
+move (2.5, 2.5); draw (6.4, 2.5); draw (6.4, 2.0); draw (4.0, 2.0); 
+  draw (4.0, 1.5); draw (6.5, 1.5); draw (6.5, 2.5); draw (13.5, 2.5); 
+  move (13.5, 2.0); draw (7.0, 2.0); draw (7.0, 1.5); draw (9.0, 1.5); 
+  draw (9.0, 1.0); draw (3.5, 1.0); draw (3.5, 2.0); draw (2.5, 2.0); 
+move (9.5, 2.0); draw (9.5, 1.0); draw (10.4, 1.0); draw (10.4, 1.5); 
+  draw (10.0, 1.5); draw (10.0, 2.0); 
+move (10.5, 2.0); draw (10.5, 1.0); draw (13.0, 1.0); draw (13.0, 2.0); 
+  move (11.0, 2.0); draw (11.0, 1.5); draw (12.5, 1.5); draw (12.5, 2.0); 
+move (4.5, 1.5); draw (4.75, 1.25); draw (4.5, 1.0); 
+move (5.5, 1.5); draw (5.75, 1.25); draw (5.5, 1.0); 
+move (7.5, 1.5); draw (7.75, 1.25); draw (7.5, 1.0); 
+move (11.5, 1.5); draw (11.75, 1.25); draw (11.5, 1.0); 
+ 
+font size (0.25); font expansion (1.4); 
+move (2.5, 4.1); draw ("K0"); 
+move (2.5, 3.1); draw ("N0"); 
+move (2.5, 2.1); draw ("A0"); 
+ 
+move (0.0, 4.1); draw ("'Kalender'"); 
+move (0.0, 3.1); draw ("'Namen'"); 
+move (0.0, 2.1); draw ("'Adressen'"); 
+move (0.0, 1.1); draw ("Arbeitskopie"); 
+ 
+move (4.9, 1.1); draw ("A1"); 
+move (5.9, 1.1); draw ("A2"); 
+move (7.9, 1.1); draw ("A3"); 
+move (11.9, 1.1); draw ("K1"); 
+ 
+x alignment (right); 
+move (13.5, 4.1); draw ("K1"); 
+move (13.5, 3.1); draw ("N0"); 
+move (13.5, 2.1); draw ("A2"); 
+ 
+x alignment (normal); 
+font size (0.2); 
+INT VAR i; 
+FOR i FROM 0 UPTO 10 REP 
+  time (2.5 + real (i) * 1.0, i) 
+END REP; 
+ 
+PROC time (REAL CONST x pos, INT CONST nr) : 
+ 
+  move (x pos, 4.9); draw (x pos, 4.6); 
+  move (x pos, 3.9); draw (x pos, 3.6); 
+  move (x pos, 2.9); draw (x pos, 2.6); 
+  move (x pos, 1.9); draw (x pos, 1.6); 
+  move (x pos, 0.9); draw (x pos, 0.6); 
+  move (x pos + 0.1, 0.6); draw (text (nr)) 
+ 
+END PROC time; 
+ 
+ 
+LET myname = "abb.6-2";
+save pixels (myname + ".p"); 
+FILE VAR f := sequential file (modify, myname + ".p"); 
+to line (f, 1); insert record (f); 
+write record (f, "#linefeed (0.8)#"); 
+insert record (f); write record (f, myname); 
+to eof (f); insert record (f); write record (f, myname); 
+to line (f, 1);
+(* 
+pause (9000); 
+*)
+
diff --git a/app/eudas/4.4/doc/ref-manual/abb.7-1 b/app/eudas/4.4/doc/ref-manual/abb.7-1
new file mode 100644
index 0000000..3536ad9
--- /dev/null
+++ b/app/eudas/4.4/doc/ref-manual/abb.7-1
@@ -0,0 +1,46 @@
+init dgs; 
+window (0.0, 0.0, 13.5, 6.0);   viewport (0.0,0.0,13.5,6.0);
+(*scale (1.7,1.7, 0.0,0.0);*)
+(*clear pixels;*)
+ 
+kasten (5.0, 4.5, 3.0, 1.0); 
+kasten (5.0, 1.5, 3.0, 1.0); 
+kasten (1.5, 3.0, 3.0, 1.0); 
+font size (0.35); font expansion (1.5); 
+x alignment (center);
+move (6.5, 4.8); draw ("Druckmuster"); 
+move (6.5, 1.8); draw ("Druckdatei"); 
+move (3.0, 3.3); draw ("EUDAS-Datei"); 
+move (6.5, 0.0); draw ("Drucker"); 
+ 
+move (6.5, 4.25); draw (6.5, 2.75); draw (6.25, 3.0); 
+  move (6.5, 2.75); draw (6.75, 3.0); 
+move (4.75, 3.5); draw (6.25, 3.5); draw (6.0, 3.75); 
+  move (6.25, 3.5); draw (6.0, 3.25); 
+move (6.5, 1.25); draw (6.5, 0.5); draw (6.75, 0.75); 
+  move (6.5, 0.5); draw (6.25, 0.75); 
+ 
+
+PROC kasten (REAL CONST x anf, y anf, x l, y l) : 
+ 
+  move (x anf, y anf); 
+  draw (x anf, y anf + y l); 
+  draw (x anf + x l, y anf + y l); 
+  draw (x anf +  x l, y anf); 
+  draw (x anf, y anf) 
+ 
+END PROC kasten;
+
+ 
+LET myname = "abb.7-1";
+save pixels (myname + ".p"); 
+FILE VAR f := sequential file (modify, myname + ".p"); 
+to line (f, 1); insert record (f); 
+write record (f, "#linefeed (0.8)#"); 
+insert record (f); write record (f, myname); 
+to eof (f); insert record (f); write record (f, myname); 
+to line (f, 1);
+(* 
+pause (9000); 
+*)
+
diff --git a/app/eudas/4.4/doc/ref-manual/abb.9-1 b/app/eudas/4.4/doc/ref-manual/abb.9-1
new file mode 100644
index 0000000..774b78b
--- /dev/null
+++ b/app/eudas/4.4/doc/ref-manual/abb.9-1
@@ -0,0 +1,41 @@
+init dgs; 
+window (0.0, 0.0, 13.5, 4.0); viewport (0.0,0.0,13.5,4.0);
+(*scale (1.7,1.7, 0.0,0.0);*)
+(*clear pixels;*)
+ 
+move (1.5, 1.0); draw (8.75, 1.0); 
+move (1.5, 3.5); draw (8.75, 3.5); 
+INT VAR i; 
+FOR i FROM 0 UPTO 9 REP 
+  move (1.75 + real (i) * 0.75, 3.7); 
+  draw (1.75 + real (i) * 0.75, 1.0); 
+END REP; 
+ 
+move (4.7, 3.7); draw (4.7, 1.0); 
+ 
+font size (0.25); font expansion (1.5); 
+x alignment (center); 
+FOR i FROM 0 UPTO 8 REP 
+  move (2.125 + real (i) * 0.75, 3.6); draw (text (i + 110)) 
+END REP; 
+FOR i FROM 1 UPTO 5 REP 
+  move (2.125 + real (i + 3) * 0.75, 0.6); draw ("(" + text (i) + ")") 
+END REP;
+ 
+font size (0.35); x alignment  (left); 
+move (2.0, 0.0); draw ("Datei A"); 
+move (5.0, 0.0); draw ("Datei B"); 
+ 
+ 
+LET myname = "abb.9-1";
+save pixels (myname + ".p"); 
+FILE VAR f := sequential file (modify, myname + ".p"); 
+to line (f, 1); insert record (f); 
+write record (f, "#linefeed (0.8)#"); 
+insert record (f); write record (f, myname); 
+to eof (f); insert record (f); write record (f, myname); 
+to line (f, 1);
+(* 
+pause (9000)
+*)
+
diff --git a/app/eudas/4.4/doc/ref-manual/abb.9-2 b/app/eudas/4.4/doc/ref-manual/abb.9-2
new file mode 100644
index 0000000..4e9444d
--- /dev/null
+++ b/app/eudas/4.4/doc/ref-manual/abb.9-2
@@ -0,0 +1,96 @@
+init dgs; 
+window (0.0, 0.0, 13.5, 6.5); viewport (0.0,0.0,13.5,6.5); 
+(*scale (1.7,1.7, 0.0,0.0);*)
+(*clear pixels;*)
+ 
+INT VAR i; 
+move (4.0, 0.0); draw (4.0, 2.0); 
+move (5.5, 0.0); draw (5.5, 2.0); 
+FOR i FROM 0 UPTO 4 REP 
+  move (4.0, real (i) * 0.5); 
+  draw (5.5, real (i) * 0.5)
+END REP; 
+ 
+move (4.0, 3.0); draw (4.0, 6.0); 
+move (5.5, 3.0); draw (5.5, 6.0); 
+FOR i FROM 0 UPTO 6 REP 
+  move (4.0, real (i) * 0.5 + 3.0); 
+  draw (5.5, real (i) * 0.5 + 3.0) 
+END REP; 
+ 
+move (7.5, 2.0); draw (7.5, 6.0); 
+move (9.0, 2.0); draw (9.0, 6.0); 
+FOR i FROM 0 UPTO 8 REP 
+  move (7.5, real (i) * 0.5 + 2.0); 
+  draw (9.0, real (i) * 0.5 + 2.0) 
+END REP; 
+ 
+strichel (5.5, 6.0, 7.5, 6.0); 
+strichel (5.5, 3.0, 7.5, 3.0); 
+strichel (5.5, 1.0, 7.5, 3.0); 
+strichel (5.5, 0.0, 7.5, 2.0); 
+ 
+move (5.5, 4.75); draw (6.0, 4.75); 
+  draw (6.0, 1.75); draw (5.5, 1.75); 
+move (4.0, 3.75); draw (3.5, 3.75); 
+  draw (3.5, 1.25); draw (4.0, 1.25); 
+ 
+font size (0.4); font expansion (1.5); 
+move (0.0, 0.8); draw ("Koppeldatei"); 
+move (0.0, 4.3); draw ("Hauptdatei"); 
+move (10.0, 4.3); draw ("virtuelle"); 
+move (10.0, 3.4); draw ("Datei");
+ 
+font size (0.3); 
+move (4.5, 0.1); draw ("H2"); 
+move (4.5, 0.6); draw ("H1"); 
+move (4.5, 1.1); draw ("B"); 
+move (4.5, 1.6); draw ("A"); 
+move (4.5, 3.1); draw ("F4"); 
+move (4.5, 3.6); draw ("B"); 
+move (4.5, 4.1); draw ("F3"); 
+move (4.5, 4.6); draw ("A"); 
+move (4.5, 5.1); draw ("F2"); 
+move (4.5, 5.6); draw ("F1"); 
+move (8.0, 5.6); draw ("F1"); 
+move (8.0, 5.1); draw ("F2"); 
+move (8.0, 4.6); draw ("A"); 
+move (8.0, 4.1); draw ("F3"); 
+move (8.0, 3.6); draw ("B"); 
+move (8.0, 3.1); draw ("F4"); 
+move (8.0, 2.6); draw ("H1"); 
+move (8.0, 2.1); draw ("H2"); 
+ 
+PROC strichel (REAL CONST x anf, y anf, x end, y end) : 
+ 
+  REAL VAR laenge := x end - x anf; 
+  INT VAR teile := int (abstand/ 0.4); 
+  REAL VAR verhaeltnis := (y end - y anf) / laenge;
+  laenge := laenge / (real (2 * teile + 1)); 
+  INT VAR i; 
+  FOR i FROM 0 UPTO teile REP 
+    move (x anf + real (i + i) * laenge, 
+          y anf + verhaeltnis * real (i + i) * laenge); 
+    draw (x anf + real (i + i + 1) * laenge, 
+          y anf + verhaeltnis * real (i + i + 1) * laenge) 
+  END REP . 
+ 
+abstand : 
+  sqrt ((y end - y anf) + (y end - y anf) + 
+        (x end - x anf) * (x end - x anf)) . 
+ 
+END PROC strichel; 
+ 
+ 
+LET myname = "abb.9-2";
+save pixels (myname + ".p"); 
+FILE VAR f := sequential file (modify, myname + ".p"); 
+to line (f, 1); insert record (f); 
+write record (f, "#linefeed (0.8)#"); 
+insert record (f); write record (f, myname); 
+to eof (f); insert record (f); write record (f, myname); 
+to line (f, 1);
+(* 
+pause (9000);
+*)
+
diff --git a/app/eudas/4.4/doc/ref-manual/abb.9-3 b/app/eudas/4.4/doc/ref-manual/abb.9-3
new file mode 100644
index 0000000..9b190ab
--- /dev/null
+++ b/app/eudas/4.4/doc/ref-manual/abb.9-3
@@ -0,0 +1,113 @@
+init dgs; 
+window (0.0, 0.0, 13.5, 7.0); viewport (0.0,0.0,13.5,7.0); 
+(*scale (1.7,1.7, 0.0,0.0);*)
+(*clear pixels;*)
+ 
+x alignment (center); 
+font size (0.3); font expansion (1.2); 
+kasten (1.5, 5.0, 2.0, 1.5); 
+move (2.5, 5.9); draw ("EUDAS-"); 
+move (2.5, 5.3); draw ("Datei 1"); 
+move (3.5, 5.75); draw (4.0, 5.75); 
+kasten (4.0, 5.0, 2.0, 1.5); 
+move (5.0, 5.9); draw ("gekettete"); 
+move (5.0, 5.3); draw ("Datei A"); 
+move (6.0, 5.75); draw (6.5, 5.75);
+kasten (6.5, 5.0, 2.0, 1.5); 
+move (7.5, 5.9); draw ("gekettete"); 
+move (7.5, 5.3); draw ("Datei B"); 
+kasten (1.5, 2.0, 2.0, 1.5); 
+move (2.5, 2.9); draw ("gekoppelte"); 
+move (2.5, 2.3); draw ("Datei C");
+kasten (4.0, 0.0, 2.0, 1.5); 
+move (5.0, 0.9); draw ("gekoppelte"); 
+move (5.0, 0.3); draw ("Datei D"); 
+ 
+punkt (9.0, 5.75); 
+punkt (9.25, 5.75); 
+punkt (9.5, 5.75); 
+ 
+strichel (1.0, 4.5, 10.0, 4.5); 
+strichel (1.0, 7.0, 10.0, 7.0); 
+strichel (1.0, 4.5, 1.0, 7.0); 
+x alignment (right); font size (0.4);
+move (10.0, 3.9); 
+draw ("Hauptdatei"); 
+ 
+punkt (2.5, 3.75); 
+punkt (2.5, 4.0); 
+punkt (2.5, 4.25); 
+ 
+punkt (5.0, 1.75); 
+punkt (5.0, 2.0); 
+punkt (5.0, 2.25); 
+punkt (5.0, 2.5); 
+punkt (5.0, 2.75); 
+punkt (5.0, 3.0); 
+punkt (5.0, 3.25); 
+punkt (5.0, 3.5); 
+punkt (5.0, 3.75); 
+punkt (5.0, 4.0); 
+punkt (5.0, 4.25); 
+ 
+PROC punkt (REAL CONST x pos, y pos) : 
+ 
+  LET p size = 0.025;
+  move (x pos, y pos + p size); 
+  draw (x pos + p size, y pos); 
+  draw (x pos, y pos - p size); 
+  draw (x pos - p size, y pos); 
+  draw (x pos, y pos + p size) 
+ 
+END PROC punkt; 
+ 
+ 
+PROC strichel (REAL CONST x anf, y anf, x end, y end) : 
+ 
+  REAL VAR laenge := x end - x anf; 
+  INT VAR teile := int (abstand/ 0.4); 
+  REAL VAR senkrecht, verhaeltnis; 
+  IF laenge <> 0.0 THEN
+    verhaeltnis := (y end - y anf) / laenge; senkrecht := 1.0 
+  ELSE 
+    verhaeltnis := 1.0; senkrecht := 0.0 ; 
+    laenge := y end - y anf
+  END IF;
+  laenge := laenge / (real (2 * teile + 1)); 
+  INT VAR i; 
+  FOR i FROM 0 UPTO teile REP 
+    move (x anf + real (i + i) * laenge * senkrecht,
+          y anf + verhaeltnis * real (i + i) * laenge); 
+    draw (x anf + real (i + i + 1) * laenge * senkrecht,
+          y anf + verhaeltnis * real (i + i + 1) * laenge) 
+  END REP . 
+ 
+abstand : 
+  sqrt ((y end - y anf) * (y end - y anf) + 
+        (x end - x anf) * (x end - x anf)) . 
+ 
+END PROC strichel; 
+ 
+PROC kasten (REAL CONST x anf, y anf, x l, y l) : 
+ 
+  move (x anf, y anf); 
+  draw (x anf, y anf + y l); 
+  draw (x anf + x l, y anf + y l); 
+  draw (x anf +  x l, y anf); 
+  draw (x anf, y anf) 
+ 
+END PROC kasten;
+ 
+ 
+LET myname = "abb.9-3";
+save pixels (myname + ".p"); 
+FILE VAR f := sequential file (modify, myname + ".p"); 
+to line (f, 1); insert record (f); 
+write record (f, "#linefeed (0.8)#"); 
+insert record (f); write record (f, myname); 
+to eof (f); insert record (f); write record (f, myname); 
+to line (f, 1);
+(* 
+pause (9000)
+*)
+
diff --git a/app/eudas/4.4/doc/ref-manual/abb.9-4 b/app/eudas/4.4/doc/ref-manual/abb.9-4
new file mode 100644
index 0000000..e243265
--- /dev/null
+++ b/app/eudas/4.4/doc/ref-manual/abb.9-4
@@ -0,0 +1,98 @@
+init dgs; 
+window (0.0, 0.0, 13.5, 6.0); viewport (0.0,0.0,13.5,6.0);
+(*scale (1.7,1.7, 0.0,0.0);*)
+(*clear pixels;*)
+ 
+kasten (2.0, 1.0, 1.4, 2.0); 
+kasten (3.5, 1.0, 1.4, 2.0); 
+kasten (6.5, 1.0, 1.4, 2.0); 
+kasten (2.0, 3.4, 1.4, 2.0); 
+kasten (5.0, 3.4, 1.4, 2.0); 
+kasten (6.5, 3.4, 1.4, 2.0); 
+  strichel (3.5, 3.4, 3.5, 5.4); 
+  strichel (3.5, 5.4, 4.9, 5.4); 
+  strichel (4.9, 5.4, 4.9, 3.4); 
+  strichel (4.9, 3.4, 3.5, 3.4); 
+move (1.9, 2.7); draw (1.5, 2.7); 
+draw (1.5, 4.6); draw (1.9, 4.6);
+ 
+x alignment (center); 
+font size (0.3); font expansion (1.4); 
+ 
+move (2.7, 5.6); draw ("22-1"); 
+move (2.7, 4.9); draw ("X"); 
+move (2.7, 4.4); draw ("K"); 
+move (2.7, 2.5); draw ("K"); 
+move (2.7, 2.0); draw ("N1"); 
+move (2.7, 0.4); draw ("(114)"); 
+ 
+move (4.2, 5.6); draw ("22-2"); 
+move (4.2, 4.9); draw ("X"); 
+move (4.2, 4.4); draw ("K"); 
+move (4.2, 2.5); draw ("K"); 
+move (4.2, 2.0); draw ("N2"); 
+move (4.2, 0.4); draw ("(209)"); 
+ 
+move (5.7, 5.6); draw ("23-1"); 
+move (5.7, 4.9); draw ("Y"); 
+move (5.7, 4.4); draw ("L"); 
+ 
+move (7.2, 5.6); draw ("24-1"); 
+move (7.2, 4.9); draw ("Z"); 
+move (7.2, 4.4); draw ("M"); 
+move (7.2, 2.5); draw ("M"); 
+move (7.2, 0.4); draw ("(17)"); 
+ 
+font size (0.4); x alignment (normal);
+move (8.5, 2.0); draw ("Koppeldatei"); 
+move (8.5, 4.4); draw ("Hauptdatei"); 
+ 
+PROC strichel (REAL CONST x anf, y anf, x end, y end) : 
+ 
+  REAL VAR laenge := x end - x anf; 
+  INT VAR teile := int (abstand/ 0.4); 
+  REAL VAR senkrecht, verhaeltnis; 
+  IF laenge <> 0.0 THEN
+    verhaeltnis := (y end - y anf) / laenge; senkrecht := 1.0 
+  ELSE 
+    verhaeltnis := 1.0; senkrecht := 0.0 ; 
+    laenge := y end - y anf
+  END IF;
+  laenge := laenge / (real (2 * teile + 1)); 
+  INT VAR i; 
+  FOR i FROM 0 UPTO teile REP 
+    move (x anf + real (i + i) * laenge * senkrecht,
+          y anf + verhaeltnis * real (i + i) * laenge); 
+    draw (x anf + real (i + i + 1) * laenge * senkrecht,
+          y anf + verhaeltnis * real (i + i + 1) * laenge) 
+  END REP . 
+ 
+abstand : 
+  sqrt ((y end - y anf) * (y end - y anf) + 
+        (x end - x anf) * (x end - x anf)) . 
+ 
+END PROC strichel; 
+ 
+PROC kasten (REAL CONST x anf, y anf, x l, y l) : 
+ 
+  move (x anf, y anf); 
+  draw (x anf, y anf + y l); 
+  draw (x anf + x l, y anf + y l); 
+  draw (x anf +  x l, y anf); 
+  draw (x anf, y anf) 
+ 
+END PROC kasten;
+ 
+ 
+LET myname = "abb.9-4";
+save pixels (myname + ".p"); 
+FILE VAR f := sequential file (modify, myname + ".p"); 
+to line (f, 1); insert record (f); 
+write record (f, "#linefeed (0.8)#"); 
+insert record (f); write record (f, myname); 
+to eof (f); insert record (f); write record (f, myname); 
+to line (f, 1);
+(* 
+pause (9000)
+*)
+
diff --git a/app/eudas/4.4/doc/ref-manual/abb.9-5 b/app/eudas/4.4/doc/ref-manual/abb.9-5
new file mode 100644
index 0000000..c00655c
--- /dev/null
+++ b/app/eudas/4.4/doc/ref-manual/abb.9-5
@@ -0,0 +1,51 @@
+init dgs; 
+window (0.0, 0.0, 13.5, 7.0); viewport (0.0,0.0,13.5,7.0); 
+(*scale (1.7,1.7, 0.0,0.0);*)
+(*clear pixels;*)
+ 
+kasten (1.5, 0.0, 3.5, 2.0); 
+kasten (7.0, 0.0, 3.5, 2.0); 
+kasten (4.0, 4.0, 4.0, 3.0); 
+  kasten (5.0, 5.5, 2.0, 1.0); 
+ 
+move (3.25, 2.25); draw (4.75, 3.75); 
+  draw (4.5, 3.75); move (4.75, 3.75); draw (4.75, 3.5); 
+  move (3.25, 2.25); draw (3.5, 2.25); 
+  move (3.25, 2.25); draw (3.25, 2.5); 
+move (8.75, 2.25); draw (7.25, 3.75); 
+  draw (7.5, 3.75); move (7.25, 3.75); draw (7.25, 3.5);
+  move (8.75, 2.25); draw (8.5, 2.25); 
+  move (8.75, 2.25); draw (8.75, 2.5);
+ 
+x alignment (center); 
+font size (0.4); font expansion (1.4); 
+ 
+move (3.25, 0.2); draw ("Benutzer A"); 
+move (8.75, 0.2); draw ("Benutzer B"); 
+move (6.0, 4.3); draw ("Manager"); 
+font size (0.3);
+move (6.0, 5.6); draw ("Kunden"); 
+ 
+PROC kasten (REAL CONST x anf, y anf, x l, y l) : 
+ 
+  move (x anf, y anf); 
+  draw (x anf, y anf + y l); 
+  draw (x anf + x l, y anf + y l); 
+  draw (x anf +  x l, y anf); 
+  draw (x anf, y anf) 
+ 
+END PROC kasten;
+ 
+ 
+LET myname = "abb.9-5";
+save pixels (myname + ".p"); 
+FILE VAR f := sequential file (modify, myname + ".p"); 
+to line (f, 1); insert record (f); 
+write record (f, "#linefeed (0.8)#"); 
+insert record (f); write record (f, myname); 
+to eof (f); insert record (f); write record (f, myname); 
+to line (f, 1);
+(* 
+pause (9000)
+*)
+
diff --git a/app/eudas/4.4/doc/ref-manual/bildergenerator b/app/eudas/4.4/doc/ref-manual/bildergenerator
new file mode 100644
index 0000000..8129476
--- /dev/null
+++ b/app/eudas/4.4/doc/ref-manual/bildergenerator
@@ -0,0 +1,25 @@
+PROC starten : 
+ 
+  command dialogue (FALSE); 
+  disable stop; 
+  fetch (name, /"DGS NEC"); 
+  run (name); 
+  save (name + ".p", /"DGS NEC"); 
+  end (myself) 
+ 
+END PROC starten; 
+ 
+TEXT VAR name; 
+ 
+PROC gen (TEXT CONST t) : 
+ 
+  name := t; 
+  begin ("p", PROC starten, a); 
+  TASK VAR a; 
+  WHILE exists (a) REP pause (100) END REP 
+ 
+END PROC gen; 
+ 
+gen ("abb.4-2"); 
+gen ("abb.6-1");
+
diff --git a/app/eudas/4.4/doc/ref-manual/eudas.ref.1 b/app/eudas/4.4/doc/ref-manual/eudas.ref.1
new file mode 100644
index 0000000..4ca390a
--- /dev/null
+++ b/app/eudas/4.4/doc/ref-manual/eudas.ref.1
@@ -0,0 +1,323 @@
+#type ("prop")##limit (14.0)# 
+#format# 
+#page (3)# 
+#kapitel ("1", "Zustände", "und", "Bedienung")# 
+ 
+ 
+ 
+#abschnitt ("1.1", "ZUSTÄNDE", "Zustände")# 
+ 
+EUDAS befindet sich zu jeder Zeit in einem von 11 verschiedenen
+Zuständen. Für jeden Zustand ist festgelegt, welche Eingabetasten
+benutzt werden können und welche Wirkung sie haben. Bestimmte
+Tastenfunktionen führen in einen anderen Zustand. Obwohl für
+jeden Zustand andere Tastenkombinationen gültig sind, wird für die
+gleiche Funktion in jedem Zustand auch die gleiche Taste oder
+Tastenkombination verwendet. 
+    Die wichtigsten Tastenfunktionen eines Zustandes werden in
+der #on("i")#Statuszeile#off("i")# am oberen Bildschirmrand angezeigt. 
+    Im folgenden sind alle möglichen Zustände als Übersicht be­
+schrieben. Eine Übersicht der Zustandsübergänge enthält Abb. 1-1. 
+    Zu jedem Zustand wird die entsprechende Statuszeile darge­
+stellt sowie alle möglichen Tastenfunktionen und ihre Bedeutung. 
+ 
+#bildschirm# 
+EUDAS:   Öffnen   Einzelsatz   Gesamtdatei   Drucken   Dateien   Archiv 
+#text# 
+_____________________________________________________ 
+ 
+OBEN         Anwahl der nächsthöheren Funktion 
+UNTEN        Anwahl der nächsttieferen Funktion 
+RECHTS       Anwahl des nächsten Menüs zur Rechten 
+LINKS        Anwahl des nächsten Menüs zur Linken 
+HOP OBEN     Anwahl der ersten Funktion 
+HOP UNTEN    Anwahl der letzten Funktion 
+'1' .. '6'   Anwahl des entsprechenden Menüs 
+LEER         Ausführen der gewählten Funktion 
+'Buchstabe'  Ausführen der Funktion mit 'Buchstabe' davor 
+ESC '?'      Hilfestellung zur gewählten Funktion 
+ESC ESC      Eingabe von ELAN-Kommandos 
+ 
+ 
+#bildschirm# 
+HILFE:    Beenden: ESC q    Seite weiter: ESC w    Seite zurueck: ESC z 
+#text# 
+_____________________________________________________ 
+ 
+ESC 'w'      Blättern zur nächsten Seite 
+ESC 'z'      Blättern zur vorigen Seite 
+ESC 'q'      Verlassen (Rückkehr in alten Zustand) 
+ 
+ 
+#bildschirm# 
+AUSWAHL:  Ankreuzen: 'x'  Durchstreichen: 'o'  Beenden: ESC q  Hilfe: ESC ? 
+#text# 
+_____________________________________________________ 
+ 
+'x'          Auswahl ankreuzen 
+'o'          Ankreuzen rückgängig machen 
+LEER         Ankreuzen und Auswahl sofort verlassen 
+OBEN         Zur nächsten Auswahl nach oben 
+UNTEN        Zur nächsten Auswahl nach unten 
+HOP OBEN     Zur obersten Auswahl bzw. eine Seite zurück 
+HOP UNTEN    Zur untersten Auswahl bzw. eine Seite weiter 
+HOP RETURN   Aktuelle Auswahl wird erste auf der Seite 
+ESC '1'      zur ersten Auswahl 
+ESC '9'      zur letzten Auswahl 
+ESC 'q'      Auswahl verlassen und weitermachen 
+ESC '?'      Hilfe zur Auswahl 
+HOP 'x'      alle freien Wahlen ankreuzen 
+HOP 'o'      alle Kreuze entfernen 
+ESC 'h'      Auswahl und Funktion abbrechen 
+ 
+ 
+#bildschirm# 
+EINGABE:  Bestätigen: RETURN  Zeigen: ESC z  Abbrechen: ESC h  Hilfe: ESC ? 
+#text# 
+_____________________________________________________ 
+ 
+RECHTS       zum nächsten Zeichen 
+LINKS        zum vorigen Zeichen 
+HOP RECHTS   zum letzten Zeichen 
+HOP LINKS    zum ersten Zeichen 
+RUBOUT       Zeichen löschen 
+RUBIN        Einfügemodus umschalten 
+HOP RUBOUT   Rest der Zeile löschen 
+'Zeichen'    Zeichen überschreiben oder einfügen 
+RETURN       Eingabe abschließen und weitermachen 
+ESC '?'      Hilfe zur Eingabe 
+ESC 'h'      Eingabe und Funktion abbrechen 
+ESC 'z'      Auswahl zeigen (falls in Statuszeile aufgeführt) 
+ 
+ 
+#bildschirm# 
+FRAGE:   Bejahen: j,J   Verneinen: n,N   Abbrechen: ESC h   Hilfe: ESC ? 
+#text# 
+_____________________________________________________ 
+ 
+'j', 'J'     Frage bejahen 
+'n', 'N'     Frage verneinen 
+ESC '?'      Hilfe zur Frage 
+ESC 'h'      Frage und Funktion abbrechen 
+ 
+ 
+#bildschirm# 
+!!! FEHLER !!!     Quittieren: ESC q     Hilfe zur Meldung: ESC ? 
+#text# 
+_____________________________________________________ 
+ 
+ESC '?'      Hilfe zum Fehler 
+ESC 'Taste'  Fehler quittieren 
+'Taste'      Fehler quittieren 
+ 
+ 
+#bildschirm# 
+SATZ ÄNDERN:    Abbruch: ESC h    Beenden: ESC q    Hilfe: ESC ? 
+SATZ EINFÜGEN:    Abbruch: ESC h    Beenden: ESC q    Hilfe: ESC ? 
+SUCHMUSTER EINGEBEN:    Abbruch: ESC h    Beenden: ESC q    Hilfe: ESC ? 
+#text# 
+_____________________________________________________ 
+ 
+ESC OBEN     eine Seite zurück blättern 
+ESC UNTEN    eine Seite vor blättern 
+ESC '?'      Hilfe zum Satzeditor 
+ESC 'p'      ganzen Satz merken (nicht bei Suchmuster) 
+ESC 'g'      Satz durch gemerkten ersetzen (nicht bei Such­
+             muster) 
+ESC 'h'      Abbruch der Funktion 
+ESC 'D'      Tagesdatum schreiben 
+ESC 'F'      Prüffehler nach Tragen editieren 
+ESC 'w'      Verlassen und mit nächstem Satz erneut aufrufen
+             (nicht im Suchmuster) 
+ESC 'z'      Verlassen und mit vorigem Satz erneut aufrufen
+             (nicht im Suchmuster) 
+ESC RUBIN    Rest der Zeile in neue Zeile umbrechen 
+ESC RUBOUT   Rest der Zeile löschen 
+HOP RUBIN    nicht verwenden! 
+HOP RUBOUT   nicht verwenden! 
+#f2# 
+Weitere Tasten siehe EUMEL-Benutzerhandbuch (Editor). 
+ 
+ 
+#bildschirm# 
+Bitte warten.. 
+#text# 
+_____________________________________________________ 
+ 
+keine Tasten erlaubt (außer SV) 
+ 
+ 
+#bildschirm# 
+ZEIGEN:   Blättern: HOP OBEN, HOP UNTEN   Ende: ESC q   Hilfe: ESC ? 
+#text# 
+_____________________________________________________ 
+ 
+HOP OBEN     auf erste Zeile bzw. eine Seite zurück 
+HOP UNTEN    auf letzte Zeile bzw. eine Seite vor 
+ESC '?'      Hilfe zur Übersicht 
+ESC 'h'      Abbruch der Funktion 
+ESC 'q'      Verlassen 
+ 
+ 
+#bildschirm# 
+EDITIEREN:   Abbruch: ESC h   Verlassen: ESC q   Hilfe: ESC ? 
+#text# 
+_____________________________________________________ 
+ 
+ESC 'F'      Feldnamen anzeigen und auswählen 
+ESC 'h'      Abbruch der Funktion 
+#f2# 
+Weitere Tasten siehe EUMEL-Benutzerhandbuch (Editor). 
+ 
+ 
+#bildschirm# 
+Gib Kommando: 
+#text# 
+_____________________________________________________ 
+ 
+Tasten siehe EINGABE. 
+ 
+ 
+#free (18.5)# 
+#beispiel# 
+#center#Abb. 1-1   Zustandsübergänge 
+#text# 
+ 
+ 
+ 
+#abschnitt ("1.2", "MENÜS", "Menüs")# 
+ 
+Menüs dienen zur Auswahl von Funktionen. Sie werden am linken
+Rand des Bildschirms angezeigt. Welches Menü aktiv ist, wird durch
+Markierung des Menünamens in der obersten Bildschirmzeile unter
+allen zur Verfügung stehenden Menüs angezeigt. In jedem Menü ist
+die zuletzt ausgeführte Funktion ebenfalls markiert. 
+ 
+#a ("Ausführen von Funktionen")# Zum Ausführen einer bestimmten Funk­
+tion wird mit Hilfe der Cursortasten ein bestimmtes Menü und die
+gewünschte Funktion angewählt. Die Funktion wird dann durch
+Drücken der Leertaste ausgeführt. Alternativ kann auch der vor der
+Funktion stehende Buchstabe gedrückt werden. 
+    Die einzelnen Menüs können auch durch Nummern (1 bis 6)
+angewählt werden (absolute Positionierung). 
+    Soll eine andere Taste als die Leertaste zum Ausführen ver­
+wendet werden, so kann dies durch die Prozedur 'ausfuehrtaste'
+angegeben werden (s. Abschnitt 10.3). 
+    Funktionen, deren Ausführung augenblicklich nicht möglich
+oder nicht sinnvoll ist, werden durch ein vorangestelltes Minuszei­
+chen gekennzeichnet. Sie können zwar angewählt, nicht aber ausge­
+führt werden. 
+    Durch ESC '?' wird ein erläuternder Hilfstext zur gerade ange­
+wählten Funktion angezeigt. Näheres dazu s. Abschnitt 1.4. 
+    Durch ESC ESC kann ein beliebiges ELAN-Kommando eingegeben
+und ausgeführt werden. Die Eingabe des Kommandos erfolgt in der
+Statuszeile. 
+ 
+ 
+#abschnitt ("1.3", "AUSWAHL", "Auswahl")# 
+ 
+Die Auswahlfunktion dient dazu, aus vorhandenen Datei- oder
+Feldnamen in bestimmter Reihenfolge auszuwählen. Die einzelnen
+Namen werden untereinander aufgelistet. 
+    Vor jedem Namen ist ein 'o' zum Ankreuzen angegeben. Mit den
+Cursortasten kann der Cursor vor einen bestimmten Namen positio­
+niert werden. Mit 'x' kann dieser Name dann angekreuzt werden. Das
+Ankreuzen kann durch 'o' wieder rückgängig gemacht werden. 
+    Die Reihenfolge des Ankreuzens wird durch vorangestellte
+Nummern gekennzeichnet. Die Namen werden von der entsprechenden
+Funktion später in genau dieser Reihenfolge verwendet. 
+    Wenn nicht alle Namen auf den Bildschirm passen, kann die
+Darstellung gerollt werden. Ein Teil der Überschrift bleibt dabei
+stehen; am Anfang und am Ende wird jeweils eine Abschlußzeile zur
+Kennzeichnung mitgerollt. 
+    Mit ESC '?' kann eine Hilfestellung abgerufen werden. Mit ESC
+'q' wird die Auswahl beendet. Mit ESC 'h' können die Auswahl und
+die in Ausführung befindliche Operation abgebrochen werden. 
+ 
+ 
+#abschnitt ("1.4", "HILFE UND DIALOG", "Hilfe und Dialog")# 
+ 
+In den meisten Situationen kann durch ESC '?' eine spezifische
+Hilfestellung abgerufen werden. Die Anzeige der Hilfsinformation
+geschieht im rechten Bildschirmteil. 
+    Die Texte sind seitenweise aufgebaut. Es wird immer eine Seite
+angezeigt. Mit ESC 'w' bzw. ESC 'z' kann auf die nächste bzw, vorige
+Seite umgeblättert werden. Mit ESC 'q' wird die Hilfestellung wieder
+verlassen und die Situation wiederhergestellt, in der die Hilfe auf­
+gerufen wurde. 
+ 
+#a ("Fragen")# Die meisten Funktionen wickeln zur Eingabe von zusätz­
+lichen Parametern oder zum Stellen von Fragen einen Dialog in der
+unteren Schirmhälfte ab. Es gibt zwei Möglichkeiten des Dialogs:
+eine Frage oder die Eingabe eines Textes. 
+    Bei einer Frage kann man mit 'j' oder 'n' antworten. Sowohl
+große als auch kleine Buchstaben werden akzeptiert. Mit ESC '?'
+kann eine Hilfsinformation zu der Frage abgerufen werden. ESC 'h'
+bricht die fragende Funktion ab. 
+ 
+#a ("Eingabe")# Bei der Eingabe eines Textes können die üblichen Opera­
+tionen zum Editieren in einer Zeile verwendet werden. Die Eingabe
+wird durch RETURN beendet. Auch hier kann durch ESC '?' eine
+Hilfsinformation abgerufen werden. ESC 'h' bricht ebenfalls die fra­
+gende Funktion ab. In einigen Fällen (ersichtlich aus der Statuszei­
+le) kann durch ESC 'z' eine Auswahl der verfügbaren Namen abgeru­
+fen werden. 
+ 
+ 
+#abschnitt ("1.5", "EDITOR", "Editor")# 
+ 
+Der EUMEL-Editor wird in EUDAS auf zweierlei Weise aufgerufen.
+Zum einen dient er im Satzformular zum Eingeben von Daten und
+Suchmustern. Dort wird er als #on("i")#Satzeditor#off("i")# bezeichnet. Da hier die
+Feldnamen mit berücksichtigt werden müssen, gibt es einige Unter­
+schiede zum normalen Editor. 
+    An anderen Stellen wird der Editor ohne Änderungen eingesetzt
+zum Eingeben von Feldnamen oder Mustern. In diesem Fall finden
+Sie die Bedienungshinweise im EUMEL-Benutzerhandbuch. 
+ 
+#a ("Satzeditor")# Beim Ändern, Einfügen und Eingeben des Suchmusters
+wird im EUDAS-Formular der Editor aufgerufen. Das Editorfenster
+beschränkt sich auf den rechten Teil des Formulars, der einen Teil
+der Überschrift und die Feldinhalte umfaßt. Im Satzeditor können
+dann die entsprechenden Inhalte eingegeben bzw. verändert werden. 
+    Rollen unter Beibehaltung der Korrespondenz ist durch ESC
+OBEN und ESC UNTEN möglich. Diese Funktionen wirken wie bei der
+Anzeige - das Editorfenster wird ebenfalls entsprechend mitgerollt.
+Mit ESC '1' kann wie üblich auf die erste, mit ESC '9' auf die letzte
+Zeile gesprungen werden. Auch diese Funktionen passen die Feld­
+namen entsprechend an. 
+    Falls die für ein Feld vorgesehenen Zeilen nicht für den Inhalt
+ausreichen, kann durch ESC RUBIN eine weitere Zeile für dieses Feld
+bereitgestellt werden. ESC RUBIN wirkt wie zweimal HOP RUBIN, die
+Korrespondenz mit den Feldnamen bleibt jedoch gewahrt. 
+    Zum Löschen steht ESC RUBOUT zur Verfügung. Es löscht eine
+ganze Zeile, aber nur, wenn für dieses Feld noch andere Zeilen zur
+Verfügung stehen, wird die Zeile tatsächlich vom Bildschirm ent­
+fernt. Im Normalfall bleibt sonst eine Leerzeile für dieses Feld ste­
+hen. 
+    Ist die Information für ein Feld auf mehrere Zeilen verteilt, so
+werden diese Zeilen zur Verarbeitung aneinandergehängt. Gegebe­
+nenfalls wird zwischen zwei Zeilen noch ein Leerzeichen eingefügt. 
+    Der Editor kann wie üblich mit ESC 'q' verlassen werden. ESC
+'h' bricht die Funktion ab, ohne die erfolgten Änderungen und Ein­
+gaben zu berücksichtigen. Mit ESC 'w' und ESC 'z' kann das Bearbei­
+ten von mehreren Sätzen beschleunigt werden. Durch diese Tasten­
+kombinationen wird der Editor verlassen und die gleiche Operation
+(Ändern/Einfügen) beim nächsten bzw. vorigen Satz wiederholt. 
+ 
+#a ("Hinweis")# Aus technischen Gründen kann das Editorfenster gegen­
+über den Feldnamen verschoben werden (durch Rollen mit HOP
+UNTEN zum Beispiel). Dabei geht die sichtbare Korrespondenz zwi­
+schen Feldnamen und Feldinhalten verloren. Ein solcher Fall wird
+durch einen markierten Balken mit entsprechender Meldung ange­
+zeigt. Durch ESC '1' wird das Fenster aber wieder zurechtgerückt. 
+    Aus diesem Grund sollte im Satzeditor auf HOP OBEN und HOP
+UNTEN sowie auf RETURN am Ende des Fensters verzichtet werden.
+Auch HOP RUBIN und HOP RUBOUT sollten nicht verwendet werden,
+weil auf diese Weise die Anzahl der Zeilen verändert wird. Eine
+solche Störung kann nicht durch ESC '1' beseitigt werden. Von Hand
+müssen die entsprechenden Zeilen wieder gelöscht oder eingefügt
+werden. 
+ 
+ 
+
diff --git a/app/eudas/4.4/doc/ref-manual/eudas.ref.10 b/app/eudas/4.4/doc/ref-manual/eudas.ref.10
new file mode 100644
index 0000000..2478130
--- /dev/null
+++ b/app/eudas/4.4/doc/ref-manual/eudas.ref.10
@@ -0,0 +1,394 @@
+#type ("prop")##limit (14.0)# 
+#format# 
+#page (97)# 
+#kapitel ("10", "Programmierung", "der", "Menüs")# 
+ 
+ 
+ 
+#abschnitt ("10.1", "MENÜFORMAT", "Menüformat")# 
+ 
+EUDAS verwendet drei verschiedene Strukturen zur Benutzerunter­
+stützung: Menü, Auswahl und Hilfestellung. Ein Menü dient zur
+Auswahl von Funktionen, eine Auswahl bietet Feld- oder Datei­
+namen an und eine Hilfestellung zeigt einen Informationstext. 
+    Alle diese Strukturen werden aus einer Initialisierungsdatei
+eingelesen. Die Initialisierungsdatei ist eine normale Textdatei. Ihr
+Format soll in diesem Abschnitt beschrieben werden. 
+    Die Strukturen können in beliebiger Reihenfolge in der Initiali­
+sierungsdatei stehen. Jede Struktur wird durch eine spezielle
+Anweisung eingeleitet. Anweisungen beginnen ähnlich wie im
+Druckmuster mit einem Prozentzeichen. Dementsprechend gibt es die
+drei Anweisungen 
+ 
+#beispiel# 
+    % MENUE "Name" 
+    % AUSWAHL "Name" 
+    % HILFE "Gebiet/Name" 
+#text# 
+ 
+die jeweils eine Struktur einleiten. Beendet wird eine Definition
+immer mit 
+ 
+#beispiel# 
+    % ENDE 
+#text# 
+ 
+#a ("Menü")# Für ein Menü wird noch der Text angegeben, der auf dem
+Bildschirm erscheinen soll. Er wird durch die Anweisung 
+ 
+#beispiel# 
+    % BILD 
+#text# 
+ 
+eingeleitet. Danach folgen Zeilen mit dem Bildschirminhalt in der
+gewünschten Größe (die tatsächliche Anzeigegröße wird erst beim
+Aufruf angegeben). Dabei werden die Auswahlpositionen, auf denen
+der Cursor sich bewegen kann, durch ein geschütztes Leerzeichen in
+Spalte 2 festgelegt. 
+    Nach der Angabe des Bildes muß für jede mögliche Auswahl­
+position noch eine weitere Angabe gemacht werden. Die Auswahl­
+positionen (oder Felder) werden dabei von oben nach unten durch­
+gezählt. Begonnen wird mit der Nummer 1. 
+    Eine Felddefinition hat das Format 
+ 
+#beispiel# 
+    % FELD nr "Hilfstext" "Tasten" 
+#text# 
+ 
+Die Nummer identifiziert das Feld. Der Hilfstext gibt den Namen der
+Hilfestellung an, die gezeigt werden soll, wenn auf diesem Feld ESC
+'?' gedrückt wird. Die Tasten sind alle Zeichen, die gedrückt werden
+können, um dieses Feld direkt auszuführen. 
+    Anschließend an die Felddefinition kann in weiteren Zeilen
+noch ein ELAN-Programm folgen, das bei Auswahl des Feldes aus­
+geführt wird. 
+ 
+#a ("Auswahl")# Für eine Auswahl muß zuerst ein Vorspann angegeben
+werden, der immer in den ersten Bildschirmzeilen der Auswahl an­
+gezeigt wird. Dieser wird durch 
+ 
+#beispiel# 
+    % VORSPANN 
+#text# 
+ 
+eingeleitet. Danach folgt das Bild. Das Bild setzt sich aus drei Tei­
+len zusammen. Die erste Zeile, in der ein geschütztes Leerzeichen
+vorkommt, bildet den Wiederholungsteil. Diese Zeile wird nachher so
+oft wie nötig mit entsprechenden Inhalten wiederholt, wobei das
+geschützte Leerzeichen als Bindestrich dargestellt wird, auf dem
+sich der Cursor bewegen kann. Die Teile davor und danach werden
+jeweils bei Bedarf mitgerollt. 
+    Die Wiederholungszeile darf mehrere geschützte Leerzeichen
+enthalten. Die Inhalte werden dann in mehreren Spalten angezeigt.
+Zu beachten ist, daß vor einem Trennstrich noch mindestens fünf
+Zeichen Platz für eine laufende Nummer bleiben müssen. 
+ 
+#a ("Hilfe")# Der Name einer Hilfestellung setzt sich aus zwei Teilen
+zusammen, die durch einen Schrägstrich getrennt werden. Der erste
+Name gibt die Kategorie der Hilfestellung an, der zweite Name den
+Einzeltext. Dies dient dazu, die relativ große Zahl der Hilfstexte
+überschaubar zu machen. Als Beispiel 
+ 
+#beispiel# 
+    % HILFE "JA/Allgemein" 
+#text# 
+ 
+Eine Hilfestellung besteht einfach aus mehreren Seiten Text. Jede
+Seite wird durch die AnweisungQ
+ 
+#beispiel# 
+Q̈Q̈Q̈Q̈Q̈Q̈Q̈Q
+#text# 
+ 
+
+
+
+
+
+ 
+#beispiel# 
+
+#text# 
+ 
+
+
+
+Text folgen. 
+ 
+ 
+
+ 
+
+
+
+
+hinzugefügt. 
+
+
+
+
+
+
+
+ 
+#proc# 
+
+#endproc# 
+
+
+
+
+ 
+#proc# 
+
+#endproc# 
+
+    deutung: 
+
+
+
+
+
+
+ 
+#proc# 
+
+#endproc# 
+
+
+ 
+#proc# 
+
+#endproc# 
+
+
+
+ 
+#proc# 
+
+#endproc# 
+
+
+
+ 
+#proc# 
+
+
+
+#endproc# 
+
+
+
+ 
+#beispiel# 
+
+
+
+ 
+
+
+
+
+        ELSE 
+
+
+ 
+
+ 
+
+
+#text# 
+ 
+ 
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+selbst. 
+ 
+#proc# 
+
+
+
+
+#endproc# 
+
+
+
+
+
+
+
+
+#f2# 
+
+
+
+
+
+#f2# 
+
+
+
+
+
+
+
+
+
+
+
+
+#f2# 
+    FEHLER: 
+#f1# 
+
+
+ 
+#proc# 
+
+
+#endproc# 
+
+
+
+ 
+#proc# 
+
+#endproc# 
+
+
+#f2# 
+    FEHLER: 
+#f1# 
+
+
+
+ 
+#proc# 
+
+
+
+#endproc# 
+
+
+
+
+
+#f2# 
+    FEHLER: 
+#f1# 
+
+
+ 
+#proc# 
+
+#endproc# 
+
+
+
+ 
+#proc# 
+
+#endproc# 
+
+
+
+#f2# 
+    FEHLER: 
+#f1# 
+
+
+ 
+#proc# 
+
+#endproc# 
+
+ 
+ 
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+#proc# 
+
+#endproc# 
+
+
+ 
+#proc# 
+PROC dialog 
+#endproc# 
+
+
+
+ 
+#proc# 
+
+#endproc# 
+
+
+ 
+#proc# 
+
+#endproc# 
+
+
+
+ 
+#proc# 
+
+
+#endproc# 
+
+
+
+
+
+ 
+#proc# 
+
+#endproc# 
+
+
+
+
+    den. 
+ 
+
diff --git a/app/eudas/4.4/doc/ref-manual/eudas.ref.11 b/app/eudas/4.4/doc/ref-manual/eudas.ref.11
new file mode 100644
index 0000000..3c555d1
--- /dev/null
+++ b/app/eudas/4.4/doc/ref-manual/eudas.ref.11
@@ -0,0 +1,327 @@
+#type ("prop")##limit (14.0)# 
+#format# 
+#page (105)# 
+#kapitel ("11", "Programmierung", "von", "Anwendungen")# 
+ 
+ 
+ 
+Zur Realisierung eigener EUDAS-Anwendungen mit Hilfe von ELAN-
+Programmen gibt es mehrere Möglichkeiten mit zunehmender Lei­
+stungsfähigkeit, aber auch steigender Komplexität und Fehleranfäl­
+ligkeit. In den folgenden Abschnitten werden die drei wesentlichen
+Methoden vorgestellt. Sie sollten erst dann eine kompliziertere
+Methode in Angriff nehmen, wenn Sie die einfachere beherrschen. 
+ 
+ 
+#abschnitt ("11.1", "MUSTERPROGRAMME", "Musterprogramme")# 
+ 
+Die bevorzugte Methode zur Erstellung eigener Anwendungen unter
+EUDAS ist die Programmierung von Mustern. EUDAS läßt dies bei
+Druckmustern, Kopiermustern und Änderungsmustern zu. 
+    In diesem Fall steuert EUDAS den Ablauf des Programms im
+groben automatisch. Die jeweils unterschiedlichen Anweisungen, was
+im einzelnen zu tun ist, werden in ELAN programmiert. Aus dem
+Muster mit diesen zusätzlichen Anweisungen generiert EUDAS dann
+das Programm und führt es mit Hilfe des ELAN-Compilers aus. 
+ 
+#a ("Vorteile")# Diese Methode hat den Vorteil, daß nur die minimal not­
+wendigen Anweisungen tatsächlich selbst programmiert werden
+müssen. Dafür reichen bereits geringe ELAN-Kenntnisse vollkommen
+aus. Ein Muster kann relativ schnell erstellt und getestet werden.
+Durch den einfachen Aufbau ist auch die Fehlerwahrscheinlichkeit
+beim Entwickeln geringer als bei anderen Methoden. 
+    Daneben lassen sich die Musterprogramme jeweils bequem im
+Menü durch Angabe des Namens oder durch Ankreuzen ausführen,
+also auch durch unbedarfte Benutzer. 
+ 
+#a ("Nachteile")# Nachteil dieser Methode ist, daß jeweils beim Aufruf das
+Programm nochmal neu erzeugt und übersetzt werden muß, da die
+Übersetzung auch von der gerade geöffneten Datei abhängt. Dies
+stört besonders bei umfangreichen Druckmustern (auf langsamen
+Rechnern). 
+    Zum zweiten wird ein umfangreiches Druckmuster auch bald
+unübersichtlich, da Strukturierungshilfen für größere Programme
+fehlen. Der eigentliche Mustertext ist dann schwer von den zahlrei­
+chen Abkürzungen zu trennen. 
+    Als Abhilfe für diese beiden Nachteile bietet es sich an, um­
+fangreichere Abkürzungen bzw. Ausdrücke eingebettet in ein
+ELAN-Paket aus dem Muster herauszunehmen und vorher zu in­
+sertieren. 
+    Dadurch fällt zum einen die ständige Neuübersetzung dieser
+Ausdrücke weg, zum anderen ist das eigentliche Muster wieder
+überschaubar. Voraussetzung zur Anwendung eines solchen Musters
+ist dann jedoch, daß das zugehörige Paket in der jeweiligen Task
+bereits vorher übersetzt wurde. 
+    Die nachfolgenden Beispiele zeigen, wie dieses Verfahren in der
+Realität aussehen kann. 
+ 
+#a ("Beispiel 1")# In der Schulverwaltung soll ein Kopier- oder Ände­
+rungsmuster erstellt werden, das die Versetzung am Schuljahresende
+realisiert. Angenommen wird eine Datei, die alle Schüler enthält.
+Schüler, die nicht versetzt werden, sind vorher im Feld 'Versetzung'
+mit einem beliebigen Text gekennzeichnet worden (zum Beispiel
+'Nachprüfung' o.ä.). 
+    Die Versetzung kann auf zweierlei Weise erfolgen: zum einen
+durch automatische Änderung, wenn die alte Version noch auf einer
+Archivdiskette aufgehoben wird, oder durch Kopieren in eine neue
+Datei. 
+    Bei beiden Mustern ist die einzige Änderung die Angabe der
+neuen Klasse. Daher bietet es sich an, eine Prozedur 'neue klasse'
+zu definieren, die als Ergebnis die neue Klasse eines Schülers lie­
+fert. Diese Prozedur kann dann im Änderungsmuster wie folgt ver­
+wendet werden: 
+ 
+#beispiel# 
+        "Klasse" V neue klasse; 
+#text# 
+ 
+Entsprechend läuft die Verwendung im Kopiermuster: 
+ 
+#beispiel# 
+        "Name" K f ("Name"); 
+        "Vorname" K f ("Vorname"); 
+        "Klasse" K neue klasse; 
+        ... 
+#text# 
+ 
+Die Prozedur 'neue klasse' muß dann in einem Paket definiert wer­
+den, das etwa folgendes Aussehen haben könnte (spezifische Ände­
+rungen natürlich möglich): 
+ 
+#beispiel# 
+    PACKET klassenwechsel DEFINES neue klasse: 
+ 
+    TEXT PROC neue klasse : 
+ 
+      IF f ("Versetzung") = "" THEN 
+        klasse um 1 erhoeht 
+      ELSE 
+        alte klasse ohne zusatz 
+      END IF . 
+ 
+    klasse um 1 erhoeht : 
+      INT CONST alte klasse := int (f ("Klasse")); 
+      IF alte klasse < 9 THEN 
+        "0" + text (alte klasse + 1) + zusatz 
+      ELSE 
+        text (alte klasse + 1) + zusatz 
+      END IF . 
+ 
+    zusatz : 
+      f ("Klasse") SUB 3. 
+ 
+    alte klasse ohne zusatz : 
+      subtext (f ("Klasse"), 1, 2) . 
+ 
+    END PROC neue klasse; 
+ 
+    END PACKET klassenwechsel; 
+#text# 
+ 
+Schüler, die versetzt werden, erhalten ihre neue Jahrgangsstufe mit
+dem alten Klassenzusatz zugeteilt. Dabei ist darauf zu achten, daß
+die Klassen 5 bis 9 eine '0' vorangestellt bekommen, damit die
+Sortierung funktioniert. 
+    Schüler, die nicht versetzt werden, behalten ihre alte Jahr­
+gangsstufe, allerdings ohne einen Klassenzusatz, der ihnen an­
+schließend manuell zugewiesen werden muß. 
+    Zur Benutzung muß das oben angegebene Paket in eine Text­
+datei geschrieben und mit dem Kommando 'insert' fest insertiert
+werden. 
+ 
+#a ("Beispiel 2")# Aus einer Datei mit bibliographischen Einträgen sollen
+bestimmte Literaturhinweise gedruckt werden. Der Literaturhinweis
+soll jeweils als Endlostext umbrochen werden. Dafür müssen in einer
+Abkürzung alle Daten verkettet werden. Es sei das folgende ein­
+fache Druckmuster vorgegeben: 
+ 
+#beispiel# 
+    % WIEDERHOLUNG 
+    % MODUS 3 
+    [&<krz>]    &titel 
+ 
+    % ABKUERZUNGEN 
+    &krz :  f ("Kurzbez") .    (* z.B. "Lew84" *) 
+    &titel :  titel lang . 
+#text# 
+ 
+Die Prozedur 'titel lang' wird in folgendem Paket definiert: 
+ 
+#beispiel# 
+    PACKET bibliographie DEFINES titel lang : 
+ 
+    TEXT VAR puffer;   (* verringert Heap-Belastung *) 
+ 
+    TEXT PROC titel lang : 
+ 
+      puffer := f ("Name 1"); 
+      puffer CAT ", "; 
+      puffer CAT f ("Vorname 1"); 
+      ggf weitere namen; 
+      titel kursiv; 
+      enthalten in; 
+      erscheinungsort und jahr; 
+      puffer . 
+ 
+    ggf weitere namen: 
+      IF f ("Name 2") <> "" THEN 
+        puffer CAT "; "; 
+        puffer CAT f ("Name 2") 
+      END IF . 
+ 
+    titel kursiv : 
+      puffer CAT "   \#on (""i"")\#"; 
+      puffer CAT f ("Titel"); 
+      puffer CAT "\#off (""i"")\#, " . 
+ 
+    enthalten in : 
+      IF f ("in") <> "" THEN 
+        puffer CAT " in: "; 
+        puffer CAT f ("in"); 
+        puffer CAT ", " 
+      END IF . 
+ 
+    erscheinungsort und jahr : 
+      puffer CAT f ("Ort"); 
+      puffer CAT ", "; 
+      puffer CAT f ("Jahr") . 
+ 
+    END PROC titel lang; 
+ 
+    END PACKET bibliographie; 
+#text# 
+ 
+Die Puffervariable wird verwendet, um die bei Verwendung des
+Operators '+' entstehende Heapbelastung zu verringern. An diese
+Variable werden nacheinander alle notwendigen Daten mit den ent­
+sprechenden Trennzeichen angehängt. 
+    Im Druckmuster wird dieser lange Text dann im Modus 3 auf
+mehrere Zeilen umbrochen, wobei die Einrückung erhalten bleibt. Die
+Druckausgabe kann dann bei Bedarf noch mit 'lineform' bearbeitet
+werden, um einen noch besseren Umbruch zu erzielen. 
+ 
+ 
+#abschnitt ("11.2", "DATEIANWENDUNGEN", "Dateianwendungen")# 
+ 
+Die zweite Möglichkeit der Programmierung unter EUDAS besteht
+darin, ELAN-Programme zu schreiben, die EUDAS-Dateien mit Hilfe
+des in Kapitel 6 beschriebenen Datentyps EUDAT manipulieren. Die
+Programmierung gestaltet sich ähnlich wie mit FILEs. 
+ 
+#a ("Vorteile")# Durch dieses Verfahren haben Sie volle Freiheit der Pro­
+grammierung. Da lediglich die Struktur der EUDAS-Dateien als
+Datenspeicher verwendet wird, sind sehr viele Anwendungen denk­
+bar. 
+    Außerdem können so beliebig viele Dateien gleichzeitig bear­
+beitet werden. Da die Programme nicht auf die virtuelle Datei zu­
+greifen, ist ein Konflikt mit dem aktuellen Zustand von EUDAS
+nahezu ausgeschlossen. 
+ 
+#a ("Nachteile")# Der Nachteil dieses Verfahrens ist, daß viele Dinge
+selbst programmiert werden müssen, so zum Beispiel das Durchgehen
+einer Datei. Auch die Hilfsmittel der virtuellen Datei wie Such­
+muster, Koppeln und alle Anwendungen, die auf die virtuelle Datei
+zugreifen, stehen nicht zur Verfügung. 
+ 
+#a ("Beispiel 1")# Die in Abschnitt 6.6 vorgestellte Anwendung als Asso­
+ziativspeicher kann als Beispiel für diese Methode dienen. 
+ 
+#a ("Beispiel 2")# Eine EUDAS-Datei (zum Beispiel eine Schülerdatei) soll
+in mehrere Dateien aufgespalten werden (zum Beispiel klassen­
+weise). Dies kann durch das folgende Beispielprogramm bewirkt
+werden: 
+ 
+#beispiel# 
+    LET 
+      klassenfeld = 3, 
+      quellname = "Schüler", 
+      zielname = "Jahrgang "; 
+    ROW 9 EUDAT VAR ziel; 
+    EUDAT VAR quelle; 
+    SATZ VAR feldnamen; 
+ 
+    quelle oeffnen; 
+    zieldateien einrichten; 
+    auf satz (quelle, 1); 
+    WHILE NOT dateiende (quelle) REP 
+      aktuellen satz kopieren; 
+      weiter (quelle) 
+    END REP . 
+ 
+    quelle oeffnen : 
+      oeffne (quelle, quellname); 
+      feldnamen lesen (quelle, feldnamen) . 
+ 
+    zieldateien einrichten : 
+      INT VAR i; 
+      FOR i FROM 1 UPTO 9 REP 
+        oeffne (ziel (i), zielname + text (i + 4)); 
+        feldnamen aendern (ziel (i), feldnamen) 
+      END REP . 
+ 
+    aktuellen satz kopieren : 
+      SATZ VAR satz; 
+      satz lesen (quelle, satz); 
+      satz einfuegen (ziel (stufe), satz); 
+      weiter (ziel (stufe)) . 
+ 
+    stufe : 
+      TEXT VAR klasse; 
+      feld lesen (satz, klassenfeld, klasse); 
+      int (klasse) - 4 . 
+#text# 
+ 
+ 
+#abschnitt ("11.3", "INTEGRIERTE ANWENDUNGEN", "Integrierte Anwendungen")# 
+ 
+Die schwierigste Möglichkeit, Anwendungen unter EUDAS zu reali­
+sieren, ist ihre Integration. Ein solches Programm greift selbst auf
+die virtuelle Datei zu, nutzt die Funktionen von EUDAS so weit wie
+möglich und definiert vielleicht sogar ein eigenes Menü. 
+ 
+#a ("Vorteile")# Auf diese Weise können natürlich alle Möglichkeiten
+ausgeschöpft werden. Sie können Programme erstellen, die als eine
+natürliche Erweiterung von EUDAS wirken oder EUDAS ganz erset­
+zen. 
+ 
+#a ("Nachteile")# Eine solche Integration ist aber besonders schwierig,
+wenn EUDAS und die Erweiterung nebeneinander benutzt werden
+sollen. In diesem Fall hat EUDAS keine komplette Kontrolle der
+Interaktion, so daß leicht undefinierte Zustände möglich sind. 
+    Weniger Probleme treten auf, wenn sichergestellt ist, daß nur
+die Anwendung selbst verwendet wird. Auch in diesem Fall ist zu
+beachten, daß EUDAS nicht als Programmierumgebung für Anwen­
+dungssysteme konzipiert wurde und daher nicht immer leicht zu
+benutzen ist. 
+    Am einfachsten ist es noch, nur eigene Menüs für eine andere
+Anwendung zu verwenden, da die Menüprozeduren relativ unabhän­
+gig vom Rest sind. 
+ 
+#a ("Richtlinien")# Bei Erweiterungen von EUDAS sind folgende Richtlinien
+zu beachten: 
+#f2# 
+1. Ein Programm, das selber Dateien für die virtuelle Datei öffnen
+   will, sollte vorher prüfen, ob noch eine Datei geöffnet ist und in
+   diesem Fall abbrechen. Beim Multi-User-Betrieb ist nämlich
+   sonst nicht gewährleistet, daß alle Sperren wieder entfernt
+   werden. 
+#f2# 
+2. Ein solches Programm sollte seine eigenen Dateien vor dem
+   Wechsel zu EUDAS selbst wieder sichern und die Arbeitskopien
+   löschen, damit der Ausgangszustand zu Beginn des Programms
+   wiederhergestellt wird. 
+#f2# 
+3. Programme, die Menüs benutzen, sollten nicht unter EUDAS auf­
+   gerufen werden, da sonst eine Beeinflussung der EUDAS-Menüs
+   möglich ist. 
+#f2# 
+An dieser Stelle soll noch einmal von der Erstellung integrierter
+Anwendungen abgeraten werden, wenn es auch andere Möglichkeiten
+gibt, das gegebene Problem mit EUDAS zu lösen. Der hohe Aufwand
+dieser Methode rechtfertigt sich nur in wenigen Fällen. 
+    Experimentierfreudige Anwender werden sich durch diese War­
+nung sowieso nicht abhalten lassen. Ihnen sollte aber bewußt sein,
+daß ein solches Vorgehen auf eigene Gefahr stattfindet und kein
+Anspruch auf Beratung oder Fehlerbeseitigung in einem solchen Fall
+besteht. 
+
diff --git a/app/eudas/4.4/doc/ref-manual/eudas.ref.2 b/app/eudas/4.4/doc/ref-manual/eudas.ref.2
new file mode 100644
index 0000000..bed3bf6
--- /dev/null
+++ b/app/eudas/4.4/doc/ref-manual/eudas.ref.2
@@ -0,0 +1,820 @@
+#type ("prop")##limit (14.0)# 
+#format# 
+#page (13)# 
+#kapitel ("2", "Zusammenstellung", "der", "Funktionen")# 
+ 
+ 
+ 
+Im folgenden finden Sie eine Übersicht über alle Menüfunktionen. Zu
+jeder Funktion ist aufgeführt, welche Parameter angegeben werden
+müssen. Die Parameter werden als Text erfragt. Bei einigen Funk­
+tionen können alle möglichen Parameterwerte mit ESC 'z' (Zeigen)
+als Auswahl abgerufen werden. Bei manchen können in der Auswahl
+mehrere Werte angekreuzt werden, die dann nacheinander abgear­
+beitet werden. Welcher Fall zutrifft, ist jeweils aufgeführt. 
+ 
+ 
+#abschnitt ("2.1", "MENÜ 'ÖFFNEN'", "Menü 'Öffnen'")# 
+ 
+ 
+#linefeed (0.5)# 
+#on ("b")#O           EUDAS-Datei Öffnen#off("b")# 
+#linefeed (1.07)# 
+_____________________________________________________ 
+ 
+Parameter:  EUDAS-Dateiname, mit Zeigen, eine Wahl 
+#f2# 
+Zweck:      Stellt eine EUDAS-Datei als aktuelle Arbeitsdatei ein.
+            Falls eine vorher geöffnete Datei verändert wurde,
+            wird sie nach Anfrage gesichert. Falls die zu öffnende
+            Datei noch nicht existiert, kann sie nach Anfrage
+            eingerichtet werden. Dabei müssen dann die Feld­
+            namen angegeben werden. 
+#f2# 
+            Es wird gefragt, ob die Datei geändert werden soll. In
+            diesem Fall wird eine Arbeitskopie hergestellt. Fast
+            alle EUDAS-Funktionen beziehen sich nachher auf die
+            so eingestellte Datei. 
+#f2# 
+            Ist ein Mehrbenutzer-Manager eingestellt, kann auch
+            eine Datei aus dieser Managertask als Parameter
+            angegeben werden. Die Datei wird dann automatisch
+            von dort kopiert und eine Sperre im Manager gesetzt,
+            falls Änderungen vorgenommen werden sollen. 
+#f2# 
+Verweise:   Abschnitt 3.2 
+            Benutzerhandbuch Abschnitt 5.1 und 9.1 
+ 
+ 
+#linefeed (0.5)# 
+#on("b")#E           EUDAS-Datei Ketten#off("b")# 
+#linefeed (1.07)# 
+_____________________________________________________ 
+ 
+Parameter:  EUDAS-Dateiname, mit Zeigen, mehrfache Wahl 
+#f2# 
+Zweck:      Falls bereits eine EUDAS-Datei geöffnet ist, kann eine
+            weitere Datei gleicher Struktur logisch angekettet
+            werden. Bei der Bearbeitung werden dann beide Datei­
+            en wie eine zusammenhängende Datei behandelt. 
+#f2# 
+            Die gekettete Datei kann ebenfalls verändert werden,
+            wenn dies beim Öffnen der ersten Datei angegeben
+            wurde. Die angegebene Datei kann auch aus einem
+            Manager stammen. 
+#f2# 
+Verweise:   Abschnitt 3.2 
+            Benutzerhandbuch Abschnitt 9.2 
+ 
+ 
+#linefeed (0.5)# 
+#on("b")#K           EUDAS-Datei Koppeln#off("b")# 
+#linefeed (1.07)# 
+_____________________________________________________ 
+ 
+Parameter:  EUDAS-Dateiname, mit Zeigen, mehrfache Wahl 
+#f2# 
+Zweck:      Falls bereits eine Datei geöffnet ist, kann eine andere
+            EUDAS-Datei dazugekoppelt werden. Dazu muß min­
+            destens das erste Feld der zu koppelnden Datei in der
+            bereits geöffneten Datei vorkommen. 
+#f2# 
+            Nach dem Koppeln erscheinen beide Dateien wie eine
+            Datei. Zu jedem Satz der ersten Datei erscheinen je­
+            weils alle Sätze der Koppeldatei, die in dem Koppelfeld
+            übereinstimmen. 
+#f2# 
+            Die gekoppelte Datei kann ebenfalls verändert werden,
+            wenn dies beim Öffnen der ersten Datei angegeben
+            wurde. Die angegebene Datei kann auch aus einem
+            Manager stammen. 
+#f2# 
+Verweise:   Abschnitt 3.3 
+            Benutzerhandbuch Abschnitt 9.3 und 9.4 
+ 
+ 
+#linefeed (0.5)# 
+#on("b")#S           Arbeitskopie Sichern#off("b")# 
+#linefeed (1.07)# 
+_____________________________________________________ 
+ 
+Parameter:  keine 
+#f2# 
+Zweck:      Wurde eine EUDAS-Datei geöffnet und verändert, muß
+            zum Schluß die veränderte Arbeitskopie wieder ge­
+            sichert werden. Die Arbeitskopie kann entweder ge­
+            löscht werden, die alte Version ersetzen oder unter
+            einem neuen Namen registriert werden. 
+#f2# 
+            Für jede veränderte Datei wird zunächst erfragt, ob
+            die alte Version überschrieben werden soll. Dies ist
+            der Normalfall. Bei Verneinung dieser Frage muß ein
+            neuer Name für die Arbeitskopie angegeben werden. 
+#f2# 
+            Zum Schluß wird erfragt, ob alle Arbeitskopien ge­
+            löscht werden sollen (Normalfall: ja). Anderenfalls
+            bleiben die Dateien weiter geöffnet. 
+#f2# 
+Verweise:   Abschnitt 3.5 
+            Benutzerhandbuch Abschnitt 6.4 
+ 
+ 
+#linefeed (0.5)# 
+#on("b")#N           Notizen ansehen/ändern#off("b")# 
+#linefeed (1.07)# 
+_____________________________________________________ 
+ 
+Parameter:  keine 
+#f2# 
+Zweck:      Zu jeder EUDAS-Datei kann als Notiz ein beliebiger
+            Text gespeichert werden. Dieser Text der aktuellen
+            Datei wird mit dieser Funktion im Editor angezeigt
+            und kann verändert werden, wenn eine Arbeitskopie
+            angelegt wurde. Anderenfalls werden etwaige Verän­
+            derungen einfach ignoriert. 
+#f2# 
+Verweise:   Abschnitt 3.1 
+ 
+ 
+#linefeed (0.5)# 
+#on("b")#F           Feldstruktur ändern#off("b")# 
+#linefeed (1.07)# 
+_____________________________________________________ 
+ 
+Parameter:  keine 
+#f2# 
+Zweck:      Mit dieser Funktion können neue Felder an die aktu­
+            elle Datei angefügt werden. Außerdem lassen sich
+            Feldnamen und Feldtypen ändern. Die Feldtypen be­
+            stimmen die Behandlung eines Feldes beim Suchen oder
+            Sortieren (z.B. von Zahlen). 
+#f2# 
+            Zunächst wird erfragt, ob neue Feldnamen angefügt
+            werden sollen. Diese können dann im Editor eingege­
+            ben werden. Danach wird gefragt, ob Feldnamen oder
+            Feldtypen geändert werden sollen (neu angefügte
+            Felder erhalten erst einmal den Typ TEXT). Falls die
+            Frage bejaht wird, können in einer Auswahl die zu
+            ändernden Felder angekreuzt werden. Für jedes ange­
+            kreuzte Feld werden dann der Name und der Typ zum
+            Überschreiben angeboten. 
+#f2# 
+Verweise:   Abschnitt 3.1 
+            Benutzerhandbuch Abschnitt 11.1 
+ 
+ 
+#linefeed (0.5)# 
+#on("b")#P           Prüfbedingungen ansehen/ändern#off("b")# 
+#linefeed (1.07)# 
+_____________________________________________________ 
+ 
+Parameter:  keine 
+#f2# 
+Zweck:      Beim Tragen in eine EUDAS-Datei können Bedingungen
+            für die zu tragenden Sätze überprüft werden. Diese
+            Bedingungen für die aktuelle Datei können mit dieser
+            Funktion angezeigt und, falls erlaubt, auch geändert
+            werden. 
+#f2# 
+Verweise:   Abschnitt 3.1 und 4.4 
+            Benutzerhandbuch Abschnitt 11.3 
+ 
+ 
+#linefeed (0.5)# 
+#on("b")#M           Mehrbenutzer Manager einstellen#off("b")# 
+#linefeed (1.07)# 
+_____________________________________________________ 
+ 
+Parameter:  Managertaskname, kein Zeigen 
+#f2# 
+Zweck:      EUDAS kann beim Öffnen eine Datei von einer anderen
+            Task des Systems kopieren. Dadurch können mehrere
+            Benutzer kontrolliert auf die gleiche Datei zugreifen.
+            Wenn diese Möglichkeit verwendet werden soll, muß
+            mit dieser Funktion zunächst die in Frage kommende
+            Managertask angegeben werden. 
+#f2# 
+Verweise:   Abschnitt 3.7 
+            Benutzerhandbuch Abschnitt 9.6 
+ 
+ 
+#abschnitt ("2.2", "MENÜ 'EINZELSATZ'", "Menü 'Einzelsatz'")# 
+ 
+ 
+#linefeed (0.5)# 
+#on("b")#W           Weiter#off("b")# 
+#linefeed (1.07)# 
+_____________________________________________________ 
+ 
+Parameter:  keine 
+#f2# 
+Zweck:      Geht einen Satz weiter in der aktuellen Datei - falls
+            eine Suchbedingung eingestellt ist, weiter zum näch­
+            sten ausgewählten Satz. 
+#f2# 
+Verweise:   Abschnitt 4.2 
+            Benutzerhandbuch Abschnitt 5.2 
+ 
+ 
+#linefeed (0.5)# 
+#on("b")#Z           Zurück#off("b")# 
+#linefeed (1.07)# 
+_____________________________________________________ 
+ 
+Parameter:  keine 
+#f2# 
+Zweck:      Geht einen Satz zurück in der aktuellen Datei - falls
+            eine Suchbedingung eingestellt ist, zurück zum vori­
+            gen ausgewählten Satz. 
+#f2# 
+Verweise:   Abschnitt 4.2 
+            Benutzerhandbuch Abschnitt 5.2 
+ 
+ 
+#linefeed (0.5)# 
+#on("b")#N           Auf Satz Nr. ..#off("b")# 
+#linefeed (1.07)# 
+_____________________________________________________ 
+ 
+Parameter:  keine 
+#f2# 
+Zweck:      Positioniert auf einen bestimmten Satz der aktuellen
+            Datei, dessen Satznummer eingegeben werden muß, und
+            zwar unabhängig, ob der Satz durch die Suchbedingung
+            ausgewählt wird oder nicht. Trifft die eingestellte
+            Suchbedingung nicht auf den Satz zu, erscheint
+            'SUCH-' in der Überschrift. Existiert die eingegebene
+            Satznummer nicht, positioniert EUDAS hinter den
+            letzten Satz der Datei. 
+#f2# 
+Verweise:   Benutzerhandbuch Abschnitt 5.2 
+ 
+ 
+#linefeed (0.5)# 
+#on("b")#S           Suchbedingung Setzen#off("b")# 
+#linefeed (1.07)# 
+_____________________________________________________ 
+ 
+Parameter:  keine 
+#f2# 
+Zweck:      Es kann eine neue Suchbedingung für die aktuelle
+            Datei eingegeben werden, bzw. eine vorher eingestellte
+            Suchbedingung wird zum Ändern angeboten. Die Such­
+            bedingung wird in Form eines Suchmusters in das
+            Satzformular geschrieben. 
+#f2# 
+            Die eingestellte Suchbedingung wird beim Positionieren
+            und bei allen Bearbeitungsfunktionen beachtet. 
+#f2# 
+Verweise:   Abschnitt 4.2 
+            Benutzerhandbuch Abschnitt 5.3, 5.4 und 10.3 
+ 
+ 
+#linefeed (0.5)# 
+#on("b")#L           Suchbedingung Löschen#off("b")# 
+#linefeed (1.07)# 
+_____________________________________________________ 
+ 
+Parameter:  keine 
+#f2# 
+Zweck:      Die eingestellte Suchbedingung wird wieder gelöscht. 
+#f2# 
+Verweise:   Abschnitt 4.2 
+            Benutzerhandbuch Abschnitt 5.3 
+ 
+ 
+#linefeed (0.5)# 
+#on ("b")#M           Markierung umkehren#off("b")# 
+#linefeed (1.07)# 
+_____________________________________________________ 
+ 
+Parameter:  keine 
+#f2# 
+Zweck:      Mit dieser Funktion können einzelne Sätze zur späte­
+            ren Bearbeitung markiert werden. Falls der aktuelle
+            Satz bereits markiert ist, wird die Markierung wieder
+            entfernt, ansonsten wird er markiert. 
+#f2# 
+            Wenn mindestens ein Satz markiert ist, beachten die
+            Bearbeitungsfunktionen nur die markierten Sätze. So
+            kann eine manuelle Auswahl durchgeführt werden. Die
+            Markierung bleibt nur bis zum Sichern bestehen. Sie
+            ist keine permanente Eigenschaft einer EUDAS-Datei. 
+#f2# 
+Verweise:   Abschnitt 4.2 
+            Benutzerhandbuch Abschnitt 10.4 
+ 
+ 
+#linefeed (0.5)# 
+#on ("b")#E           Datensatz Einfügen#off ("b")# 
+#linefeed (1.07)# 
+_____________________________________________________ 
+ 
+Parameter:  keine 
+#f2# 
+Zweck:      Mit dieser Funktion wird vor dem aktuellen Satz ein
+            leerer Satz eingefügt, für den anschließend die Feld­
+            inhalte im Satzformular eingetragen werden können. 
+#f2# 
+Verweise:   Abschnitt 3.4 
+            Benutzerhandbuch Abschnitt 6.2 und 10.2 
+ 
+ 
+#linefeed (0.5)# 
+#on ("b")#A           Datensatz Ändern#off ("b")# 
+#linefeed (1.07)# 
+_____________________________________________________ 
+ 
+Parameter:  keine 
+#f2# 
+Zweck:      Die Inhalte des aktuellen Satzes werden im Satzformu­
+            lar zum Ändern angeboten. 
+#f2# 
+Verweise:   Abschnitt 3.4 
+            Benutzerhandbuch Abschnitt 6.3 und 10.2 
+ 
+ 
+#linefeed (0.5)# 
+#on ("b")#T           Datensatz Tragen#off ("b")# 
+#linefeed (1.07)# 
+_____________________________________________________ 
+ 
+Parameter:  EUDAS-Dateiname, mit Zeigen, eine Wahl 
+#f2# 
+Zweck:      Mit dieser Funktion kann der aktuelle Satz in eine
+            anderen EUDAS-Datei gleicher Struktur transportiert
+            werden. In der Zieldatei wird er am Ende angefügt. 
+#f2# 
+Verweise:   Abschnitt 4.4 
+            Benutzerhandbuch Abschnitt 6.3 
+ 
+ 
+#linefeed (0.5)# 
+#on ("b")#H           Datensatz Holen#off ("b")# 
+#linefeed (1.07)# 
+_____________________________________________________ 
+ 
+Parameter:  EUDAS-Dateiname, mit Zeigen, eine Wahl 
+#f2# 
+Zweck:      Mit dieser Funktion kann der letzte Satz einer ande­
+            ren Datei vor dem aktuellen Satz eingefügt werden,
+            sofern die Struktur gleich ist. Damit kann ein vorher­
+            gegangenes Tragen rückgängig gemacht werden. 
+#f2# 
+Verweise:   Abschnitt 4.4 
+            Benutzerhandbuch Abschnitt 6.3 
+ 
+ 
+#linefeed (0.5)# 
+#on ("b")#F           Feldauswahl#off("b")# 
+#linefeed (1.07)# 
+_____________________________________________________ 
+ 
+Parameter:  keine 
+#f2# 
+Zweck:      Die Felder der aktuellen Datei werden in einer Aus­
+            wahl angeboten. Am Bildschirm werden danach nur die
+            ausgewählten Felder in der gewählten Reihenfolge
+            dargestellt. Die Auswahl hat jedoch nur Auswirkung
+            auf die Darstellung am Bildschirm, anderen Funktionen
+            stehen nach wie vor alle Felder zur Verfügung. Die
+            Auswahl gilt bis zum Sichern, sie wird also nicht mit
+            der Datei abgespeichert. 
+#f2# 
+Verweise:   Abschnitt 4.1 
+            Benutzerhandbuch Abschnitt 10.1 
+ 
+ 
+#abschnitt ("2.3", "MENÜ 'GESAMTDATEI'", "Menü 'Gesamtdatei'")# 
+ 
+ 
+#linefeed (0.5)# 
+#on ("b")#K           Satzauswahl Kopieren#off ("b")# 
+#linefeed (1.07)# 
+_____________________________________________________ 
+ 
+Parameter:  EUDAS-Dateiname, mit Zeigen, eine Wahl 
+            Name Kopiermuster, ohne Zeigen 
+#f2# 
+Zweck:      Mit dieser Funktion werden die ausgewählten bzw.
+            markierten Sätze der aktuellen Datei in eine andere
+            Datei kopiert. Welche Felder kopiert werden sollen und
+            in welcher Reihenfolge, wird durch ein Kopiermuster
+            festgelegt. Dieses Kopiermuster kann benannt werden
+            oder unbenannt nur für ein Mal erstellt werden. Wird
+            das Kopiermuster neu erstellt, wird ein Standard-
+            Kopiermuster zum Ändern angeboten. 
+#f2# 
+Verweise:   Abschnitt 4.4 
+            Benutzerhandbuch Abschnitt 11.2 
+ 
+ 
+#linefeed (0.5)# 
+#on ("b")#T           Satzauswahl Tragen#off("b")# 
+#linefeed (1.07)# 
+_____________________________________________________ 
+ 
+Parameter:  EUDAS-Dateiname, mit Zeigen, eine Wahl 
+#f2# 
+Zweck:      Transportieren der ausgewählten bzw. markierten
+            Sätze in eine andere Datei gleicher Struktur. Die Sätze
+            werden in der Zieldatei am Ende eingefügt. 
+#f2# 
+Verweise:   Abschnitt 4.4 
+            Benutzerhandbuch Abschnitt 11.3 
+ 
+ 
+#linefeed (0.5)# 
+#on ("b")#V           Satzauswahl Verändern#off ("b")# 
+#linefeed (1.07)# 
+_____________________________________________________ 
+ 
+Parameter:  Name Änderungsmuster, mit Zeigen, mehrfache Wahl 
+#f2# 
+Zweck:      Bearbeiten der ausgewählten bzw. markierten Sätze
+            der aktuellen Datei nach Vorgabe einer Änderungs­
+            vorschrift. 
+#f2# 
+Verweise:   Abschnitt 4.4 
+            Benutzerhandbuch Abschnitt 11.4 
+ 
+ 
+#linefeed (0.5)# 
+#on ("b")#U           Übersicht Satzauswahl#off ("b")# 
+#linefeed (1.07)# 
+_____________________________________________________ 
+ 
+Parameter:  keine 
+#f2# 
+Zweck:      Anzeige aller ausgewählten Sätze in einem Über­
+            sichtsformat mit einem Satz pro Bildschirmzeile. Die
+            Felder, die in der Übersicht angezeigt werden sollen,
+            können vorher ausgewählt werden. In der Übersicht ist
+            Blättern und Markieren von Sätzen möglich. 
+#f2# 
+Verweise:   Abschnitt 4.1 
+            Benutzerhandbuch Abschnitt 10.5 
+ 
+ 
+#linefeed (0.5)# 
+#on ("b")#S           Aktuelle Datei Sortieren#off ("b")# 
+#linefeed (1.07)# 
+_____________________________________________________ 
+ 
+Parameter:  keine 
+#f2# 
+Zweck:      Sortieren der aktuellen Datei in beliebiger Reihenfolge
+            auf- oder absteigend. Zum Sortieren muß eine Ar­
+            beitskopie angelegt sein. Die Feldreihenfolge, in der
+            sortiert werden soll, wird vorher erfragt. 
+#f2# 
+Verweise:   Abschnitt 4.3 
+            Benutzerhandbuch Abschnitt 11.1 
+ 
+ 
+#linefeed (0.5)# 
+#on ("b")#L           Alle Markierungen Löschen#off ("b")# 
+#linefeed (1.07)# 
+_____________________________________________________ 
+ 
+Parameter:  keine 
+#f2# 
+Zweck:      Löschen aller Markierungen der aktuellen Datei. 
+#f2# 
+Verweise:   Abschnitt 4.2 
+            Benutzerhandbuch Abschnitt 10.4 
+ 
+ 
+#abschnitt ("2.4", "MENÜ 'DRUCKEN'", "Menü 'Drucken'")# 
+ 
+ 
+#linefeed (0.5)# 
+#on ("b")#D           Satzauswahl Drucken#off ("b")# 
+#linefeed (1.07)# 
+_____________________________________________________ 
+ 
+Parameter:  Name Druckmuster, mit Zeigen, mehrfache Wahl 
+#f2# 
+Zweck:      Ausdruck des Inhalts der ausgewählten oder markier­
+            ten Sätze in druckbarer Form nach Vorgabe eines
+            Druckmusters. Die Ausgabe kann automatisch zum
+            Drucker geschickt werden oder erst in einer Datei
+            zwischengespeichert werden. 
+#f2# 
+Verweise:   Kapitel 5 
+            Benutzerhandbuch Abschnitt 7.1 und 7.2 
+ 
+ 
+#linefeed (0.5)# 
+#on ("b")#R           Richtung Druckausgabe#off ("b")# 
+#linefeed (1.07)# 
+_____________________________________________________ 
+ 
+Parameter:  keine 
+#f2# 
+Zweck:      Mit dieser Funktion kann festgelegt werden, ob die
+            Druckausgabe automatisch zum Drucker geschickt wird,
+            in eine bestimmte Datei oder in eine automatisch
+            eingerichtete Datei geschrieben wird. 
+#f2# 
+            Die Angabe einer bestimmten Datei gilt nur für den
+            nächsten Druckvorgang. Sie muß also gegebenenfalls
+            wieder neu eingestellt werden. 
+#f2# 
+Verweise:   Abschnitt 5.2 
+            Benutzerhandbuch Abschnitt 7.2 und 12.1 
+ 
+ 
+#linefeed (0.5)# 
+#on ("b")#E           Textdatei Editieren#off ("b")# 
+#linefeed (1.07)# 
+_____________________________________________________ 
+ 
+Parameter:  Name Textdatei, mit Zeigen, mehrfache Wahl 
+#f2# 
+Zweck:      Aufruf des EUMEL-Editors zum Erstellen und Ändern
+            von Druckmustern und Änderungsmustern sowie zum
+            Ansehen der Druckausgabe. 
+#f2# 
+Verweise:   Benutzerhandbuch Abschnitt 7.2 
+ 
+ 
+#linefeed (0.5)# 
+#on ("b")#A           Textdatei Ausdrucken#off ("b")# 
+#linefeed (1.07)# 
+_____________________________________________________ 
+ 
+Parameter:  Name Textdatei, mit Zeigen, mehrfache Wahl 
+#f2# 
+Zweck:      Mit dieser Funktion kann eine Textdatei oder die
+            zwischengespeicherte Ausgabe des Druckens einer
+            EUDAS-Datei zum Drucker geschickt werden. 
+#f2# 
+Verweise:   Benutzerhandbuch Abschnitt 7.2 
+ 
+ 
+#linefeed (0.5)# 
+#on ("b")#N           Textdatei Nachbearbeiten#off ("b")# 
+#linefeed (1.07)# 
+_____________________________________________________ 
+ 
+Parameter:  Name Textdatei, mit Zeigen, mehrfache Wahl 
+#f2# 
+Zweck:      Mit dieser Funktion kann die zwischengespeicherte
+            Ausgabe des Druckens einer EUDAS-Datei mit den
+            Textkosmetikprogrammen 'lineform' und 'pageform'
+            bearbeitet werden. 
+#f2# 
+Verweise:   Benutzerhandbuch Abschnitt 12.1 
+ 
+ 
+#abschnitt ("2.5", "MENÜ 'DATEIEN'", "Menü 'Dateien'")# 
+ 
+ 
+#linefeed (0.5)# 
+#on ("b")#U          Übersicht Dateien System#off ("b")# 
+#linefeed (1.07)# 
+_____________________________________________________ 
+ 
+Parameter:  keine 
+#f2# 
+Zweck:      Übersicht über die Dateien im System in der aktuellen
+            Benutzertask. 
+#f2# 
+Verweise:   Benutzerhandbuch Abschnitt 16.1 
+ 
+ 
+#linefeed (0.5)# 
+#on ("b")#L           Datei Löschen#off ("b")# 
+#linefeed (1.07)# 
+_____________________________________________________ 
+ 
+Parameter:  Dateiname, mit Zeigen, mehrfache Wahl 
+#f2# 
+Zweck:      Löschen einer beliebigen Datei in der aktuellen Be­
+            nutzertask nach Anfrage. 
+#f2# 
+Verweise:   Benutzerhandbuch Abschnitt 16.1 
+ 
+ 
+#linefeed (0.5)# 
+#on ("b")#N           Datei Umbenennen#off ("b")# 
+#linefeed (1.07)# 
+_____________________________________________________ 
+ 
+Parameter:  Dateiname, mit Zeigen, mehrfache Wahl 
+            Neuer Name, ohne Zeigen 
+#f2# 
+Zweck:      Umbenennen einer beliebigen Datei in der aktuellen
+            Benutzertask. 
+#f2# 
+Verweise:   Benutzerhandbuch Abschnitt 16.1 
+ 
+ 
+#linefeed (0.5)# 
+#on ("b")#K           Datei Kopieren#off ("b")# 
+#linefeed (1.07)# 
+_____________________________________________________ 
+ 
+Parameter:  Dateiname, mit Zeigen, mehrfache Wahl 
+            Zieldateiname, ohne Zeigen 
+#f2# 
+Zweck:      Anfertigen einer logischen Kopie einer beliebigen
+            Datei in der aktuellen Benutzertask. 
+#f2# 
+Verweise:   Benutzerhandbuch Abschnitt 16.1 
+ 
+ 
+#linefeed (0.5)# 
+#on ("b")#P           Platzbedarf einer Datei#off ("b")# 
+#linefeed (1.07)# 
+_____________________________________________________ 
+ 
+Parameter:  Dateiname, mit Zeigen, mehrfache Wahl 
+#f2# 
+Zweck:      Zeigt den belegten Speicherplatz einer beliebigen
+            Datei in der aktuellen Benutzertask. 
+#f2# 
+Verweise:   Benutzerhandbuch Abschnitt 16.1 
+ 
+ 
+#linefeed (0.5)# 
+#on ("b")#A           Datei Aufräumen#off ("b")# 
+#linefeed (1.07)# 
+_____________________________________________________ 
+ 
+Parameter:  Dateiname, mit Zeigen, mehrfache Wahl 
+#f2# 
+Zweck:      Reorganisieren einer Textdatei oder einer EUDAS-
+            Datei, um Platz zu sparen oder den Zugriff zu be­
+            schleunigen. Empfiehlt sich bei stark veränderten
+            oder umsortierten Dateien. 
+#f2# 
+Verweise:   Benutzerhandbuch Abschnitt 16.1 
+ 
+ 
+#abschnitt ("2.6", "MENÜ 'ARCHIV'", "Menü 'Archiv'")# 
+ 
+ 
+#linefeed (0.5)# 
+#on ("b")#U           Übersicht Dateien Archiv#off ("b")# 
+#linefeed (1.07)# 
+_____________________________________________________ 
+ 
+Parameter:  keine 
+#f2# 
+Zweck:      Übersicht aller Dateien auf der eingelegten Archivdis­
+            kette. 
+#f2# 
+Verweise:   Benutzerhandbuch Abschnitt 16.2 
+ 
+ 
+#linefeed (0.5)# 
+#on ("b")#D           Archivübersicht Drucken#off ("b")# 
+#linefeed (1.07)# 
+_____________________________________________________ 
+ 
+Parameter:  keine 
+#f2# 
+Zweck:      Die Archivübersicht wird direkt zum Drucker ge­
+            schickt. 
+#f2# 
+Verweise:   Benutzerhandbuch Abschnitt 16.2 
+ 
+ 
+#linefeed (0.5)# 
+#on ("b")#K           Datei Kopieren vom Archiv#off ("b")# 
+#linefeed (1.07)# 
+_____________________________________________________ 
+ 
+Parameter:  Dateiname, mit Zeigen, mehrfache Wahl 
+#f2# 
+Zweck:      Eine Datei auf der Archivdiskette wird in die aktuelle
+            Benutzertask kopiert. 
+#f2# 
+Verweise:   Benutzerhandbuch Abschnitt 16.2 
+ 
+ 
+#linefeed (0.5)# 
+#on ("b")#S           Datei Schreiben auf Archiv#off ("b")# 
+#linefeed (1.07)# 
+_____________________________________________________ 
+ 
+Parameter:  Archivname 
+            Dateiname, mit Zeigen, mehrfache Wahl 
+#f2# 
+Zweck:      Eine Datei aus der aktuellen Benutzertask wird auf
+            die eingelegte Archivdiskette geschrieben. 
+#f2# 
+Verweise:   Benutzerhandbuch Abschnitt 16.2 
+ 
+ 
+#linefeed (0.5)# 
+#on ("b")#L           Datei Löschen auf Archiv#off ("b")# 
+#linefeed (1.07)# 
+_____________________________________________________ 
+ 
+Parameter:  Archivname 
+            Dateiname, mit Zeigen, mehrfache Wahl 
+#f2# 
+Zweck:      Löschen einer Datei auf der eingelegten Archivdisket­
+            te. Der Platz kann jedoch nicht immer wiederverwendet
+            werden. 
+#f2# 
+Verweis:    Benutzerhandbuch Abschnitt 16.2 
+ 
+ 
+#linefeed (0.5)# 
+#on ("b")#I           Archivdiskette Initialisieren#off ("b")# 
+#linefeed (1.07)# 
+_____________________________________________________ 
+ 
+Parameter:  keine 
+#f2# 
+Zweck:      Mit dieser Funktion kann eine Archivdiskette komplett
+            gelöscht werden. Die Diskette kann dabei auch gleich­
+            zeitig formatiert werden, falls der Rechner dies zu­
+            läßt. Das Initialisieren ist notwendig, bevor eine neue
+            Diskette als Archiv verwendet werden kann. 
+#f2# 
+Verweise:   Benutzerhandbuch Abschnitt 16.2 
+ 
+ 
+#linefeed (0.5)# 
+#on ("b")#Z           Zielarchiv einstellen#off ("b")# 
+#linefeed (1.07)# 
+_____________________________________________________ 
+ 
+Parameter:  Managertaskname, ohne Zeigen 
+#f2# 
+Zweck:      Mit dieser Funktion kann eine Managertask angegeben
+            werden, die als Ziel der Archivoperationen dient.
+            Damit können Dateien auch in beliebigen Managertasks
+            oder über das EUMEL-Netz gesichert werden. 
+#f2# 
+            Es wird erfragt, ob die angegebene Task ein Archiv­
+            manager oder ein gewöhnlicher Dateimanager ist. 
+#f2# 
+Verweise:   Benutzerhandbuch Abschnitt 16.2 
+ 
+ 
+#linefeed (0.5)# 
+#on ("b")#P           Paßwort einstellen#off ("b")# 
+#linefeed (1.07)# 
+_____________________________________________________ 
+ 
+Parameter:  Paßwort 
+#f2# 
+Zweck:      Mit dieser Funktion kann ein Paßwort eingestellt
+            werden, das bei der Kommunikation mit allgemeinen
+            Managertasks überprüft wird. 
+#f2# 
+Verweise:   Benutzerhandbuch Abschnitt 16.2 
+ 
+ 
+#linefeed (0.5)# 
+#on ("b")#R           Archivmanager Reservieren#off ("b")# 
+#linefeed (1.07)# 
+_____________________________________________________ 
+ 
+Parameter:  Reservierungstext 
+#f2# 
+Zweck:      Falls als Zielarchiv eine Managertask eingestellt ist,
+            die zwar kein Archivmanager ist, aber reserviert
+            werden muß (z.B. 'DOS'), kann die Reservierung mit
+            dieser Funktion ausgeführt werden. Die Freigabe
+            erfolgt automatisch beim Verlassen des Menüs. 
+#f2# 
+Verweise:   Benutzerhandbuch Abschnitt 16.2 
+ 
+ 
+ 
+#abschnitt ("2.7", "KURZABFRAGE", "Kurzabfrage")# 
+ 
+Wird 'eudas' innerhalb des EUMEL-Editors aufgerufen, so wird eine
+spezielle Kurzabfrage gestartet. Diese ermöglicht die Übernahme von
+Druckdaten direkt in die editierte Datei. 
+    Zunächst wird der Dateiname der zu verwendenden EUDAS-
+Datei erfragt. Diese Datei wird dann geöffnet. Vorher geöffnete und
+veränderte Dateien werden nach Anfrage gesichert. 
+    Als nächstes kann für die folgende Übersicht eine Feldauswahl
+eingestellt werden, damit die relevanten Felder auch auf dem Bild­
+schirm erscheinen. 
+    Danach beginnt ein wiederholbarer Prozeß mit der Eingabe
+eines Suchmusters nach Anfrage. Die ausgewählten Sätze werden
+dann in einer Übersicht gezeigt. In der Übersicht können auch Sätze
+markiert werden. 
+    Nach Verlassen der Übersicht bestehen drei Möglichkeiten zum
+Drucken: Falls mindestens ein Satz markiert wurde, können nach
+Anfrage alle markierten Sätze gedruckt werden. Wurde kein Satz
+markiert, können nach Anfrage alle ausgewählten (bzw. vorher
+angezeigten) Sätze gedruckt werden. Wird diese Frage jeweils ver­
+neint, kann nach Anfrage auch der aktuelle Satz als einziger ge­
+druckt werden. 
+    Wurde eine der Fragen bejaht, wird der Name des Druckmusters
+erfragt, das bereits existieren muß. Das Ergebnis der Druckausgabe
+wird dann an der aktuellen Cursorposition in der editierten Datei
+eingefügt. 
+    Der Prozeß kann danach mit einem anderen Suchmuster wieder­
+holt werden. Dabei werden alle Markierungen wieder gelöscht. 
+
diff --git a/app/eudas/4.4/doc/ref-manual/eudas.ref.3 b/app/eudas/4.4/doc/ref-manual/eudas.ref.3
new file mode 100644
index 0000000..77c3fc6
--- /dev/null
+++ b/app/eudas/4.4/doc/ref-manual/eudas.ref.3
@@ -0,0 +1,256 @@
+#type ("prop")##limit (14.0)# 
+#format# 
+#page (31)# 
+#kapitel ("3", "Das", "virtuelle", "Dateimodell")# 
+ 
+ 
+ 
+#abschnitt ("3.1", "DATEISTRUKTUR", "Dateistruktur")# 
+ 
+Eine EUDAS-Datei hat folgende Bestandteile: 
+ 
+- 0 bis 5000 #on("i")#Sätze#off("i")#, von 1 an durchnumeriert. Jeder Satz enthält für
+  jedes Feld einen variabel langen Text als Inhalt, der standard­
+  mäßig leer ist. 
+ 
+- 1 bis 256 #on("i")#Felder#off("i")#, die die Sätze aufteilen. Jedes Feld besitzt einen
+  #on("i")#Feldnamen#off("i")# als Text und einen von vier #on("i")#Feldtypen#off("i")# (TEXT, ZAHL,
+  DATUM oder DIN). Der Feldname dient zur Identifizierung des
+  Feldes, der Feldtyp spezifiziert die Art der Behandlung beim Ver­
+  gleichen von Feldern. 
+ 
+- Drei Zusatztexte. Der erste nimmt die #on("i")#Prüfbedingungen#off("i")# auf, der
+  zweite speichert das Datum der letzten Veränderung und der
+  dritte kann allgemeine #on("i")#Notizen#off("i")# aufnehmen. 
+ 
+- Einen #on("i")#Satzzeiger#off("i")#, der einen bestimmten Satz als aktuellen Satz
+  auszeichnet. Der Satzzeiger kann durch Positionierungsoperatio­
+  nen verändert werden. 
+ 
+- Eine #on("i")#Sortierreihenfolge#off("i")#, die angibt, in welcher Feldreihenfolge die
+  Datei zuletzt sortiert worden ist. Dazu für jeden Satz eine Anga­
+  be, ob er entsprechend dieser Reihenfolge an der richtigen Posi­
+  tion steht. 
+ 
+- Eine interne Datenstruktur, die beschleunigten Zugriff auf eine
+  Satz nach dem Inhalt des ersten Feldes ermöglicht. Diese Struktur
+  steht ganz unter Kontrolle von EUDAS und kann nicht von außen
+  manipuliert werden. 
+ 
+ 
+#abschnitt ("3.2", "ÖFFNEN", "Öffnen")# 
+ 
+#a ("Virtuelle Datei")# Die meisten EUDAS-Funktionen arbeiten nicht
+direkt auf einer EUDAS-Datei, sondern auf der sogenannten #on("i")#vir­
+tuellen Datei#off("i")#, die aus mehreren realen Dateien bestehen kann. Die
+virtuelle Datei erscheint nach außen hin wie eine einzelne
+EUDAS-Datei. Die Operationen auf der virtuellen Datei werden je­
+weils auf die einzelnen Bestandteile abgebildet. 
+    Damit eine EUDAS-Datei Bestandteil der virtuellen Datei wird,
+muß sie geöffnet werden. Dieses Öffnen kann auf dreierlei Art und
+Weise geschehen. 
+    Das Öffnen der ersten Datei stellt eine neue virtuelle Datei
+her. Die Feldnamen und Feldeigenschaften der ersten Datei werden
+in der virtuellen Datei übernommen. Dies ist der Normalfall, in dem
+sich die virtuelle Datei noch nicht von der zugrundeliegenden Datei
+unterscheidet. 
+    Bei diesem ersten Öffnen muß angegeben werden, ob die vir­
+tuelle Datei verändert werden soll oder nicht. Falls die virtuelle
+Datei verändert werden soll, wird eine Arbeitskopie aller geöffneten
+Dateien angelegt. Die Ursprungsdateien können erst am Ende der
+Arbeit mit den geänderten Kopien überschrieben werden. 
+ 
+#a ("Weitere Dateien")# Weitere Dateien können gekettet oder gekoppelt
+werden. Gekettete Dateien werden logisch an die zuerst geöffnete
+Datei angehängt. Ihre Dateistruktur wird ignoriert, sollte aber mit
+der ersten Datei übereinstimmen. Die Folge aneinander geketteter
+EUDAS-Dateien wird als #on("i")#Hauptdatei#off("i")# bezeichnet. 
+    In der Hauptdatei werden die Sätze von 1 an durchnumeriert;
+die Aufeinanderfolge der Sätze wird durch die Anordnung der Sätze
+in den einzelnen Dateien und die Reihenfolge bestimmt, in der die
+Dateien gekettet wurden. 
+    Die gekoppelten Dateien werden der Hauptdatei untergeordnet.
+Die in ihnen enthaltenen Informationen werden nur angezeigt, wenn
+sie mit einem Satzinhalt der Hauptdatei korrespondieren. Der
+Mechanismus dieser Satzkopplung wird im nächsten Abschnitt
+beschrieben. 
+ 
+#beispiel# 
+#free (8.0)# 
+ 
+#center#Abb. 3-1   Schematischer Aufbau der virtuellen Datei 
+#text# 
+ 
+ 
+#abschnitt ("3.3", "KOPPELN", "Koppeln")# 
+ 
+    Die Sätze der gekoppelten Dateien werden in Relation zu den
+Sätzen in der Hauptdatei gesetzt. Zu jedem Satz in der Hauptdatei
+kann eine Anzahl von Sätzen aus jeder Koppeldatei gehören. Diese
+Sätze müssen in den Inhalten der sogenannten #on("i")#Koppelfelder#off("i")# über­
+einstimmen. 
+    Welche Felder Koppelfelder sind, richtet sich nach den Feld­
+namen. Die ersten Felder der Koppeldatei, die auch in der Haupt­
+datei vorhanden sind, werden als Koppelfelder betrachtet. Die Kop­
+pelfelder müssen also bei der Koppeldatei am Anfang stehen - in
+der Hauptdatei kann jedes beliebige Feld ein Koppelfeld sein. 
+    Wenn eine Datei zur virtuellen Datei gekoppelt wird, werden
+alle Felder, die nicht Koppelfelder sind, in die virtuelle Datei auf­
+genommen. Die Koppelfelder brauchen nicht noch mal wiederholt zu
+werden, da ihr Inhalt ja immer identisch ist. 
+    Zu beachten ist, daß bei diesem Verfahren auch Namenskonflik­
+te entstehen können, wenn nach den Koppelfeldern später wieder
+ein Feldname vorkommt, der auch in der Hauptdatei vorhanden ist.
+In den Fällen, in denen Felder durch ihren Namen angesprochen
+werden, ist dann das zweite Feld gleichen Namens nicht verfügbar. 
+ 
+#beispiel# 
+#free (7.0)# 
+ 
+#center#Abb. 3-2   Schema des Koppelvorgangs 
+#text# 
+ 
+#a ("Kombinationen")# Beim Vorwärtsgehen in der virtuellen Datei werden
+zu jedem Satz der Hauptdatei nacheinander alle möglichen Kombina­
+tionen der zugehörigen Koppelsätze angezeigt, denn es können
+mehrere passende Koppelsätze vorhanden sein. Die Satznummer
+bleibt dabei gleich; die einzelnen Kombinationen werden von 1 an
+durchgezählt. Beim Rückwärtsgehen wird aus technischen Gründen
+immer nur die erste Kombination angezeigt. 
+    Existiert zu einem Satz kein passender Koppelsatz, so bleiben
+die entsprechenden Felder leer. Die Koppelsätze müssen in der
+ganzen Koppeldatei gesucht werden, daher ist bei großen Koppel­
+dateien die Suchzeit zu berücksichtigen. 
+ 
+ 
+#abschnitt ("3.4", "ÄNDERUNGEN", "Änderungen")# 
+ 
+In der virtuellen Datei kann auch geändert werden. Dabei ist jedoch
+Vorsicht angebracht. Es muß festgelegt sein, wie Änderungen der
+einzelnen Felder auf die beteiligten Dateien abgebildet werden. 
+    Falls die virtuelle Datei keine Koppeldateien enthält, werden
+Änderungen am aktuellen Satz an der zugehörigen Datei durchge­
+führt. Das Löschen eines Satzes wird auch direkt in der Datei
+durchgeführt. Ein neuer Satz wird immer in der Datei eingefügt, zu
+der der aktuelle Satz gehört - am Ende der ersten Datei kann also
+kein Satz eingefügt werden, wenn noch weitere Dateien folgen. 
+    Enthält die virtuelle Datei Koppeldateien, werden die Änderun­
+gen in der Hauptdatei wie oben beschrieben durchgeführt. Änderun­
+gen, die Felder in den Koppeldateien betreffen, werden nach folgen­
+der Entscheidungstabelle behandelt: 
+ 
+                                   1  2  3  4  5 
+                                  --------------- 
+    Koppelfelder verändert         N  J  J  N  N 
+    Übrige Felder verändert        N  -  -  J  J 
+    Übrige Felder leer             -  J  N  -  N 
+    Vorher Koppelsatz vorhanden    -  -  -  J  N 
+                                  --------------- 
+    Neuen Satz einfügen                  x     x 
+    Koppelsatz ändern                       x 
+    Kopplung aktualisieren            x 
+ 
+Fall 1: Es wurden keine Veränderungen an den Feldern des Kop­
+        pelsatzes vorgenommen, daher ist auch keine Aktion not­
+        wendig. 
+ 
+Fall 2: Eines der Koppelfelder wurde verändert. Die Änderung wird
+        in der Hauptdatei durchgeführt. Die übrigen Felder des
+        Koppelsatzes sind jedoch als leer angegeben. In diesem Fall
+        wird der Koppelsatz nicht verändert, sondern nur eine
+        neue Korrespondenz gesucht. 
+ 
+Fall 3: Eines der Koppelfelder wurde verändert, gleichzeitig ent­
+        halten aber auch die anderen Felder Informationen. In
+        diesem Fall wird ein neuer Satz in der Koppeldatei ange­
+        fügt, der die neuen Inhalte enthält. So wird vermieden,
+        daß an anderer Stelle plötzlich kein passender Koppelsatz
+        mehr vorhanden ist. 
+ 
+Fall 4: Nur Felder der Koppeldatei, die nicht Koppelfelder sind,
+        wurden verändert, außerdem existierte ein korrespondie­
+        render Satz in der Koppeldatei. In diesem Fall werden die
+        Informationen im Koppelsatz abgeändert. 
+ 
+Fall 5: Wie 4, nur war vorher noch kein Koppelsatz vorhanden
+        (Felder waren leer). In diesem Fall muß ein neuer Satz in
+        die Koppeldatei eingefügt werden. Einfügungen in die
+        Koppeldatei geschehen immer am Dateiende. 
+ 
+#a ("Einfügen/Löschen")# Beim Löschen eines Satzes der virtuellen Datei
+durch Tragen bleiben die Koppeldateien unverändert. Nach dem
+Einfügen eines neuen Satzes wird nur dann ein Satz in einer Kop­
+peldatei eingefügt, wenn dieser Satz nicht nur Koppelfelder enthal­
+ten würde. Falls beim Einfügen nur die Koppelfelder angegeben
+werden, wird ein korrespondierender Satz in der Koppeldatei ge­
+sucht. Vergleichen Sie hierzu die Regeln beim Ändern. 
+ 
+ 
+#abschnitt ("3.5", "SICHERN", "Sichern")# 
+ 
+Falls Änderungen der virtuellen Datei erlaubt sind, arbeitet EUDAS
+immer auf Sicherheitskopien der beteiligten Dateien. Eine Datei, die
+wirklich verändert wurde, muß vor dem Aufbau einer neuen virtuel­
+len Datei gesichert oder explizit gelöscht werden. 
+    Für jede einzelne Datei kann festgelegt werden, ob sie gesi­
+chert werden soll oder nicht. Als Hilfe wird dazu für jede Datei
+angegeben, ob sie tatsächlich verändert wurde oder nicht. Die
+Arbeitskopie kann beim Sichern die alte Version überschreiben oder
+unter einem neuen Namen gesichert werden. 
+    Am Ende des Sicherns können die Arbeitskopien gelöscht wer­
+den. Anderenfalls werden die Dateien so betrachtet, als ob sie di­
+rekt nach dem Sichern wieder geöffnet worden wären und stehen
+weiterhin zur Verfügung. 
+    Falls alle Dateien entweder gesichert oder nicht verändert
+sind, werden beim nächsten Öffnen einer neuen virtuellen Datei die
+vorherigen Arbeitskopien gelöscht. 
+ 
+ 
+#abschnitt ("3.6", "UMSCHALTEN AUF KOPPELDATEI", "Umschalten auf Koppeldatei")# 
+ 
+Falls eine Datei gekoppelt ist, kann man die virtuelle Datei auf
+diese Koppeldatei umschalten. Dadurch verhält sich die virtuelle
+Datei so, als ob nur diese Koppeldatei geöffnet wäre. Die Einstel­
+lungen der Hauptdatei wie Markierungen und Suchbedingung bleiben
+jedoch erhalten und stehen beim Zurückschalten wieder zur Verfü­
+gung. 
+    Die Satzposition der Koppeldatei beim letzten Umschalten wird
+ebenfalls gespeichert und wird beim nächsten Umschalten wieder
+eingenommen, unabhängig von der tatsächlichen Satzposition der
+Koppeldatei zu diesem Zeitpunkt. 
+    Für die Koppeldatei können eigene Markierungen vergeben
+werden, die auch nach dem Umschalten gespeichert bleiben. Auch
+ein Suchmuster kann für die Koppeldatei eingestellt werden, dies
+geht jedoch beim Zurückschalten wieder verloren. Die eingestellte
+Feldauswahl für die Bildschirmanzeige geht leider bei jedem Um­
+schalten verloren. 
+    Das Umschalten kann entweder im Menü 'Einzelsatz' oder beim
+Einfügen und Ändern durch ESC 'K' bewirkt werden, ebenso das
+Zurückschalten nur im Menü 'Einzelsatz'. Beim Umschalten aus Ein­
+fügen oder Ändern erfolgt beim Zurückschalten eine Rückkehr in
+diesen Zustand. Dabei können nach Anfrage die Koppelfelder des
+aktuellen Satzes der Koppeldatei in die Hauptdatei übernommen und
+damit eine bestimmte Kopplung bewirkt werden. 
+ 
+ 
+#abschnitt ("3.7", "MEHRBENUTZERBETRIEB", "Mehrbenutzerbetrieb")# 
+ 
+Durch Einstellen einer Managertask für den Mehrbenutzerbetrieb
+können auch Dateien dieser Managertask beim Öffnen direkt ver­
+wendet werden. Die Datei wird automatisch aus der Managertask
+kopiert und geöffnet. 
+    Falls die Datei geändert werden soll, wird eine Sperre in der
+Managertask gesetzt, die verhindert, daß auch ein anderer Benutzer
+diese Datei zum Ändern öffnet. Beim Sichern erfolgt dann ein Rück­
+schreiben der Arbeitskopie. Die Sperre wird jedoch erst dann zu­
+rückgesetzt, wenn alle Arbeitskopien gelöscht werden, da erst dann
+keine Möglichkeit des Rückschreibens mehr besteht. 
+    Alle Dateien der Managertask werden bei der Dateiauswahl zum
+Öffnen mit angeboten. Falls eine Datei in beiden Tasks existiert,
+wird die Datei in der Managertask genommen, die Datei der eigenen
+Task jedoch erst nach Anfrage überschrieben. 
+    Damit die Sperre funktionieren kann, muß EUDAS in der Mana­
+gertask zur Verfügung stehen und die Task muß #on("i")#nach#off("i")# dem Insertie­
+ren von EUDAS als 'global manager' definiert werden (nicht 'free
+global manager' verwenden). 
+
diff --git a/app/eudas/4.4/doc/ref-manual/eudas.ref.4 b/app/eudas/4.4/doc/ref-manual/eudas.ref.4
new file mode 100644
index 0000000..92ec931
--- /dev/null
+++ b/app/eudas/4.4/doc/ref-manual/eudas.ref.4
@@ -0,0 +1,421 @@
+#type ("prop")##limit (14.0)# 
+#format# 
+#page (39)# 
+#kapitel ("4", "Ansehen", "und", "Bearbeiten")# 
+ 
+ 
+ 
+#abschnitt ("4.1", "ANZEIGE", "Anzeige")# 
+ 
+Die Anzeige und Eingabe von Einzelsätzen sowie die Eingabe von
+Suchmustern geschieht in einem Standardformular in einem recht­
+eckigen Fenster. Dieses Fenster befindet sich in der rechten Bild­
+schirmhälfte. 
+    Das Formular besteht aus vier Teilen: der Überschrift, den
+Feldnamen, den Feldinhalten und der Abschlußzeile (s. Abbildung). 
+ 
+#bildschirm# 
+                          Überschrift 
+#free (0.3)# 
+      Satz 33       ..SUCH+..MARK-... datei ............... Feld 1 
+      Feld 1      
+      Feld 2 
+      Feld 3              Feldinhalte 
+      
+      Feld 4 
+      .............................................................. 
+#free (0.3)# 
+  Feldnamen                    Abschlußzeile 
+ 
+#text# 
+ 
+#a ("Überschrift")# Die Überschrift zeigt folgende Informationen an: 
+ 
+    #bsp ("Satz n[-m]")# 
+    Die Satznummer des aktuellen Satzes, bei gekoppelten Dateien
+    auch die Satzkombination. 
+ 
+    #bsp ("SUCH+/-")# 
+    Zeigt an, ob der aktuelle Satz die eingestellte Suchbedingung
+    erfüllt oder nicht (wird während Eintragungen nicht angezeigt).
+    Wenn keine Suchbedingung eingestellt ist, erscheint diese An­
+    zeige nicht. 
+ 
+    #bsp ("MARK+/-")# 
+    Zeigt an, ob der aktuelle Satz markiert ist oder nicht (Wird
+    während Eintragungen nicht angezeigt). Wenn kein Satz mar­
+    kiert ist, erscheint diese Anzeige nicht. 
+ 
+    #bsp ("ENDE")# 
+    Wird hinter dem letzten Satz der Datei als Kennzeichnung des
+    Endesatzes ausgegeben. 
+ 
+    #bsp ("'Dateiname'")# 
+    Gibt den Namen der ersten geöffneten Datei an. 
+ 
+    #bsp ("<KOPPPEL>")# 
+    Erscheint statt des Dateinamens, wenn auf eine Koppeldatei
+    umgeschaltet wurde. 
+ 
+    #bsp ("Feld n/Zeile n")# 
+    Zeilennummer des obersten angezeigten Feldes (bei Anzeige)
+    bzw. der aktuellen Cursorzeile (während Eintragungen). 
+ 
+#a ("Feldteil")# Die Feldnamen sind zur Unterscheidung von den Feld­
+inhalten invers dargestellt. Die Breite der Feldnamen richtet sich
+nach der Länge des längsten Feldnamens. Ist dieser zu lang, um
+noch eine ordentliche Anzeige zu ermöglichen, wird bei einer be­
+stimmten Länge der Rest des Namens abgeschnitten. 
+    Zwischen dem Feldnamen an der linken Seite und dem dane­
+benstehenden Feldinhalt besteht immer eine Korrespondenz, d.h. der
+Inhalt eines Feldes wird direkt neben dem Namen dargestellt. In der
+Regel wird pro Feld eine Bildschirmzeile reserviert. Kann der Feld­
+inhalt jedoch nicht mehr in einer Zeile untergebracht werden, wer­
+den weitere Zeilen zur Darstellung dieses Feldes herangezogen. In
+diesen Zeilen steht statt des Feldnamens nur ein markierter Leer­
+raum. 
+    Alle folgenden Zeilen ohne Namen gehören zu dem gleichen
+Feld. Der Inhalt wird auf diese Zeilen umbrochen, d.h. wenn ein
+Wort nicht mehr auf die Zeile paßt, wird es komplett in die nächste
+Zeile geschrieben (wie beim Editor). Wörter werden nur dann zer­
+schnitten, wenn sie nicht als Ganzes auf eine Zeile passen. Wörter
+werden untereinander durch Leerzeichen getrennt. 
+    Aus Effizienzgründen werden in bestimmten Fällen auch mehr
+Folgezeilen als nötig angezeigt. Hat nämlich ein neuer Satz einen
+kürzeren Inhalt als der vorige, so werden die Feldnamen nur dann
+wieder zusammengerückt, wenn das ganze Bild neugeschrieben wer­
+den muß. Anderenfalls werden nur die Feldinhalte aktualisiert. 
+    Die Bildausgabe wird unterbrochen, wenn 'w' oder 'z' gedrückt
+wurde, da dann die Inhalte des aktuellen Satzes nicht mehr inter­
+essieren. 
+ 
+#a ("Rollen")# Da nicht alle Felder auf den Bildschirm passen müssen,
+kann das Bild gerollt werden. 
+    Mit ESC UNTEN wird um eine Seite nach unten geblättert, mit
+ESC OBEN wieder zurück. Hinter dem letzten Feld erscheint ein
+markierter Balken als Abschlußzeile. Weiter als bis zum Erscheinen
+dieses Balken kann nicht gerollt werden. Mit ESC '1' wird ganz an
+den Anfang gerollt, mit ESC '9' ganz ans Ende. 
+    Bei Feldern, die sich über mehrere Zeilen erstrecken, kann es
+passieren, daß nach dem Rollen die erste Bildschirmzeile nicht die
+erste Zeile eines Feldes ist, also der erste Teil eines Feldes nicht
+dargestellt wird. Trotzdem wird in diesem Fall in der ersten Anzei­
+gezeile der Feldname angezeigt. 
+ 
+#a ("Feldauswahl")# Man kann auswählen, welche Felder in welcher Rei­
+henfolge angezeigt werden sollen. Dies dient der besseren Übersicht.
+Von der Anzeige werden nur die ausgewählten Felder behandelt, die
+anderen Felder bleiben leer, werden nicht verändert oder berück­
+sichtigt. Die Anzeigeauswahl ändert jedoch nichts an der Datei­
+struktur. 
+    Die Feldauswahl ist keine permanente Eigenschaft einer
+EUDAS-Datei. Sie geht daher bei einem neuen Öffnen oder beim
+Umschalten auf eine Koppeldatei verloren. 
+ 
+#a ("Übersicht")# Im Gegensatz zur normalen Anzeige, bei der ein Satz pro
+Bildschirm dargestellt wird, können in der Übersicht mehrere Sätze
+gleichzeitig überschaut werden. Dabei wird jeder Satz in einer Zeile
+untergebracht. Die Auswahl der Felder, die in der Übersicht er­
+scheinen sollen, wird vor Beginn der Funktion erfragt. 
+    In jeder Zeile steht die Nummer des jeweiligen Satzes, eine
+Anzeige, ob er markiert ist (+) oder nicht (-) und die Feldinhalte
+in der gewählten Reihenfolge und Auswahl, jeweils duch Komma und
+Leerzeichen getrennt. Inhalte, die nicht mehr auf die Zeile passen,
+werden abgeschnitten. 
+    Es werden nur durch das Suchmuster ausgewählte Sätze ange­
+zeigt. Ist der aktuelle Satz nicht ausgewählt, so erscheint an seiner
+Stelle #bsp("'<< >>'")# als Hinweis. In der Überschrift sind die Feldnamen
+angegeben - durch Komma getrennt, so viele wie hinpassen. 
+    Die Satznummer des aktuellen Satzes ist jeweils markiert. In
+der Übersicht kann geblättert werden. HOP OBEN und HOP UNTEN,
+OBEN und UNTEN wirken wie im Editor. 
+    Durch '+' oder '-' kann auch die Markierung des aktuellen
+Satzes verändert werden. 
+ 
+ 
+#abschnitt ("4.2", "SATZAUSWAHL", "Satzauswahl")# 
+ 
+Die Auswahl der Sätze, die gedruckt oder mit den Funktionen aus
+Abschnitt 4.4 bearbeitet werden sollen, kann entweder durch eine
+Suchbedingung oder durch Markierung vorgenommen werden. Wenn
+mindestens ein Satz markiert ist, werden von den Bearbeitungs­
+funktionen nur die markierten Sätze behandelt. Anderenfalls wird
+die eingestellte Suchbedingung beachtet. 
+    Die Bildschirmanzeige richtet sich immer nur nach der einge­
+stellten Suchbedingung. 
+ 
+#a ("Suchmuster")# Ein Suchmuster gibt für jedes Feld bestimmte Bedin­
+gungen an. Es wird im Standardformular mit Hilfe des Satzeditors
+eingegeben. Dabei stehen neben jedem Feld die Bedingungen für
+dieses Feld in einer intuitiv verständlichen Form. Folgende Einzel­
+bedingungen sind möglich: 
+ 
+    #bsp("Muster")#            Inhalt ist gleich Muster 
+    #bsp("Muster..")#          Inhalt ist größergleich Muster 
+    #bsp("..Muster")#          Inhalt ist kleiner Muster 
+    #bsp("Muster1..Muster2")#  Inhalt liegt dazwischen 
+    #bsp("*Muster")#           Inhalt endet mit Muster 
+    #bsp("Muster*")#           Inhalt beginnt mit Muster 
+    #bsp("*Muster*")#          Inhalt enthält Muster 
+    #bsp("*")#                 Inhalt ist nicht leer 
+    #bsp("++")#                Satz markiert (unabhängig vom Feldinhalt) 
+ 
+Die ersten vier Einzelbedingungen beachten auch den Typ eines
+Feldes (wie er bei der Feldstruktur eingegeben werden kann und
+beim Sortieren beachtet wird). So werden z.B. bei der Gleichheit von
+Zahlen alle nicht-numerischen Zeichen ignoriert (s. Sortieren). 
+    Die drei Bedingungen mit Stern können auch miteinander ver­
+knüpft werden. Die Einzelbedingungen müssen dann alle zutreffen,
+damit der Satz ausgewählt wird. So bedeutet zum Beispiel das
+Muster #bsp ("'M1*M2*M3*M4'")#, daß das Feld mit 'M1' beginnen und mit 'M4'
+enden muß. Außerdem muß es 'M2' und 'M3' enthalten, jedoch nicht
+unbedingt in der angegebenen Reihenfolge. 
+    Wird der Mustertext durch '&' und einen gültigen Feldnamen der
+aktuellen Datei ersetzt, findet der Vergleich nicht mit einem
+Mustertext, sondern mit dem Inhalt des angegebenen Feldes statt.
+Als Feldtyp für den Vergleich wird in diesem Fall der Typ des Fel­
+des genommen, in dem der Vergleich steht. 
+ 
+#a ("Verknüpfung")# Einzelbedingungen können durch Voranstellen von
+'--' verneint werden. Einzelbedingungen für verschiedene Felder
+werden mit UND verknüpft. 
+    Es gibt zwei Arten der ODER-Verknüpfung: die lokale und die
+globale. Die lokale ODER-Verknüpfung wird durch ein Komma zwi­
+schen Einzelbedingungen realisiert. Sie hat eine höhere Priorität als
+das UND zwischen verschiedenen Feldern. So hat folgendes Such­
+muster 
+ 
+#beispiel# 
+    Feld1   Bed1,Bed2 
+    Feld2   Bed3 
+#text# 
+ 
+die Bedeutung 
+ 
+#beispiel# 
+    ( Bed1 (Feld1) ODER Bed2 (Feld2) ) UND Bed3 (Feld3) 
+#text# 
+ 
+Die globale ODER-Verknüpfung wird durch ein Semikolon repräsen­
+tiert. Alle Einzelbedingungen nach dem n-ten Semikolon aller Zeilen
+werden zu einer Alternative zusammengefaßt. Damit hat das Such­
+muster 
+ 
+#beispiel# 
+    Feld1   Bed1;Bed2 
+    Feld2   Bed3 
+#text# 
+ 
+die Bedeutung 
+ 
+#beispiel# 
+    ( Bed1 (Feld1) UND Bed3 (Feld2) ) ODER Bed2 (Feld1) 
+#text# 
+ 
+Damit ergibt sich für die Priorität der einzelnen Konstruktionen
+folgende Reihenfolge: 
+ 
+    höchste        Einzelbedingung 
+                   Verkettung von Einzelbedingungen (UND) 
+                   Verneinung 
+                   lokales ODER 
+                   UND zwischen Feldern 
+    niedrigste     globales ODER 
+ 
+#a ("Optimierung")# Wenn für das erste Feld einer Datei eine Gleich-
+Bedingung angegeben wurde und keine globale Alternative vorhan­
+den ist, kann der Suchvorgang wegen der Dateistruktur optimiert
+werden, indem nur Sätze untersucht werden müssen, die im ersten
+Feld den gesuchten Text enthalten. 
+ 
+#a ("Reservierte Zeichen")# Im Rahmen der Analyse einer Musterzeile
+wirken folgende Zeichenfolgen als unbeschränkt reservierte Zeichen: 
+ 
+#beispiel# 
+        ,    ;    ..    * 
+#text# 
+ 
+Sie dürfen daher in keinem Mustertext oder Feldnamen vorkommen,
+da sie als Separator wirken. Die beiden folgenden Zeichenfolgen
+werden nur zu Anfang eines durch die vorstehenden Separatoren
+gebildeten Abschnitts erkannt: 
+ 
+#beispiel# 
+        --    &    ++ 
+#text# 
+ 
+Sie dürfen daher prinzipiell an weiterer Stelle vorkommen, ohne als
+Sonderzeichen erkannt zu werden. Alle anderen Zeichen in der Zeile
+werden dem Mustertext bzw. Feldnamen ohne weitere Interpretation
+zugeordnet. 
+ 
+ 
+#abschnitt ("4.3", "SORTIEREN UND REORGANISIEREN", "Sortieren und Reorganisieren")# 
+ 
+Eine EUDAS-Datei kann in einer beliebigen Feldreihenfolge sortiert
+werden. Mit dieser Angabe kann man bestimmen, welche Felder beim
+Vergleich zweier Sätze berücksichtigt werden sollen und in welcher
+Reihenfolge. 
+    Die Sortierreihenfolge wird in der Datei gespeichert und wird
+anschließend immer wieder verwendet, wenn keine anderen Angaben
+gemacht wurden. 
+    Der Sortierzustand einer Datei wird ebenfalls gespeichert. Wenn
+nur wenige Sätze seit der letzten Sortierung verändert wurden,
+müssen auch nur diese Sätze einsortiert werden. 
+ 
+#a ("Feldtypen")# Um eine korrekte Sortierung auch von Zahlen oder
+Daten sicherzustellen, wird jedem Feld einer EUDAS-Datei ein Feld­
+typ zugeordnet, der beim Sortieren (und auch beim Suchen) berück­
+sichtigt wird. 
+    Es gibt folgende Feldtypen (als Standard wird der Typ TEXT
+verwendet): 
+ 
+  TEXT   Vergleich von Texten nach dem EUMEL-Code der einzel­
+         nen Zeichen. Dies ist Standard und sorgt für schnellst­
+         möglichen Vergleich. Die weiteren Typen brauchen erheb­
+         lich mehr Zeit. 
+ 
+  DIN    Vergleich nach DIN 5007 (s. EUMEL-Benutzerhandbuch).
+         Umlaute werden korrekt eingeordnet, Groß- und Klein­
+         buchstaben werden gleichbehandelt, Sonderzeichen werden
+         ignoriert. 
+ 
+  ZAHL   Der Wert einer Zahl wird verglichen. Außer den Ziffern,
+         dem Dezimalkomma und dem Minuszeichen vor der ersten
+         Ziffer werden alle anderen Zeichen ignoriert. Das Dezi­
+         malkomma ist standardmäßig auf ',' eingestellt, kann aber
+         verändert werden (s. Abschnitt 6.5). Die nicht ignorierten
+         Zeichen werden in eine REAL-Zahl umgewandelt und dann
+         verglichen. 
+ 
+  DATUM  Es werden Daten der Form 'tt.mm.jj' verglichen. In diesem
+         Fall werden Tag und Jahr vertauscht und dann vergli­
+         chen. Texte mit einer anderen Länge als 8 werden alle
+         als gleich betrachtet. 
+ 
+#a ("Reorganisieren")# Wenn viele Änderungen an einer EUDAS-Datei
+vorgenommen worden sind, steigt ihr Platzbedarf durch viele Text­
+leichen an. In diesem Fall empfiehlt es sich, die Datei zu reorgani­
+sieren. Auch wenn beim Sortieren viele Sätze vertauscht wurden,
+sollte die Datei reorganisiert werden, da beim Sortieren die physi­
+kalische Reihenfolge der Sätze nicht verändert wird. In diesem Fall
+ergibt sich nach dem Reorganisieren ein Geschwindigkeitsvorteil. 
+ 
+ 
+#abschnitt ("4.4", "BEARBEITEN", "Bearbeiten")# 
+ 
+#a ("Kopieren")# Durch Kopieren kann ein Ausschnitt aus der virtuellen
+Datei in eine andere EUDAS-Datei kopiert werden. Es werden alle
+ausgewählten Sätze kopiert. Wenn mindestens ein Satz markiert ist,
+werden alle markierten Sätze als ausgewählt betrachtet, ansonsten
+alle, die durch die Suchbedingung angegeben sind. Die kopierten
+Sätze werden am Ende der Zieldatei angefügt. 
+    Welche Felder kopiert werden sollen, wird durch das Kopier­
+muster angegeben. Hierbei können auch mehrere Felder zu einem
+verschmolzen werden. Allgemein ergeben sich die Felder der Ziel­
+datei aus einem beliebigen ELAN-Ausdruck. 
+    Das Kopiermuster ist ein ELAN-Programm und enthält im we­
+sentlichen Ausdrücke der Form 
+ 
+#beispiel# 
+        "Feldname" K Ausdruck ; 
+#text# 
+ 
+Durch diese Anweisung wird der Ausdruck in das Feld der Zieldatei
+mit dem angegebenen Namen kopiert. Existiert dieses Feld in der
+Zieldatei noch nicht, so wird es als letztes angefügt. Falls die
+Zieldatei noch nicht existiert, wird sie eingerichtet. In diesem Fall
+bestimmt also die Reihenfolge der 'K'-Ausdrücke die Reihenfolge der
+Feldnamen in der Zieldatei. 
+    Da die Reihenfolge der 'K'-Ausdrücke wichtig ist, dürfen diese
+nicht in einer IF-Anweisung stehen, sondern müssen für jeden Satz
+komplett in der gleichen Reihenfolge ausgeführt werden. 
+ 
+#a ("Standard-Kopiermuster")# Vor dem Kopieren wird ein Standard-
+Kopiermuster zum Editieren angeboten, das sich nach der Zieldatei
+richtet. Existiert die Zieldatei noch nicht, wird das Muster so kon­
+struiert, daß alle Felder der virtuellen Datei unverändert kopiert
+werden. Wollen Sie einige Felder nicht kopieren, brauchen Sie nur
+die entsprechenden Zeilen zu löschen; wollen Sie die Felder in eine
+andere Reihenfolge bringen, müssen Sie die Zeilen umordnen. 
+    Existiert die Zieldatei bereits, gibt das Standard-Kopiermuster
+an, daß alle Felder der Zieldatei einen Wert erhalten. Ist ein Feld
+der Zieldatei in der virtuellen Datei enthalten, so wird dieses ko­
+piert, ansonsten erhält das Feld einen leeren Inhalt. Sie können in
+diesem Fall weitere Felder angeben oder für die leeren Felder Aus­
+drücke formulieren. 
+ 
+#a ("Tragen")# Durch Tragen werden alle ausgewählten Sätze der virtuel­
+len Datei in eine andere Datei transportiert. Sie sind in der vir­
+tuellen Datei dann nicht mehr vorhanden. Damit bei diesem Vorgang
+keine Informationen verlorengehen können, muß die Zieldatei so
+viele Felder haben wie die virtuelle Datei. Normalerweise sollte sie
+in der Feldstruktur mit der virtuellen Datei übereinstimmen. 
+    Die getragenen Sätze werden jeweils am Ende der Datei ange­
+fügt. 
+    Beim Tragen können zusätzlich noch Konsistenzbedingungen
+überprüft werden. Die Prüfbedingungen sind in der Zieldatei gespei­
+chert und können beim Ändern der Feldstruktur angegeben werden. 
+    Die Prüfbedingung ist ein ELAN-Programm, das vor dem Tragen
+des jeweiligen Satzes ausgeführt wird. Durch spezielle Testprozedu­
+ren kann das Tragen des Satzes verhindert werden, wenn diese
+Prozeduren ein negatives Ergebnis liefern. Gleichzeitig wird eine
+Meldung in eine Protokolldatei geschrieben, die dann zur Identifi­
+zierung der fehlerhaften Sätze dienen kann. 
+    Folgende Prüfprozeduren stehen zur Verfügung (siehe auch
+Abschnitt 8.3): 
+ 
+#beispiel# 
+    pruefe ("Feldname", Bedingung) 
+#text# 
+        Hiermit kann eine beliebige Bedingung (BOOL-Ausdruck in
+        ELAN) überprüft werden. 
+ 
+#beispiel# 
+    wertemenge ("Feldname", "Wert1,Wert2,...,Wertn") 
+#text# 
+        Das Feld muß einen in der angegebenen Liste enthaltenen
+        Werte annehmen. 
+ 
+#beispiel# 
+    feldmaske ("Feldname", "Maske") 
+#text# 
+        Das Feld wird auf Übereinstimmung mit der Maske geprüft.
+        Fünf spezielle Zeichen in der Maske können dabei auf
+        mehrere Zeichen zutreffen: 
+          '9'  alle Ziffern 
+          'a'  alle Kleinbuchstaben, Umlaute, 'ß' 
+          'A'  alle Großbuchstaben, Umlaute 
+          'X'  alle Zeichen 
+          '*'  Folge von beliebigen Zeichen 
+        Der Stern sollte sparsam angewendet werden, da er verar­
+        beitungsaufwendig ist. 
+ 
+#beispiel# 
+    eindeutige felder (n) 
+#text# 
+        Die Zahl 'n' gibt an, die wieviel ersten Felder der Zieldatei
+        eindeutig sein müssen. Stimmt der zu tragende Satz mit
+        einem Satz der Zieldatei in diesen Feldern überein, wird
+        eine Fehlermeldung erzeugt. 
+ 
+Es können auch einzelne Sätze manuell getragen werden. In diesem
+Fall wird die Prüfbedingung nicht getestet. Ebenso kann der Satz
+wieder zurückgeholt und in der aktuellen Datei eingefügt werden. 
+ 
+#a ("Nach Vorschrift ändern")# Die ausgewählten Sätze der virtuellen
+Datei können automatisch nach einer Verarbeitungsvorchrift geän­
+dert werden. Die Verarbeitungsvorschrift ist ein ELAN-Programm, in
+dem mit Hilfe des Operators 'V' Änderungen angegeben werden: 
+ 
+#beispiel# 
+        "Feldname" V TEXT-Ausdruck ; 
+#text# 
+ 
+Das angegebene Feld erhält den Inhalt, der durch den Ausdruck
+angegeben ist. Änderungen an Koppeldateien werden wie im Dialog
+behandelt (s. Abschnitt 3.4). 
+ 
+ 
+ 
+
diff --git a/app/eudas/4.4/doc/ref-manual/eudas.ref.5 b/app/eudas/4.4/doc/ref-manual/eudas.ref.5
new file mode 100644
index 0000000..02127a6
--- /dev/null
+++ b/app/eudas/4.4/doc/ref-manual/eudas.ref.5
@@ -0,0 +1,415 @@
+#type ("prop")##limit (14.0)# 
+#format# 
+#page (49)# 
+#kapitel ("5", "Drucken", "und", "Druckmuster")# 
+ 
+ 
+ 
+#abschnitt ("5.1", "DRUCKMUSTERSYNTAX", "Druckmustersyntax")# 
+ 
+Ein Druckmuster ist eine Beschreibung für die Form, in der die In­
+halte einer EUDAS-Datei ausgedruckt werden sollen. Der syntakti­
+sche Aufbau des Druckmusters ist zeilenorientiert und gehorcht
+folgender Syntax: 
+ 
+    Druckmuster : 
+      [ Initialisierungsteil ] 
+      [ Vorspann ] 
+      [ Wiederholungsteil ] 
+      [ Nachspann ] 
+ 
+    Initialisierungsteil : 
+      ( Kommandozeile #char (""124"")# Textzeile )#bsp ("*")# 
+      ( GRUPPE-Anweisung #char(""124"")# Textzeile )#bsp ("*")# 
+ 
+    Vorspann : 
+      VORSPANN-Anweisung  Abschnitt 
+ 
+    Wiederholungsteil : 
+      WIEDERHOLUNG-Anweisung  Abschnitt 
+ 
+    Nachspann : 
+      NACHSPANN-Anweisung  Abschnitt 
+ 
+    Abschnitt : 
+      Musterteil 
+      [ ABKUERZUNGEN-Anweisung  Abkürzungsteil ] 
+ 
+    Musterteil : 
+      ( Musterzeile #char(""124"")# Kommandozeile #char(""124"")# 
+        MODUS-Anweisung #char (""124"")# MEHR-Anweisung )#bsp ("*")# 
+ 
+Zur Notation: [] bedeutet optional, ()#bsp("*")# beliebig häufige Wiederho­
+lung, #char(""124"")# Alternative und keine Angabe einfache Aneinanderreihung.
+Die verschiedenen Zeilentypen werden weiter unten beschrieben. 
+    Zusätzlich gilt die Bedingung, daß von Vorspann, Wiederho­
+lungsteil und Nachspann mindestens einer vorhanden sein muß. 
+ 
+#a ("Zeilentypen")# Im Druckmuster gibt es 6 verschiedene Zeilentypen: 
+ 
+#on("i")#Kommandozeilen#off("i")# 
+    Eine Kommandozeile beginnt mit '%%' in der ersten und zweiten
+    Spalte. Der Inhalt der Zeile ab Spalte 3 wird dem ELAN-Compi­
+    ler übergeben. Die Bedeutung dieser Zeilen ergibt sich aus dem
+    in 5.4 beschriebenen Übersetzungsmechanismus. 
+ 
+#on("i")#Anweisungen#off("i")# 
+    Anweisungen beginnen mit '%' in der ersten Spalte und dienen
+    zur Steuerung des Druckgenerators. Der Name der Anweisung
+    muß in Großbuchstaben und ohne Leerzeichen geschrieben
+    werden. Davor dürfen sich noch Leerzeichen befinden. An­
+    schließend können noch Parameter folgen, die nur durch Leer­
+    zeichen getrennt aneinander gereiht werden. Die Syntax einer
+    Anweisung ähnelt der eines Operators in ELAN. 
+ 
+#on("i")#Textzeilen#off("i")# 
+    Textzeilen sind die nicht anderweitig markierten Zeilen im
+    Initialisierungsteil. Sie werden unverändert an den Anfang
+    jeder Druckdatei gestellt. 
+ 
+#on("i")#Musterzeilen#off("i")# 
+    Musterzeilen sind nicht besonders gekennzeichnete Zeilen im
+    Musterteil. Sie enthalten Feldmuster und werden nach dem
+    Einsetzen von Inhalten in die Ausgabedatei übernommen. Die
+    Interpretation der Musterzeilen wird in Abschnitt 5.3 beschrie­
+    ben. 
+ 
+#on("i")#Abkürzungszeilen#off("i")# 
+    Abkürzungszeilen markieren den Beginn einer Abkürzung im
+    Abkürzungsteil eines Abschnittes. Sie werden durch '&' in der
+    ersten Spalte gekennzeichnet. Darauf folgt ohne Zwischenraum
+    der Name einer Abkürzung (ohne Leerzeichen) und danach
+    durch Leerzeichen getrennt ein Semikolon. Der Name der Ab­
+    kürzung wird bei der Übersetzung durch einen Refinementnamen
+    ersetzt und die Zeile dem ELAN-Compiler übergeben. Der Rest
+    der Zeile kann also den Beginn eines werteliefernden Refine­
+    ments enthalten. 
+ 
+#on("i")#Programmzeilen#off("i")# 
+    Programmzeilen sind die nicht durch '&' markierten Zeilen im
+    Abkürzungsteil. Sie werden unverändert an den ELAN-Compiler
+    übergeben. Der erlaubte Inhalt richtet sich nach dem Überset­
+    zungsmechanismus (5.4). 
+ 
+ 
+#abschnitt ("5.2", "DER DRUCKVORGANG", "Der Druckvorgang")# 
+ 
+Der Druckvorgang besteht im wesentlichen darin, daß für alle zu
+bearbeitenden Sätze der Wiederholungsteil einmal interpretiert wird
+und das Ergebnis in eine Ausgabedatei geschrieben wird, die dann
+gedruckt werden kann. Wenn mindestens ein Satz markiert ist, wer­
+den alle markierten Sätze der virtuellen Datei bearbeitet, ansonsten
+alle durch die Suchbedingung erfaßten. 
+ 
+#a ("Gruppen")# Eine #on("i")#Gruppe#off("i")# ist eine Folge von Sätzen, die in einem be­
+stimmten Merkmal übereinstimmen. Durch eine GRUPPE-Anweisung
+der Form 
+ 
+#beispiel# 
+        % GRUPPE n  Ausdruck 
+#text# 
+ 
+werden aufeinanderfolgende Sätze mit gleichem Wert des angegebe­
+nen Ausdrucks gruppiert. Über die Nummer 'n' kann festgestellt
+werden, ob sich das angegebene Merkmal verändert hat. Dies ge­
+schieht mit der Prozedur 
+ 
+#beispiel# 
+        BOOL PROC gruppenwechsel (INT CONST gruppennr) 
+#text# 
+ 
+Immer wenn zwischen zwei Sätzen ein Gruppenwechsel stattfindet,
+wird beim vorigen Satz der Nachspann und beim folgenden Satz der
+Vorspann einmal interpretiert. Dies führt dazu, daß entsprechende
+Vorspann- bzw. Nachspannzeilen gedruckt werden. 
+    Vor dem ersten und nach dem letzten zu bearbeitenden Satz
+wechseln alle Gruppen, d.h. dort wird immer ein Vorspann bzw.
+Nachspann erzeugt. 
+    Ist ein zu interpretierender Abschnitt nicht vorhanden, so wird
+an dieser Stelle keine Ausgabe erzeugt. Die Textzeilen des Initali­
+sierungsteils werden auf jeden Fall bei Beginn des Druckvorganges
+in die Ausgabedatei geschrieben. Falls die Ausgabedatei voll ist,
+wird eine neue Datei angefangen und die Zeilen des Initialisie­
+rungsteils erneut an den Anfang gestellt. 
+ 
+#beispiel# 
+        Satz-  Gruppen-  Ausgabe 
+        nummer merkmal 
+#free (0.1)# 
+                                     Initialisierungsteil 
+        ------------------------------------------------- 
+          1        x                 Vorspann 
+                         WDH-Teil 
+          2        x     WDH-Teil 
+                                     Nachspann 
+        ------------------------------------------------- 
+          3        y                 Vorspann 
+                         WDH-Teil 
+          4        y     WDH-Teil 
+          5        y     WDH-Teil 
+                                     Nachspann 
+        ------------------------------------------------- 
+        ENDE 
+ 
+#center#Abb. 5-1   Ablauf des Druckvorganges mit Gruppen 
+#text# 
+ 
+#a ("Spaltendruck")# Normalerweise werden die Ausgaben der einzelnen
+Abschnitte hintereinander in der Ausgabedatei plaziert. Durch An­
+gabe einer Nummer als Parameter in der WIEDERHOLUNG-Anweisung
+können auch soviel Spalten wie angegeben nebeneinander gedruckt
+werden. Die Spaltenbreite wird dabei durch das Dateilimit (Komman­
+do 'limit' im Editor) festgelegt. Alternativ kann die Spaltenbreite
+auch als zweiter Parameter durch Leerzeichen getrennt angegeben
+werden. 
+    Vorspann und Nachspann werden jedoch auf jeden Fall wieder
+in eine eigene Zeile geschrieben, der Spaltendruck also unterbro­
+chen. 
+ 
+ 
+#abschnitt ("5.3", "INTERPRETATION VON MUSTERZEILEN", "Interpretation von Musterzeilen")# 
+ 
+Musterzeilen können Feldmuster enthalten, die bei der Interpreta­
+tion durch entsprechende Inhalte ersetzt werden, ehe die Muster­
+zeile in die Ausgabedatei übernommen wird. Der Beginn eines Feld­
+musters wird durch ein Musterzeichen ('&' oder '%') markiert. Wo
+und wie der Inhalt eingesetzt wird, kann durch folgende Variationen
+angegeben werden: 
+ 
+#beispiel# 
+        Typ ! Beispiel  ! Position ! Länge    ! bündig 
+        ----+-----------+------------------------------ 
+         1  ! &Name     ! fest     ! variabel ! links 
+         2  ! %Name     ! variabel ! variabel ! links 
+         3  ! &Name&&&  ! fest     ! fest     ! links 
+         4  ! %Name%%%  ! variabel ! fest     ! links 
+         5  ! &&&Name&  ! fest     ! fest     ! rechts 
+         6  ! %%%Name%  ! variabel ! fest     ! rechts 
+#text# 
+ 
+Der in dem Feldmuster angegebene Name muß Name einer Abkür­
+zung in irgendeinem Abkürzungsteil oder eines Feldes sein. Der
+Name darf kein Leerzeichen oder Musterzeichen enthalten. Falls dies
+doch der Fall ist, muß der Name in spitze Klammern eingeschlossen
+werden. 
+    Bei fester Länge wird bei zu kurzem Inhalt mit Leerzeichen
+aufgefüllt, bei zu langem Inhalt abgeschnitten. Bei linksbündigem
+Einsetzen geschieht dies an der rechten, sonst an der linken Seite. 
+    Feldmuster variabler Länge können je nach Inhalt dazu führen,
+daß der folgende Teil der Musterzeile verschoben wird. Für diesen
+Einsetzprozeß gelten die folgenden Regeln: 
+ 
+#a ("Position")# Feldmuster fester Position (mit '&' beginnend) werden
+immer in der Position eingesetzt, in der sie stehen. Feldmuster
+variabler Position (mit '%' beginnen) können nach rechts verschoben
+werden, wenn vorherige Inhalte länger als ihre Muster sind, und
+nach links, wenn Modus 1 oder 3 eingestellt ist und vorherige In­
+halte kürzer sind. 
+ 
+#a ("Länge")# Feldmuster variabler Länge erhalten auf jeden Fall den
+Platz, der durch die Länge des Feldmusters reserviert ist. Sind die
+Inhalte kürzer, kann der gewonnene Platz als Reserve für andere
+Feldmuster verwendet werden; sind die Inhalte länger, so wird der
+Inhalt so weit eingesetzt, wie noch Reserve vorhanden ist und der
+Rest abgeschnitten. 
+    Muß in ein Feldmuster variabler Länge ein leerer Inhalt einge­
+setzt werden, so werden beim Drucken auch die auf das Feldmuster
+folgenden Leerzeichen unterdrückt, falls vor dem Feldmuster noch
+ein Leerzeichen steht oder das Feldmuster in Spalte 1 beginnt. 
+    Feldmuster fester Länge werden immer in ihrer reservierten
+Länge eingesetzt. Sie werden im folgenden behandelt wie Feldmuster
+variabler Länge, deren Inhalt so lang ist wie das Feldmuster. 
+ 
+#a ("Verteilung")# Die Verteilung der verschiebbaren Feldmuster auf der
+Zeile geschieht jeweils in dem Abschnitt zwischen zwei Feldmustern
+fester Position bzw. Zeilenanfang oder Zeilenende. Für jeden Ab­
+schnitt wird festgestellt, wieviel Stellen die Inhalte insgesamt mehr
+oder weniger als ihre Muster benötigen. 
+    Der Längenausgleich geschieht zwischen dem letzten Feldmuster
+und dem Ende des Abschnitts. Dort wird ein Pufferplatz bestimmt,
+der bei Überlänge bis auf ein Leerzeichen verkleinert werden kann
+und an dem bei Unterlänge zusätzliche Leerzeichen eingefügt wer­
+den. 
+    Außer am Pufferplatz wird an keinem Mustertext des Abschnitts
+etwas geändert. Zwischentexte zwischen den Feldmustern werden
+unverändert übertragen und mit den umgebenden Feldmustern ver­
+schoben. 
+    Als Pufferplatz wird die erste Lücke hinter dem letzten Feld­
+muster eines Abschnittes verwendet, die mehr als ein Leerzeichen
+enthält. Ist keine solche Lücke vorhanden, wird das Ende des Ab­
+schnitts verwendet, falls dort ein Leerzeichen steht, und sonst das
+Ende des letzten Feldmusters. 
+    Die durch den Pufferplatz und kürzere Inhalte gewonnene Re­
+serve wird von links an die Feldmuster mit Überlänge verteilt, bis
+die Reserve verbraucht ist. 
+ 
+#a ("Zeilende")# Das Zeilenende wird als ein Quasi-Feldmuster mit fester
+Position aufgefaßt, das am Limit der Druckmusterdatei steht. Es
+sind also keine Einsetzungen möglich, die über das Limit der Datei
+hinausgehen. Als Pufferplatz wird hier jedoch die erste Blanklücke
+vom Zeilenende her verwendet, damit Mustertexte am Zeilenende
+gegebenenfalls stehenbleiben. Ist keine solche Lücke vorhanden, so
+wird das Zeilenende als Pufferplatz verwendet. 
+    Obwohl nicht als Pufferplatz ausgewiesen, kann der Raum zwi­
+schen Zeilenende und Dateilimit als Reserve verwendet werden. 
+ 
+#a ("Modi")# Der Einsetzmechanismus kann durch die MODUS-Anweisung
+mit einem Parameter verändert werden. Folgende Modi stehen zur
+Verfügung: 
+ 
+#beispiel# 
+        Modus ! Effekt 
+        ------+---------------------------------------- 
+          1   ! Normalmodus. 
+              ! '%'-Feldmuster werden auch 
+              ! nach links geschoben. 
+              ! Keine Zeilenwiederholung. 
+        ------+---------------------------------------- 
+          2   ! Tabellenmodus. 
+              ! '%'-Feldmuster werden nicht 
+              ! nach links geschoben. 
+              ! Keine Zeilenwiederholung. 
+        ------+---------------------------------------- 
+          3   ! Normalmodus mit Zeilenwiederholung. 
+              ! '%'-Feldmuster werden auch 
+              ! nach links geschoben. 
+              ! Zeilenwiederholung ohne Zwischentexte. 
+        ------+---------------------------------------- 
+          4   ! Tabellenmodus mit Zeilenwiederholung. 
+              ! '%'-Feldmuster werden nicht 
+              ! nach links geschoben. 
+              ! Zeilenwiederholung mit Zwischentexten. 
+        ------+---------------------------------------- 
+#text# 
+ 
+Bei Zeilenwiederholung werden Inhalte in einer folgenden Zeile
+fortgesetzt, falls sie in der ersten Zeile nicht untergebracht werden
+konnten. Dazu wird die Musterzeile mit den Restinhalten erneut
+interpretiert. Je nach Modus werden auch die Zwischentexte noch
+wiederholt. Der Restinhalt umfaßt immer noch das ganze letzte Wort,
+das nicht mehr auf die vorige Zeile paßte. Es findet also ein Um­
+bruch statt. Die Positionen, die in der vorigen Zeile vom Anfang des
+Wortes eingenommen würden, werden durch Leerzeichen ersetzt. 
+    Durch die MEHR-Anweisung mit einem Parameter kann die Zahl
+der Zeilenwiederholungen für die nächste Musterzeile festgesetzt
+werden. Dies hat jedoch nur eine Auswirkung, falls Zeilenwieder­
+holung zugelassen ist. Stehen zur Interpretation keine Restinhalte
+mehr zur Verfügung, wird mit leeren Inhalten weitergearbeitet. Kann
+ein Inhalt bei der vorgegebenen Anzahl von Zeilen nicht ganz dar­
+gestellt werden, wird der Rest nicht ausgegeben. 
+ 
+ 
+#abschnitt ("5.4", "ANSCHLUSS ZUM ELAN-COMPILER", "Anschluß zum ELAN-Compiler")# 
+ 
+Falls in einem Druckmuster Abkürzungen, Kommandozeilen oder
+Gruppendefinitionen vorkommen, wird das Druckmuster in ein
+ELAN-Programm umgewandelt, das dann vom ELAN-Compiler über­
+setzt wird. 
+    Alle Zeilen eines Abkürzungsteils werden direkt in das Pro­
+gramm übernommen, wobei der Name einer Abkürzung durch einen
+beliebig gewählten Refinementnamen ersetzt wird ('abk' + eine lau­
+fende Nummer). Alle Abkürzungen und Refinements werden als glo­
+bale Refinements definiert, also außerhalb von Prozeduren. Dadurch
+wird erreicht, daß sie an jeder Stelle verwendet werden können. 
+    Damit eine Abkürzung richtig als Refinement übersetzt wird,
+muß sie ein TEXT-Objekt als Wert liefern. Die anderen Refinements
+sind beliebig, da sie nur in selbstdefinierten Anweisungen verwen­
+det werden. Die Refinements der Abkürzungen werden in einer Zu­
+weisung an eine TEXT-Variable verwendet, damit der Druckgenera­
+tor auf den entsprechenden Wert zugreifen kann. 
+    Jeder Abschnitt wird dagegen als eine Prozedur übersetzt. Eine
+Folge von Musterzeilen wird in eine Anweisung übersetzt, diese
+Musterzeilen einzusetzen und zu drucken. Eine '%%'-Anweisung wird
+einfach unverändert dazwischengeschrieben. Die Prozedur für den
+Wiederholungsteil wird einmal für jeden ausgewählten Satz aufgeru­
+fen, die Vorspann- und die Nachspann-Prozedur einmal bei jedem
+Gruppenwechsel. 
+    Anweisungen im Initialisierungsteil werden an den Anfang des
+Programms als globale Definitionen gestellt. 
+ 
+#a ("Fehler")# Findet sich in dem erzeugten ELAN-Programm ein Fehler,
+der durch den Druckgenerator nicht erkannt werden konnte (z.B.
+eine Abkürzung liefert keinen Wert), so muß der ELAN-Compiler
+diesen Fehler erkennen. Anschließend zeigt er das erzeugte Pro­
+gramm zusammen mit seinen Fehlermeldungen im Paralleleditor. Sie
+müssen nun die Fehlermeldung lokalisieren und anhand der eben
+gegebenen Hinweise in das ursprüngliche Druckmuster zurücküber­
+setzen, damit Sie dort den Fehler korrigieren können. 
+ 
+ 
+#abschnitt ("5.5", "FEHLERMELDUNGEN", "Fehlermeldungen")# 
+ 
+Folgende Fehlermeldungen können bei der Übersetzung eines Druck­
+musters auftreten: 
+ 
+#on("i")#keine schliessende Klammer in Feldmuster#off("i")# 
+  Wenn der Name in einem Feldmuster in spitze Klammern einge­
+  schlossen werden soll, muß noch in der gleichen Zeile eine
+  schließende Klammer vorhanden sein. 
+ 
+#on("i")#kein Kommando in Kommandozeile#off("i")# 
+  Eine Zeile, die mit '%' beginnt, enthält keinen weiteren Text. 
+ 
+#on("i")#unbekanntes Kommando#off("i")# 
+  Das erste Wort in einer Kommandozeile ist kein bekanntes Kom­
+  mando. 
+ 
+#on("i")#kein % WIEDERHOLUNG gefunden#off("i")# 
+  Das Druckmuster enthält keine Anweisung, die den Beginn eines
+  Abschnittes markiert. Es muß aber mindestens ein Abschnitt
+  vorhanden sein. 
+ 
+#on("i")#nur GRUPPE-Anweisung erlaubt#off("i")# 
+  Im Initialisierungsteil ist nur die GRUPPE-Anweisung erlaubt. 
+ 
+#on("i")#keine ELAN-Anweisung im Initialisierungsteil nach Gruppen­ 
+definition#off("i")# 
+  Sobald im Initialisierungsteil eine GRUPPE-Anweisung aufgetreten
+  ist, ist keine Kommandozeile mehr möglich. 
+ 
+#on("i")#illegale Gruppennummer#off("i")# 
+  In einer GRUPPE-Anweisung wurde eine zu große Nummer angege­
+  ben. Gruppen sollten von 1 an durchnumeriert werden. 
+ 
+#on("i")#diese Gruppe wurde schon definiert#off("i")# 
+  Eine Gruppennummer wurde mehrfach verwendet. 
+ 
+#on("i")#diese Abkürzung ist nicht definiert#off("i")# 
+  Ein Name in einem Feldmuster tritt nicht als Feld-oder Abkür­
+  zungsname auf. Eventuell enthält er ein Leerzeichen! 
+ 
+#on("i")#dieser Abschnitt wurde schon einmal definiert#off("i")# 
+  Kein Abschnitt kann mehrmals angegeben werden. 
+ 
+#on("i")#falscher Modus#off("i")# 
+  In einer MODUS-Anweisung wurde ein nicht definierter Modus als
+  Parameter angegeben. 
+ 
+#on("i")#diese Anweisung darf im Musterteil nicht vorkommen#off("i")# 
+ 
+#on("i")#im Abkürzungsteil darf keine Anweisung auftreten#off("i")# 
+ 
+#on("i")#in dieser Zeile stehen zu viele Feldmuster#off("i")# 
+  Es können maximal 24 Feldmuster in einer Zeile stehen. Abhilfe:
+  mehrere Feldmuster durch eine Abkürzung zusammenfassen. 
+ 
+#on("i")#das Druckmuster enthält zu viele Feldmuster#off("i")# 
+  Die Gesamtanzahl der Feldmuster ist begrenzt. Abhilfe: mehrere
+  Feldmuster durch eine Abkürzung zusammenfassen. 
+ 
+#on("i")#nach dem "&" soll direkt der Name einer Abkürzung folgen#off("i")# 
+  In einer Abkürzungszeile stehen Leerzeichen hinter dem '&'. 
+ 
+#on("i")#kein Doppelpunkt nach Abkürzung#off("i")# 
+  Nach dem Abkürzungsnamen in einer Abkürzungszeile muß durch
+  ein Leerzeichen getrennt ein Doppelpunkt folgen. 
+ 
+#on("i")#Abkürzung mehrfach definiert#off("i")# 
+  Die Abkürzung wurde unter dem gleichen Namen schon einmal,
+  vielleicht in einem anderen Abschnitt, definiert. 
+ 
+#on("i")#das Druckmuster enthält zu viele Abkürzungen#off("i")# 
+  Abhilfe: mehrere Abkürzungen zu einem Ausdruck zusammenfas­
+  sen. 
+ 
+
diff --git a/app/eudas/4.4/doc/ref-manual/eudas.ref.6 b/app/eudas/4.4/doc/ref-manual/eudas.ref.6
new file mode 100644
index 0000000..92c7610
--- /dev/null
+++ b/app/eudas/4.4/doc/ref-manual/eudas.ref.6
@@ -0,0 +1,466 @@
+#type ("prop")##limit (14.0)# 
+#format# 
+#page (61)# 
+#kapitel ("6","Struktur","von","EUDAS-Dateien")# 
+ 
+ 
+ 
+EUDAS-Dateien können unabhängig von EUDAS über den Daten­
+typ EUDAT manipuliert werden. Die zur Verfügung stehenden Zu­
+griffsoperationen sind in diesem Kapitel beschrieben. 
+    Der Datentyp EUDAT ist analog zum Datentyp FILE. Jede
+EUDAT-Variable kann an eine EUDAS-Datei angekoppelt werden.
+Dadurch lassen sich beliebig viele EUDAS-Dateien gleichzeitig be­
+arbeiten. Wie der Abschnitt 6.6 zeigt, sind so auch ganz andere
+Anwendungen realisierbar. 
+    Die wesentlichen EUDAS-Funktionen (Ansehen, Suchen, Druk­
+ken) können jedoch nicht direkt auf EUDAT-Variablen angewendet
+werden, sondern greifen auf die virtuelle Datei zu, die im nächsten
+Kapitel beschreiben wird. 
+ 
+ 
+#abschnitt ("6.1", "DER DATENTYP SATZ", "Der Datentyp SATZ")# 
+ 
+Der Datentyp SATZ stellt einen einzelnen EUDAS-Satz dar, der
+intern als TEXT realisiert ist. Ein SATZ besteht aus bis zu 256
+Feldern, die jeweils einen TEXT enthalten können. Nach dem Initi­
+alisieren sind alle Felder mit "" vorbelegt. Die Felder können über
+Nummern von 1 bis 256 angesprochen werden. 
+    Damit kann man sich einen SATZ als dynamisches ROW n TEXT
+vorstellen, das bis zu 256 Elemente haben kann. Anders als ein
+entsprechendes ROW belegt ein leerer SATZ praktisch keinen Spei­
+cherplatz. 
+    Folgende Zugriffsprozeduren stehen zur Verfügung: 
+ 
+#proc# 
+TYPE SATZ 
+ 
+OP := (SATZ VAR, SATZ CONST) 
+ 
+PROC satz initialisieren (SATZ VAR) 
+#endproc# 
+    Jeder SATZ muß vor Benutzung initialisiert werden. 
+ 
+#proc# 
+INT PROC felderzahl (SATZ CONST) 
+#endproc# 
+    Liefert die Nummer des höchsten belegten Feldes. 
+ 
+#proc# 
+PROC feld lesen (SATZ CONST, INT CONST feldnr, 
+                 TEXT VAR inhalt) 
+#endproc# 
+    Liest den Inhalt des Feldes 'feldnr' in 'inhalt'. 
+#f2# 
+    FEHLER: 
+#f2# 
+    #on("i")#n ist keine Feldnummer#off("i")# 
+    'n' liegt außerhalb des Bereiches 1..256. 
+ 
+#proc# 
+PROC feld bearbeiten (SATZ CONST, INT CONST feldnr, 
+     PROC (TEXT CONST, INT CONST, INT CONST) bearbeite) 
+#endproc# 
+    Ruft 'bearbeite' auf, wobei 'bearbeite' ein Text und zwei Posi­
+    tionen in diesem Text übergeben werden. Die Positionen geben
+    das erste und das letzte Zeichen des durch 'feldnr' ausgewähl­
+    ten Feldes an. Ist der Anfang größer als das Ende, so ist das
+    Feld leer. 
+#f2# 
+    FEHLER: 
+#f2# 
+    #on("i")#n ist keine Feldnummer#off("i")# 
+    'n' liegt außerhalb des Bereiches 1..256. 
+ 
+#proc# 
+PROC feld aendern (SATZ VAR, INT CONST feldnr, 
+                   TEXT CONST inhalt) 
+#endproc# 
+    Schreibt 'inhalt' in das Feld mit der Nummer 'feldnr' 
+#f2# 
+    FEHLER: 
+#f2# 
+    #on("i")#n ist keine Feldnummer#off("i")# 
+    'n' liegt außerhalb des Bereiches 1..256. 
+ 
+#proc# 
+INT PROC feldindex (SATZ CONST, TEXT CONST muster) 
+#endproc# 
+    Falls eines der Felder 'muster' enthält, wird die Nummer dieses
+    Feldes geliefert, sonst 0. 
+ 
+ 
+#abschnitt ("6.2","DER DATENTYP EUDAT","Der Datentyp EUDAT")# 
+ 
+Der Datentyp EUDAT muß ähnlich wie ein FILE an einen benann­
+ten oder unbenannten Datenraum angekoppelt werden. Der Daten­
+raum hat anschließend den Typ 3243. Weitere Zugriffe auf eine
+EUDAT-Variable sind erst nach erfolgtem Ankoppeln zulässig. An­
+derenfalls können undefinierte Fehler entstehen. 
+ 
+#proc# 
+TYPE EUDAT 
+ 
+PROC oeffne (EUDAT VAR, TEXT CONST dateiname) 
+#endproc# 
+    Koppelt die EUDAT-Variable an die EUDAS-Datei mit dem
+    Namen 'dateiname' an. Die Datei wird eingerichtet, falls sie
+    noch nicht existiert. 
+#f2# 
+    FEHLER: 
+#f2# 
+    #on("i")#Datei ist keine EUDAS-Datei#off("i")# 
+    Die angegebene Datei hat nicht den Typ 3243. 
+ 
+#proc# 
+PROC oeffne (EUDAT VAR, DATASPACE CONST ds) 
+#endproc# 
+    Koppelt die EUDAT-Variable an den Datenraum 'ds'. 
+#f2# 
+    FEHLER: 
+#f2# 
+    #on("i")#Datei ist keine EUDAS-Datei#off("i")# 
+    Der Datenraum wurde bereits verwendet und hat nicht den Typ
+    3243. 
+ 
+Eine EUDAS-Datei ist in Felder und Sätze unterteilt. Die Felder
+werden beim Zugriff über Nummern angesprochen. Jedem Feld ist
+jedoch zur Identifikation ein TEXT als Feldname zugeordnet. Die
+Feldnamen werden als SATZ gespeichert, wobei jedes Feld seinen
+zugeordneten Namen enthält. 
+ 
+#proc# 
+INT PROC felderzahl (EUDAT CONST) 
+#endproc# 
+    Liefert Anzahl der benannten Felder. Ist zu Anfang 0. 
+ 
+#proc# 
+PROC feldnamen aendern (EUDAT VAR, 
+                        SATZ CONST neue namen) 
+#endproc# 
+    Setzt die Feldnamen einer Datei. Ist 'felderzahl (neue namen)'
+    größer als die Felderzahl der Datei, so wird die Felderzahl der
+    Datei entsprechend heraufgesetzt. 
+ 
+#proc# 
+PROC feldnamen lesen (EUDAT CONST, SATZ VAR namen) 
+#endproc# 
+    Liefert alle Feldnamen in einer SATZ-Variablen. 
+ 
+Eine EUDAS-Datei enthält drei zusätzliche Notiztexte. Zwei davon
+sind bereits reserviert, und zwar: 
+#free (0.2)# 
+  1: Prüfbedingungen 
+  2: Datum der letzten Änderung 
+#f2# 
+Der dritte kann für freie Notizen verwendet werden. 
+ 
+#proc# 
+PROC notizen lesen (EUDAT CONST, INT CONST notiz nr, 
+                    TEXT VAR notizen) 
+#endproc# 
+    Schreibt die Notizen der EUDAS-Datei in 'notizen' ('notiz nr' =
+   1,2,3). 
+ 
+#proc# 
+PROC notizen aendern (EUDAT VAR, INT CONST notiz nr, 
+                      TEXT CONST notizen) 
+#endproc# 
+    Ändert die Notizen. Alte Notizen werden dabei überschrieben
+    ('notiz nr' = 1,2,3). 
+ 
+ 
+#abschnitt ("6.3", "SATZPOSITION", "Satzposition")# 
+ 
+Eine EUDAS-Datei läßt sich sequentiell vorwärts und rückwärts
+bearbeiten. Dazu gibt es eine aktuelle Satzposition. Ein bestimmter
+Satz kann auch direkt angesprungen werden. Die Prozeduren, die
+nach dem Inhalt des ersten Feldes suchen, arbeiten besonders
+schnell, da die entsprechenden Sätze über eine Hashmethode gefun­
+den werden. 
+ 
+#proc# 
+INT PROC satznr (EUDAT CONST) 
+#endproc# 
+    Liefert aktuelle Satzposition. 
+ 
+#proc# 
+INT PROC saetze (EUDAT CONST) 
+#endproc# 
+    Liefert Anzahl der Sätze. 
+ 
+#proc# 
+BOOL PROC dateiende (EUDAT CONST) 
+#endproc# 
+    Liefert TRUE, wenn 'satznr' groesser als 'saetze' ist. Die letzte
+    erreichbare Satzposition liegt um eins hinter dem letzten Satz
+    (um auch am Ende anfügen zu können). 
+ 
+#proc# 
+PROC auf satz (EUDAT VAR, INT CONST satznr) 
+#endproc# 
+    Positioniert auf den gewünschten Satz. Bei nicht existierenden
+    Sätzen wird auf den ersten bzw. hinter den letzten Satz ge­
+    sprungen. 
+ 
+#proc# 
+PROC weiter (EUDAT VAR) 
+#endproc# 
+    Geht einen Satz weiter, jedoch nicht über das Dateiende hinaus. 
+ 
+#proc# 
+PROC zurueck (EUDAT VAR) 
+#endproc# 
+    Geht einen Satz zurück, falls der erste Satz noch nicht erreicht
+    ist. 
+ 
+#proc# 
+PROC auf satz (EUDAT VAR, TEXT CONST muster) 
+#endproc# 
+    Positioniert auf den ersten Satz, der als erstes Feld 'muster'
+    enthält, anderenfalls hinter den letzten Satz. 
+ 
+#proc# 
+PROC weiter (EUDAT VAR, TEXT CONST muster) 
+#endproc# 
+    Geht weiter, bis das erste Feld 'muster' enthält, bzw. bis hinter
+    den letzten Satz. 
+ 
+#proc# 
+PROC zurueck (EUDAT VAR, TEXT CONST muster) 
+#endproc# 
+    Geht zurück, bis das erste Feld 'muster' enthält, bzw. auf den
+    ersten Satz der EUDAS-Datei. 
+ 
+ 
+#abschnitt ("6.4", "SATZZUGRIFFE", "Satzzugriffe")# 
+ 
+Der aktuelle Satz ist ein SATZ-Objekt. Auf die Felder des aktuellen
+Satzes kann direkt zugegriffen werden. 
+ 
+#proc# 
+PROC feld lesen (EUDAT CONST, INT CONST feldnr, 
+                 TEXT VAR inhalt) 
+#endproc# 
+    Wirkt wie 'feld lesen' auf den aktuellen Satz. 
+ 
+#proc# 
+PROC feld aendern (EUDAT VAR, INT CONST feldnr, 
+                   TEXT CONST inhalt) 
+#endproc# 
+    Wirkt wie 'feld aendern' auf den aktuellen Satz. 
+ 
+#proc# 
+PROC feld bearbeiten (EUDAT CONST, INT CONST feldnr, 
+     PROC (TEXT CONST, INT CONST, INT CONST) bearbeite) 
+#endproc# 
+     Wirkt wie 'feld bearbeiten' auf den aktuellen Satz. 
+ 
+Der aktuelle Satz kann auch als Ganzes bearbeitet werden. 
+ 
+#proc# 
+PROC satz lesen (EUDAT CONST, SATZ VAR satz) 
+#endproc# 
+    Liefert den aktuellen Satz. 
+ 
+#proc# 
+PROC satz aendern (EUDAT VAR, SATZ CONST satz) 
+#endproc# 
+    Ersetzt den aktuellen Satz durch 'satz'. 
+ 
+#proc# 
+PROC satz einfuegen (EUDAT VAR, SATZ CONST satz) 
+#endproc# 
+    Fügt 'satz' vor dem aktuellen Satz ein. 
+#f2# 
+    FEHLER: 
+#f2# 
+    #on("i")#EUDAS-Datei voll#off("i")# 
+    Eine EUDAS-Datei faßt mindestens 5000 Sätze. 
+ 
+#proc# 
+PROC satz loeschen (EUDAT VAR) 
+#endproc# 
+    Löscht den aktuellen Satz. 
+ 
+ 
+#abschnitt ("6.5", "SORTIEREN UND REORGANISIEREN", "Sortieren und Reorganisieren")# 
+ 
+Zum Sortieren können für die einzelnen Felder Typen angegeben
+werden, damit auch Zahlen und Daten richtig sortiert werden kön­
+nen. Außerdem kann die Feldreihenfolge angegeben werden, nach
+der sortiert werden soll. 
+ 
+#proc# 
+PROC feldinfo (EUDAT VAR, INT CONST feldnr, info) 
+#endproc# 
+    Setzt den Feldtyp des Feldes 'feldnr'. Es bedeuten 
+      -1 : normaler Text (Standard) 
+       0 : Text nach DIN. Ziffern und Sonderzeichen werden igno­
+           riert. Groß-und Kleinbuchstaben gelten gleich. Umlaute
+           werden beachtet. 
+       1 : Zahl (beim Vergleich werden alle Zeichen außer Zif­
+           fern ignoriert). 
+       2 : Datum. Es werden Daten der Form "tt.mm.jj" vergli­
+           chen. 
+ 
+#proc# 
+INT PROC feldinfo (EUDAT CONST, INT CONST feldnr) 
+#endproc# 
+    Der Feldtyp des angegebenen Feldes wird geliefert. Zu Anfang
+    ist -1 voreingestellt. 
+ 
+#proc# 
+INT PROC unsortierte saetze (EUDAT CONST) 
+#endproc# 
+    Liefert die Anzahl von Sätzen, die seit dem letzten Sortiervor­
+    gang geändert wurden. Bei einer neuen Datei, die noch nie
+    sortiert wurde, wird immer 0 geliefert. 
+ 
+#proc# 
+PROC dezimalkomma (TEXT CONST komma) 
+#endproc# 
+    Stellt das Dezimalkomma ein, das beim Vergleich von Zahlen
+    gelten soll. 
+#f2# 
+    FEHLER: 
+#f2# 
+    #on("i")#Nicht erlaubtes Dezimalkomma#off("i")# 
+    Nur Texte der Länge 1 sind zugelassen. 
+ 
+#proc# 
+TEXT PROC dezimalkomma 
+#endproc# 
+    Liefert das eingestellte Dezimalkomma ("," ist voreingestellt). 
+ 
+#proc# 
+PROC sortiere (EUDAT VAR, TEXT CONST reihenfolge) 
+#endproc# 
+    Sortiert die Datei in der von 'reihenfolge' angegebenen Reihen­
+    folge. Dabei enthält 'reihenfolge' an der Stelle #bsp ("2*i+1")# den Code
+    der Feldnummer, die als i-te in der Sortierung berücksichtigt
+    werden soll. Das Zeichen an der Stelle #bsp ("2*i")# gibt an, ob das Feld
+    mit der davorstehenden Feldnummer aufsteigend ('+') oder
+    absteigend ('-') sortiert werden soll. 
+ 
+#proc# 
+PROC sortiere (EUDAT VAR) 
+#endproc# 
+    Sortiert die Datei in der zuletzt eingestellten Reihenfolge.
+    Wurde noch keine Reihenfolge angegeben, wird die Datei in der
+    Feldreihenfolge sortiert. 
+ 
+#proc# 
+TEXT PROC sortierreihenfolge (EUDAT CONST) 
+#endproc# 
+    Liefert die zuletzt eingestellte Reihenfolge. Wurde noch nicht
+    sortiert, so wird "" geliefert. 
+ 
+Nach umfangreichen Änderungen an einer EUDAS-Datei ist eine
+Reorganisation sinnvoll, um "Textleichen" zu beseitigen. 
+ 
+#proc# 
+PROC reorganisiere (TEXT CONST dateiname) 
+#endproc# 
+    Die EUDAS-Datei mit dem Namen 'dateiname' wird reorgani­
+    siert. 
+ 
+ 
+#abschnitt ("6.6", "EUDAS-DATEIEN ALS ASSOZIATIVSPEICHER", "EUDAS-Dateien als Assoziativspeicher")# 
+ 
+In diesem Abschnitt soll ein Beispiel erläutert werden, in dem
+EUDAS-Dateien unabhängig von EUDAS für einen ganz anderen
+Zweck benutzt werden. Das folgende kurze Paket soll ein Abkür­
+zungsverzeichnis realisieren, das auf einer EUDAS-Datei basiert. 
+ 
+#beispiel# 
+    PACKET abkuerzungsverzeichnis 
+      DEFINES 
+      verzeichnis laden, 
+      abkuerzung einfuegen, 
+      abkuerzung aendern, 
+      abkuerzung loeschen, 
+      langform : 
+ 
+    EUDAT VAR verz; 
+    SATZ VAR satz; 
+    TEXT VAR inhalt; 
+ 
+    PROC verzeichnis laden (TEXT CONST dateiname) : 
+ 
+      oeffne (verz, dateiname) 
+ 
+    END PROC verzeichnis laden; 
+ 
+    PROC abkuerzung einfuegen (TEXT CONST abk, lang) : 
+ 
+      auf satz (verz, abk); 
+      IF NOT dateiende (verz) THEN 
+        errorstop ("Abkürzung existiert bereits") 
+      ELSE 
+        satz initialisieren (satz); 
+        feld aendern (satz, 1, abk); 
+        feld aendern (satz, 2, lang); 
+        satz einfuegen (satz) 
+      END IF 
+ 
+    END PROC abkuerzung einfuegen; 
+ 
+    PROC abkuerzung aendern (TEXT CONST abk, lang) : 
+ 
+      auf satz (verz, abk); 
+      IF dateiende (verz) THEN 
+        errorstop ("Abkürzung existiert nicht") 
+      ELSE 
+        feld aendern (verz, 2, lang) 
+      END IF 
+ 
+    END PROC abkuerzung aendern; 
+ 
+    PROC abkuerzung loeschen (TEXT CONST abk) : 
+ 
+      auf satz (verz, abk); 
+      IF NOT dateiende (verz) THEN 
+        satz loeschen (verz) 
+      END IF 
+ 
+    END PROC abkuerzung loeschen; 
+ 
+    TEXT PROC langform (TEXT CONST abk) : 
+ 
+      auf satz (verz, abk); 
+      IF dateiende (verz) THEN 
+        inhalt := ""; 
+        errorstop ("Abkürzung nicht vorhanden") 
+      ELSE 
+        feld lesen (verz, 2, inhalt) 
+      END IF; 
+      inhalt
+ 
+    END PROC langform; 
+ 
+    END PACKET abkuerzungsverzeichnis; 
+#text# 
+ 
+Die Prozedur 'verzeichnis laden' koppelt die interne EUDAT-Vari­
+able 'verz' an eine benannte EUDAS-Datei, die eventuell vorher mit
+EUDAS erstellt wurde. In diesem Beispiel sind die Feldnamen egal;
+falls die übergebene EUDAS-Datei noch nicht existiert, wird sie mit
+0 Feldern eingerichtet, was aber nur für eine spätere Anzeige mit
+EUDAS störend wäre. 
+    Grundlage für das Aufsuchen einer bestimmten Abkürzung bil­
+det immer die Prozedur 'auf satz', die nach dem Inhalt des ersten
+Feldes optimiert sucht. Falls die Abkürzung nicht gefunden wurde,
+wird auf das Dateiende positioniert, daher wird jeweils 'dateiende'
+abgefragt. 
+    Beim Einfügen eines neuen Satzes muß eine komplette Satz­
+variable angegeben werden, die bereits mit den Inhalten gefüllt ist.
+Beim späteren Ändern kann jedoch direkt auf ein Feld zugegriffen
+werden, ohne die Satzvariable explizit rauszuholen. 
+    Die Abfrage einer bestimmten Abkürzung bereitet dann keine
+Schwierigkeiten mehr. 
+    Für die Verwendung von EUDAS-Dateien in diesem Beispiel
+spricht zum einen die einfache Programmierung, zum anderen aber
+auch die Möglichkeit, das erstellte Verzeichnis mit den Hilfsmitteln
+von EUDAS zu warten und auszudrucken. 
+
diff --git a/app/eudas/4.4/doc/ref-manual/eudas.ref.7 b/app/eudas/4.4/doc/ref-manual/eudas.ref.7
new file mode 100644
index 0000000..47533ac
--- /dev/null
+++ b/app/eudas/4.4/doc/ref-manual/eudas.ref.7
@@ -0,0 +1,519 @@
+#type ("prop")##limit (14.0)# 
+#format# 
+#page (71)# 
+#kapitel ("7", "Verwaltung", "der offenen", "Dateien")# 
+ 
+ 
+Die in diesem Kapitel beschriebene Schnittstelle verbindet mehrere
+EUDAS-Dateien zu einem großen Dateimodell. Diese virtuelle Datei
+dient als Grundlage für die meisten EUDAS-Funktionen. Zuerst muß
+eine Datei als Bestandteil der virtuellen Datei geöffnet werden, ehe
+sie bearbeitet werden kann. Es ist so bei den Funktionen keine
+Angabe mehr nötig, welche Datei gemeint ist. 
+    Diese Schnittstelle ist in vielen Teilen für die interne
+EUDAS-Anwendung ausgelegt. Bei einigen Prozeduren werden aus
+Effizienzgründen keinerlei Überprüfungen auf illegale Aufrufe oder
+Parameter durchgeführt. Wollen Sie eine solche Prozedur dennoch
+verwenden, sollten Sie die Einhaltung der angegebenen Bedingungen
+sorgfältig überprüfen. 
+ 
+ 
+#abschnitt ("7.1", "DATEIVERWALTUNG", "Dateiverwaltung")# 
+ 
+Mit 'oeffne' wird eine Datei zum Bearbeiten geöffnet. Mit 'kette' und
+'kopple' können weitere Dateien dazugekettet bzw. dazugekoppelt
+werden. Durch 'sichere' können veränderte Kopien zurückgeschrie­
+ben werden. Durch 'dateien loeschen' werden die internen Kopien
+gelöscht. 
+    Mit 'anzahl dateien' kann die Anzahl der vorhandenen Dateien
+erfragt werden. 'anzahl koppeldateien' gibt Auskunft darüber, wie­
+viel Dateien davon gekoppelt sind. 'aendern erlaubt' gibt den Status
+wieder, der beim Öffnen der ersten Datei angegeben wurde. 'inhalt
+veraendert' gibt an, ob die angegebene Datei verändert wurde. Mit
+'eudas dateiname' können die Namen der geöffneten Dateien erfragt
+werden. Bei jedem 'oeffne' wird 'dateiversion' um 1 erhöht. Dies
+dient dazu, ein erfolgtes neues Öffnen von anderen Stellen aus zu
+entdecken. 
+    Mit 'auf koppeldatei' kann die virtuelle Datei auf eine Koppel­
+datei umgeschaltet werden, so daß der Eindruck entsteht, nur diese
+Datei wäre geöffnet worden. 
+ 
+#proc# 
+PROC oeffne (TEXT CONST dateiname, 
+             BOOL CONST aendern erlaubt) 
+#endproc# 
+    Falls Ändern erlaubt sein soll, wird eine Kopie der angegebenen
+    Datei zur Bearbeitung für EUDAS angelegt. Vorher geöffnete
+    Dateien werden gelöscht. Die Änderungserlaubnis wird entspre­
+    chend gesetzt. Es wird die Satzposition der EUDAS-Datei ange­
+    nommen (Ausnahme: steht die EUDAS-Datei hinter dem letzten
+    Satz, wird auf Satz 1 positioniert). 'dateiversion' sowie 'anzahl
+    dateien' werden um 1 erhöht. 
+#f2# 
+    FEHLER: 
+#f1# 
+    #on("i")#Datei nicht gesichert#off("i")# 
+    Eine vorher geöffnete Datei war verändert, aber nicht gesi­
+    chert. 
+#f1# 
+    #on("i")#Datei existiert nicht#off("i")# 
+    Die angegebene Datei ist nicht vorhanden. 
+#f1# 
+    #on("i")#Datei ist keine EUDAS-Datei#off("i")# 
+    Die angegebene Datei hat nicht den für EUDAS-Dateien festge­
+    legten Typ. 
+ 
+#proc# 
+PROC kopple (TEXT CONST dateiname) 
+#endproc# 
+    Die angegebene Datei wird zu den bereits geöffneten Dateien
+    dazugekoppelt. Falls Ändern erlaubt ist, wird eine Kopie dieser
+    Datei verwendet. Dabei werden die ersten Felder der Datei, die
+    bereits in der Hauptdatei vorhanden sind, als Koppelfelder
+    festgelegt. Alle weiteren Felder werden zusätzlich zu den bis­
+    herigen angelegt. 'dateiversion', 'anzahl dateien' und 'anzahl 
+    koppeldateien' werden um 1 erhöht. 
+#f2# 
+    FEHLER: 
+#f1# 
+    #on("i")#keine Datei geoeffnet#off("i")# 
+    Es muß vorher eine Datei geöffnet werden. 
+#f1# 
+    #on("i")#Zuviel Dateien geoeffnet#off("i")# 
+    Die Anzahl der gleichzeitig geöffneten Dateien ist begrenzt. 
+#f1# 
+    #on("i")#Datei existiert nicht#off("i")# 
+    Die angegebene Datei ist nicht vorhanden. 
+#f1# 
+    #on("i")#Datei ist keine EUDAS-Datei#off("i")# 
+    Die angegebene Datei hat nicht den für EUDAS-Dateien festge­
+    legten Typ. 
+#f1# 
+    #on("i")#Zu viele Felder#off("i")# 
+    Die Anzahl der Felder insgesamt ist begrenzt. 
+#f1# 
+    #on("i")#Zu viele Koppelfelder#off("i")# 
+    Die Anzahl der Koppelfelder ist begrenzt. 
+#f1# 
+    #on("i")#keine Koppelfelder vorhanden#off("i")# 
+    Das erste Feld der zu koppelnden Datei ist in der Hauptdatei
+    nicht vorhanden (unterschiedliche Feldnamen). 
+ 
+#proc# 
+PROC kette (TEXT CONST dateiname) 
+#endproc# 
+    Die angegebene Datei wird an die Hauptdatei angekettet, d.h.
+    die Sätze der neuen Datei werden am bisherigen Dateiende
+    angefügt. Falls Ändern erlaubt ist, wird eine Kopie dieser Datei
+    verwendet. Die zu kettende Datei muß in der Feldstruktur nicht
+    mit der Hauptdatei übereinstimmen. Die aktuelle Satzposition
+    wird beibehalten. 'dateiversion' und 'anzahl dateien' werden um
+    1 erhöht. 
+#f2# 
+    FEHLER: 
+#f1# 
+    #on("i")#keine Datei geoeffnet#off("i")# 
+    Es muß vorher eine Datei geöffnet werden. 
+#f1# 
+    #on("i")#Zuviel Dateien geoeffnet#off("i")# 
+    Die Anzahl der gleichzeitig geöffneten Dateien ist begrenzt. 
+#f1# 
+    #on("i")#Datei existiert nicht#off("i")# 
+    Die angegebene Datei ist nicht vorhanden. 
+#f1# 
+    #on("i")#Datei ist keine EUDAS-Datei#off("i")# 
+    Die angegebene Datei hat nicht den für EUDAS-Dateien festge­
+    legten Typ. 
+ 
+#proc# 
+PROC sichere (INT CONST dateinr, TEXT CONST dateiname) 
+#endproc# 
+    Die geöffneten Dateien werden in der Reihenfolge ihres Öffnens
+    durchnumeriert (von 1 an). Die Arbeitskopie mit der angegebe­
+    nen Nummer wird unter dem angegebenen Namen gesichert, aber
+    selbst nicht verändert. Die vorher unter diesem Namen vorhan­
+    dene Datei wird gelöscht. War die zu sichernde Arbeitskopie
+    verändert worden, so wird sie anschließend als nicht verändert
+    angesehen. 
+    Bedingungen: 
+      1 <= dateinr <= anzahl dateien 
+ 
+#proc# 
+PROC dateien loeschen (BOOL CONST auch geaenderte) 
+#endproc# 
+    Es werden alle geöffneten Arbeitskopien gelöscht. EUDAS wird
+    wieder in den Anfangszustand versetzt. Wird 'auch geaenderte'
+    angegeben, wird bei geänderten, aber nicht gesicherten Dateien
+    die Fehlermeldung unterdrückt. 
+#f2# 
+    FEHLER: 
+#f1# 
+    #on("i")#Datei nicht gesichert#off("i")# 
+    Eine vorher geöffnete Datei war verändert, aber nicht gesi­
+    chert. 
+ 
+#proc# 
+BOOL PROC auf koppeldatei 
+#endproc# 
+    Liefert TRUE, wenn auf eine Koppeldatei umgeschaltet wurde. 
+ 
+#proc# 
+PROC auf koppeldatei (INT CONST nr) 
+#endproc# 
+    Umschalten auf Koppeldatei 'nr'. Ist bereits umgeschaltet, wird
+    wieder zurückgeschaltet. In diesem Fall werden bei 'nr' = 1 die
+    Koppelfelder übernommen, anderenfalls nicht. Beim Umschalten
+    bleiben Satzposition, Markierungen und Suchmuster gespeichert.
+    In der Koppeldatei wird die beim letzten Umschalten eingestell­
+    te Position wieder eingenommen. 'dateiversion' wird um 1 er­
+    höht. 
+ 
+#proc# 
+INT PROC anzahl dateien 
+#endproc# 
+    Gibt die Anzahl der insgesamt geöffneten Dateien an. 
+ 
+#proc# 
+INT PROC anzahl koppeldateien 
+#endproc# 
+    Gibt die Anzahl der gekoppelten Dateien an. 
+ 
+#proc# 
+BOOL PROC aendern erlaubt 
+#endproc# 
+    Reflektiert den Status, der bei 'oeffne' gesetzt wurde. 
+ 
+#proc# 
+BOOL PROC inhalt veraendert (INT CONST dateinr) 
+#endproc# 
+    Gibt an, ob die geöffnete Datei mit der angegebenen Nummer
+    verändert wurde. Wird ggf. von 'sichere' zurückgesetzt. 
+    Bedingung: 
+      1 <= dateinr <= anzahl dateien 
+ 
+#proc# 
+TEXT PROC eudas dateiname (INT CONST dateinr) 
+#endproc# 
+    Liefert den Namen, unter dem die entsprechende Datei geöffnet
+    wurde. 
+    Bedingung: 
+      1 <= dateinr <= anzahl dateien 
+ 
+#proc# 
+INT PROC dateiversion 
+#endproc# 
+    Wird bei jedem 'oeffne', 'kette' und 'kopple' zyklisch erhöht. 
+ 
+#proc# 
+INT PROC folgedatei (INT CONST dateinr) 
+#endproc# 
+    Eine geöffnete EUDAS-Datei wird in eine von zwei Listen auf­
+    genommen, die der geketteten Dateien und die der gekoppelten.
+    Diese Prozedur liefert jeweils die Nummer der nächsten Datei in
+    der Liste, am Ende aber 0. Die Liste der geketteten Dateien
+    beginnt immer mit 1, mit 'folgedatei (0)' erhält man die erste
+    gekoppelte Datei. 
+    Bedingung: 
+      0 <= dateinr <= anzahl dateien 
+ 
+ 
+#abschnitt ("7.2", "FELDSTRUKTUR", "Feldstruktur")# 
+ 
+Die einzelnen Sätze der kombinierten EUDAS-Datei sind in Felder
+unterteilt. Diese setzen sich zusammen aus den Feldern der Haupt­
+datei und der einzelnen Koppeldateien, wobei die Koppelfelder je­
+weils nur einmal auftauchen. 
+    'anzahl felder' liefert die Anzahl der vorhanden Felder. Mit
+'feldnamen lesen' und 'feldnamen bearbeiten' können die Feldnamen
+abgefragt werden. 'feldnummer' liefert einen Index für einen vor­
+gegebenen Feldnamen, da die Felder immer über Nummern angespro­
+chen werden. 
+    Die Prozeduren 'feld lesen' und 'feld bearbeiten' ermöglichen
+den Zugriff auf den Feldinhalt des aktuellen Satzes; durch 'feld
+aendern' kann dieser Inhalt abgeändert werden. 
+ 
+#proc# 
+INT PROC anzahl felder 
+#endproc# 
+    Liefert die Anzahl der vorhanden Felder. 
+ 
+#proc# 
+PROC feldnamen lesen (INT CONST feldnr, 
+                      TEXT VAR feldname) 
+#endproc# 
+    Liefert in 'feldname' den Namen des Feldes mit der Nummer
+    'feldnr'. 
+    Bedingung: 
+      1 <= feldnr <= anzahl felder 
+ 
+#proc# 
+PROC feldnamen bearbeiten (INT CONST feldnr, 
+     PROC (TEXT CONST, INT CONST, INT CONST) bearbeite) 
+#endproc# 
+    Die Prozedur 'bearbeite' wird aufgerufen. Als Parameter werden
+    ein Text und Anfangs- und Endposition des gewünschten Feld­
+    namens in diesem Text übergeben. Verhindert unnötiges Kopie­
+    ren des Feldnamens in eine TEXT-Variable. Der übergebene
+    Text darf nicht verändert werden! 
+    Bedingung: 
+      1 <= feldnr <= anzahl felder 
+ 
+#proc# 
+INT PROC feldnummer (TEXT CONST feldname) 
+#endproc# 
+    Liefert den index zu dem angegebenen Feldnamen. Falls ein
+    solcher Name nicht existiert, wird 0 geliefert. 
+ 
+#proc# 
+PROC feld lesen (INT CONST feldnr, TEXT VAR inhalt) 
+#endproc# 
+    Liefert den Inhalt des angegebenen Feldes. 
+    Bedingung: 
+      1 <= feldnr <= anzahl felder 
+ 
+#proc# 
+PROC feld bearbeiten (INT CONST feldnr, 
+     PROC (TEXT CONST, INT CONST, INT CONST) bearbeite) 
+#endproc# 
+    Die Prozedur 'bearbeite' wird aufgerufen. Der Feldinhalt des
+    angegebenen Feldes steht im übergebenen Text innerhalb der
+    Grenzen. Ist die Obergrenze kleiner als die Untergrenze, so ist
+    das Feld leer. 
+    Bedingung: 
+      1 <= feldnr <= anzahl felder 
+ 
+#proc# 
+PROC feld aendern (INT CONST feldnr, TEXT CONST inhalt) 
+#endproc# 
+    Ändert den Inhalt des angegebenen Feldes. 
+    Bedingung: 
+      NOT ende der datei 
+      1 <= feldnr <= anzahl felder 
+ 
+#proc# 
+INT PROC feldinfo (INT CONST feldnummer) 
+#endproc# 
+    Liefert den Typ des angegebenen Feldes. 
+    Bedingung: 
+      1 <= feldnummer <= anzahl felder 
+ 
+#proc# 
+PROC notizen lesen (INT CONST nr, TEXT VAR inhalt) 
+#endproc# 
+    Liest die angegebenen Notizen ('nr' = 1,2,3) aus der ersten
+    Datei oder der umgeschalteten Koppeldatei. 
+ 
+#proc# 
+PROC notizen aendern (INT CONST nr, TEXT CONST inhalt) 
+#endproc# 
+    Ändert die Notizen ('nr' = 1,2,3) der ersten Datei oder der um­
+    geschalteten Koppeldatei. 
+ 
+ 
+#abschnitt ("7.3", "POSITIONIERUNG", "Positionierung")# 
+ 
+Das virtuelle Dateimodell von EUDAS verfügt ebenfalls über eine
+Satzposition, die verändert werden kann. 
+    Durch 'satznummer' wird die aktuelle Satznummer geliefert,
+beim Koppeln kann über 'satzkombination' die Reihenfolge der Kop­
+pelkombinationen bestimmt werden. 'dateiende' zeigt an, ob die
+Satzposition hinter dem letzten Satz liegt. Mit 'weiter' und 'zurueck'
+erfolgt die eigentliche Positionierung. Hier kann außer der Positio­
+nierung um Einzelsätze auch die Positionierung auf den nächsten
+ausgewählten oder markierten Satz angefordert werden. Mit 'auf 
+satz' schließlich kann ein bestimmter Satz angesprungen werden. 
+ 
+#proc# 
+INT PROC satznummer 
+#endproc# 
+    Liefert die Nummer des aktuellen Satzes. Die Sätze werden von
+    1 an durchnumeriert, wobei über die geketteten Dateien wei­
+    tergezählt wird. 
+    Bedingung: 
+      anzahl dateien > 0 
+ 
+#proc# 
+INT PROC satzkombination 
+#endproc# 
+    Liefert die laufende Nummer der Koppelkombination des aktuel­
+    len Satzes. Wird nur durch 'weiter' im Einzelsatzmodus erhöht.
+    Normalerweise 1. 
+    Bedingung: 
+      anzahl dateien > 0 
+ 
+#proc# 
+BOOL PROC dateiende 
+#endproc# 
+    Gibt an, ob die Satzposition hinter dem letzten Satz liegt. 
+ 
+#proc# 
+PROC weiter (INT CONST modus) 
+#endproc# 
+    Erhöht die aktuelle Satzposition. Für 'modus' gibt es 3 Möglich­
+    keiten: 
+    1: Falls eine weitere Satzkombination besteht, wird diese ein­
+       genommen, sonst zum nächsten Satz. 
+    2: Zum nächsten durch Suchbedingung ausgewählten Satz. Wird
+       optimiert. 
+    3: Zum nächsten markierten Satz. Wird optimiert. 
+    Ist kein Satz mehr vorhanden, wird die Satzposition hinter dem
+    letzten Satz eingenommen. 
+    Bedingung: 
+      anzahl dateien > 0 
+ 
+#proc# 
+PROC zurueck (INT CONST modus) 
+#endproc# 
+    Geht um einen Satz zurück. Die Modusangabe ist wie bei 'wei­
+    ter', jedoch wird im Modus 1 keine weitere Satzkombination
+    ausprobiert. Die Positionierung endet bei Satz 1. 
+    Bedingung: 
+      anzahl dateien > 0 
+ 
+#proc# 
+PROC auf satz (INT CONST satznr) 
+#endproc# 
+    Geht auf den angegebenen Satz. Ist 'satznr' < 1, wird auf Satz 1
+    positioniert, ist der angegebene Satz nicht vorhanden, wird
+    hinter den letzten Satz positioniert. Es wird jeweils die erste
+    Satzkombination eingenommen. 
+    Bedingung: 
+      anzahl dateien > 0 
+ 
+ 
+#abschnitt ("7.4", "ÄNDERUNGEN", "Änderungen")# 
+ 
+Sätze des Dateimodells können eingefügt oder gelöscht werden.
+Durch das Einfügen entsteht ein leerer Satz vor dem aktuellen Satz;
+alle weiteren Sätze rücken eine Stelle weiter. Beim Löschen wird
+dieser Vorgang wieder rückgängig gemacht. 
+    Durch 'satz einfuegen' wird ein Leersatz eingefügt; durch
+'satz loeschen' wird der aktuelle Satz gelöscht. 
+    Sätze in gekoppelten Dateien werden grundsätzlich nicht ge­
+löscht; auch beim Einfügen entsteht nicht automatisch ein Leersatz
+in den gekoppelten Dateien. Änderungen in den Koppeldateien
+(durch 'feld aendern') werden gepuffert. Durch 'aenderungen ein­
+tragen' werden die Änderungen dann in die Koppeldateien eingetra­
+gen. Dabei kann auch ein neuer Satz in die Koppeldatei eingefügt
+werden. Bei Positionierungen wird diese Prozedur automatisch auf­
+gerufen. 
+ 
+#proc# 
+PROC satz einfuegen 
+#endproc# 
+    Fügt vor dem aktuellen Satz einen Leersatz ein. 
+    Bedingung: 
+      anzahl dateien > 0 
+ 
+#proc# 
+PROC satz loeschen 
+#endproc# 
+    Löscht den aktuellen Satz. Hat hinter dem letzten Satz keine
+    Wirkung. 
+    Bedingung: 
+      anzahl dateien > 0 
+ 
+#proc# 
+PROC aenderungen eintragen 
+#endproc# 
+    Trägt die gepufferten Änderungen in die Koppeldateien ein.
+    Dabei können die folgenden Fälle auftreten: 
+    1. Der Satz in der Koppeldatei wird geändert. 
+       Dies geschieht dann, wenn vorher ein passender Satz in der
+       Koppeldatei vorhanden war und die Koppelfelder nicht ver­
+       ändert wurden. 
+    2. In der Koppeldatei wird ein neuer Satz eingefügt. 
+       Wenn die Koppelfelder und noch andere Felder einer Datei
+       geändert wurden, wird in dieser Datei ein neuer Satz einge­
+       fügt. 
+    3. Es wird neu gekoppelt. 
+       Wurden nur die Koppelfelder einer Datei geändert, wird ein
+       neuer, zu diesen Feldern passender Satz gesucht. Nach
+       'aenderungen eintragen' erscheinen unter den Feldern der
+       Datei die neuen Inhalte. 
+ 
+ 
+#abschnitt ("7.5", "SUCHBEDINGUNGEN", "Suchbedingungen")# 
+ 
+Über 'suchbedingung' kann eine Suchbedingung eingetragen werden,
+die für jeden Satz geprüft werden soll. Mit 'satz ausgewaehlt' wird
+erfragt, ob der aktuelle Satz die Suchbedingung erfüllt. Die Such­
+bedingung kann mit 'suchbedingung loeschen' wieder ausgeschaltet
+werden. 
+    Einzelne Sätze können auch markiert werden. Nach einem Öff­
+nen ist zunächst kein Satz markiert. Durch 'markierung  aendern'
+kann die Markierung eines Satzes geändert werden. 'satz markiert'
+fragt ab, ob der aktuelle Satz markiert ist. 'markierte saetze' liefert
+die Anzahl der markierten Sätze. Mit 'markierungen loeschen' wer­
+den alle Markierungen entfernt. 
+ 
+#proc# 
+PROC suchbedingung (INT CONST feldnr, 
+                    TEXT CONST bedingung) 
+#endproc# 
+    Stellt für das angegebene Feld die im Text als Muster angege­
+    bene Suchbedingung ein. Weitere Aufrufe verknüpfen die Be­
+    dingungen mit UND (auch wenn das gleiche Feld erneut angege­
+    ben wird). 
+    Bedingung: 
+      anzahl dateien > 0 
+      1 <= feldnr <= anzahl felder 
+#f2# 
+    FEHLER: 
+#f1# 
+    #on("i")#Suchmuster zu umfangreich#off("i")# 
+    Es wurden zu viele Vergleiche gefordert. 
+ 
+#proc# 
+BOOL PROC satz ausgewaehlt 
+#endproc# 
+    Gibt an, ob die Suchbedingung auf den aktuellen Satz zutrifft.
+    Hinter dem letzten Satz wird immer FALSE geliefert. 
+    Bedingung: 
+      anzahl dateien > 0 
+ 
+#proc# 
+PROC suchbedingung lesen (INT CONST feldnr, TEXT VAR bedingung) 
+#endproc# 
+    Liefert die zuletzt für das angegebene Feld eingestellte Bedin­
+    gung, falls die Suchbedingung nicht gelöscht und keine Datei
+    neu geöffnet wurde. 
+    Bedingung: 
+      1 <= feldnr <= anzahl felder 
+ 
+#proc# 
+PROC suchbedingung loeschen 
+#endproc# 
+    Löscht die eingestellte Suchbedingung wieder. Anschließend
+    sind alle Sätze ausgewählt. 
+    Bedingung: 
+      anzahl dateien > 0 
+ 
+#proc# 
+PROC markierung aendern 
+#endproc# 
+    Ändert die Markierung des aktuellen Satzes ins Gegenteil. 
+    Bedingung: 
+      anzahl dateien > 0 
+ 
+#proc# 
+BOOL PROC satz markiert 
+#endproc# 
+    Gibt an, ob der aktuelle Satz markiert ist. 
+    Bedingung: 
+      anzahl dateien > 0 
+ 
+#proc# 
+INT PROC markierte saetze 
+#endproc# 
+    Gibt an, wieviel Sätze insgesamt markiert sind. 
+    Bedingung: 
+      anzahl dateien > 0 
+ 
+#proc# 
+PROC markierungen loeschen 
+#endproc# 
+    Löscht alle Markierungen. 
+    Bedingung: 
+      anzahl dateien > 0 
+
diff --git a/app/eudas/4.4/doc/ref-manual/eudas.ref.8 b/app/eudas/4.4/doc/ref-manual/eudas.ref.8
new file mode 100644
index 0000000..5e8d220
--- /dev/null
+++ b/app/eudas/4.4/doc/ref-manual/eudas.ref.8
@@ -0,0 +1,444 @@
+#type ("prop")##limit (14.0)# 
+#format# 
+#page (83)# 
+#kapitel ("8", "Funktionen", "zur", "Bearbeitung")# 
+ 
+ 
+ 
+Die Verarbeitungsfunktionen arbeiten jeweils auf der aktuell geöff­
+neten Datei. Falls mindestens ein Satz markiert ist, werden nur
+markierte Sätze bearbeitet, anderenfalls die durch die Suchbedin­
+gung ausgewählten Sätze. 
+ 
+ 
+#abschnitt ("8.1", "DRUCKEN", "Drucken")# 
+ 
+Zum Drucken wird ein Druckmuster als Textdatei benötigt. Dessen
+Name muß beim Aufruf der Prozedur 'drucke' angegeben werden.
+Werden beim Übersetzen des Druckmusters Fehler entdeckt, so wird
+der Paralleleditor aufgerufen und kein Druckvorgang durchgeführt. 
+    Normalerweise sendet der Druckgenerator die Ausgabe direkt
+zum Drucker. Alternativ kann die Ausgabe auch in eine Datei ge­
+schrieben werden. Dieses Verfahren kann mit 'direkt drucken' umge­
+stellt werden. Der Aufruf 
+ 
+#beispiel# 
+    direkt drucken (TRUE) 
+#text# 
+ 
+sendet alle Dateien direkt zum Drucker, mit 
+ 
+#beispiel# 
+    direkt drucken (FALSE) 
+#text# 
+ 
+wird die Ausgabe in Dateien abgelegt. Diese Dateien erhalten Namen
+der Form 
+ 
+#beispiel# 
+    "Druckmustername.a$n" 
+#text# 
+ 
+wobei 'n' eine laufende Nummer zur Unterscheidung ist. 
+    Soll die Druckausgabe in eine ganz bestimmte Datei geleitet
+werden, so kann vor dem Aufruf von 'drucke' die Prozedur 'druck­
+datei' aufgerufen werden, die als Parameter den Namen der Ausga­
+bedatei erhält. Existiert die Datei noch nicht, wird sie eingerichtet,
+ansonsten wird die Ausgabe am Ende angehängt. 
+    Die Einstellung der Ausgabedatei gilt nur für einen Druckvor­
+gang und überschreibt für diesen Druckvorgang 'direkt drucken'.
+Beim nächsten Druckvorgang wird wieder die durch 'direkt drucken'
+festgelegte Einstellung verwendet. 
+    Wenn beim Drucken ein großes Ausgabevolumen anfällt, kann es
+sinnvoll sein, die Ausgabe in mehrere kleine Dateien aufzuteilen.
+Dies gilt auch, wenn direkt gedruckt werden soll, da auch in diesem
+Fall eine Zwischendatei erzeugt werden muß. Die maximale Anzahl
+von Zeilen pro Datei wird durch 'max druckzeilen' angegeben. 
+    Der dort angegeben Wert gilt nur ungefähr - ein Wechsel der
+Ausgabedatei findet dann statt, wenn die Ausgabedatei nach Bear­
+beitung eines Satzes die Maximalanzahl überschritten hat. In die
+neue Datei wird anschließend zuerst der Initialisierungsteil des
+Druckmusters kopiert, ehe mit der Ausgabe des nächsten Satzes
+fortgefahren wird. 
+ 
+Die Prozeduren im einzelnen: 
+ 
+#proc# 
+PROC drucke (TEXT CONST druckmuster) 
+#endproc# 
+    Die aktuell geöffnete Datei wird nach dem angegebenen Druck­
+    muster gedruckt. 
+#f2# 
+    FEHLER: 
+#f1# 
+    #on("i")#Datei "druckmuster" existiert nicht#off("i")# 
+    Das angegebene Druckmuster ist nicht vorhanden. 
+#f1# 
+    #on("i")#keine Datei geoeffnet#off("i")# 
+    Zum Drucken muß eine Datei geöffnet sein. 
+#f1# 
+    #on("i")#direkt Drucken nicht möglich#off("i")# 
+    Es ist kein Druckprogramm installiert oder der Spooler läßt sich
+    mit 'print' nicht ansprechen. Der Druck wird abgebrochen, die
+    Ausgabedatei ist noch vorhanden. 
+ 
+#proc# 
+PROC direkt drucken (BOOL CONST ja) 
+#endproc# 
+    Gibt an, ob die Druckausgaben direkt gedruckt oder in einer
+    Datei gesammelt werden sollen. 
+ 
+#proc# 
+PROC druckdatei (TEXT CONST ausgabedatei) 
+#endproc# 
+    Leitet die Druckausgabe des nächsten Druckvorgangs in die
+    Datei 'ausgabedatei'. Die Einstellung von 'direkt drucken' wird
+    für diesen Druckvorgang überschrieben. Die Ausgabe wird am
+    Ende der Datei angehängt, falls nötig, wird die Ausgabedatei
+    vorher eingerichtet. 
+ 
+#proc# 
+PROC maxdruckzeilen (INT CONST zeilen) 
+#endproc# 
+    Stellt die maximale Anzahl von Zeilen für die Ausgabedatei ein.
+    Beim Überschreiten dieses Wertes wird eine neue Datei ange­
+    fangen. Standardwert ist 4000. 
+ 
+#proc# 
+TEXT PROC lfd nr 
+#endproc# 
+    Liefert während des Druckens die laufende Nummer des gerade
+    gedruckten Satzes als Text. 
+ 
+#proc# 
+BOOL PROC gruppenwechsel (INT CONST gruppennr) 
+#endproc# 
+    Kann innerhalb eines Vor- oder Nachspanns beim Drucken ab­
+    gefragt werden, um festzustellen, ob die angegebene Gruppe
+    gewechselt und damit den Vor- bzw. Nachspann mitverursacht
+    hat (es können zu einem Zeitpunkt mehrere Gruppen wechseln).
+    Die Gruppennummer 0 gibt die Standardgruppe an, die nur vor
+    dem ersten und nach dem letzten Satz wechselt. 
+ 
+ 
+#abschnitt ("8.2", "KOPIEREN", "Kopieren")# 
+ 
+Zum selektiven Kopieren von EUDAS-Dateien wird ein Kopiermuster
+benötigt. Dieses gibt die Zuordnung zwischen Feldern der Ziel- und
+der Quelldatei an. Die Quelldatei ist immer die aktuell geöffnete
+Datei. 
+    Die Kopierfunktion wird durch 'kopiere' aufgerufen. Parameter
+sind der Name der Zieldatei und das Kopiermuster als FILE. Alter­
+nativ kann statt des Kopiermusters eine Prozedur übergeben wer­
+den, die die Kopieranweisungen erhält. 
+    Der eigentliche Kopiervorgang wird durch den Operator 'K'
+bewirkt. Dieser erhält den Zielfeldnamen und einen TEXT-Aus­
+druck als Parameter. Der Wert des TEXT-Ausdrucks wird in das
+jeweilige Feld der Zieldatei geschrieben. 
+    Existiert die Zieldatei noch nicht, so wird sie mit den Feldern
+eingerichtet, die in den einzelnen 'K'-Ausdrücken angegeben sind
+und zwar in der angeführten Reihenfolge. Existiert die Zieldatei, so
+werden gegebenenfalls noch nicht vorhandene Felder am Ende ange­
+fügt. 
+    Die Prozedur 'std kopiermuster' liefert zu einer gegebenen
+Zieldatei ein Standard-Muster, das als Auswahlgrundlage dienen
+kann. Existiert die Zieldatei nicht, werden alle Felder der Quell­
+datei 1 : 1 kopiert, anderenfalls wird zu jedem Feld der Zieldatei
+ein passendes Feld der Quelldatei gesucht - die Feldreihenfolge
+richtet sich in diesem Fall nach der Zieldatei. 
+ 
+#proc# 
+PROC kopiere (TEXT CONST dateiname, 
+              FILE VAR kopiermuster) 
+#endproc# 
+    Die aktuell geöffnete Datei wird nach den Angaben in 'kopier­
+    muster' in die Datei 'dateiname' kopiert. Das Kopiermuster wird
+    dem ELAN-Compiler übergeben. Tritt bei der Übersetzung ein
+    Fehler auf, wird der Paralleleditor aufgerufen. 
+#f2# 
+    FEHLER: 
+#f1# 
+    #on("i")#Datei ist keine EUDAS-Datei#off("i")# 
+    Zieldatei existiert, ist aber keine EUDAS-Datei. 
+#f1# 
+    #on("i")#keine Datei geoeffnet#off("i")# 
+    Es muß eine virtuelle Datei vorhanden sein. 
+ 
+#proc# 
+PROC kopiere (TEXT CONST dateiname, PROC kopierfunktion) 
+#endproc# 
+    Wie oben, nur ist die Kopierfunktion gleich als Prozedur vor­
+    handen. 
+#f2# 
+    FEHLER: 
+#f1# 
+    #on("i")#Datei ist keine EUDAS-Datei#off("i")# 
+    Zieldatei existiert, ist aber keine EUDAS-Datei. 
+#f1# 
+    #on("i")#keine Datei geoeffnet#off("i")# 
+    Es muß eine virtuelle Datei vorhanden sein. 
+ 
+#proc# 
+OP K (TEXT CONST feldname, ausdruck) 
+#endproc# 
+    Kopiert den Ausdruck in das Feld 'feldname' der Zieldatei.
+    Dieses Feld wird eingerichtet, falls es noch nicht existiert.
+    Dieser Operator ist nur während eines Kopiervorganges de­
+    finiert (also in einem Kopiermuster oder einer Kopierfunktion).
+    Er darf nicht in einer IF-Klausel stehen, sondern muß bei
+    jedem Satz mit gleichem Feldnamen an der gleichen Stelle auf­
+    gerufen werden. 
+ 
+#proc# 
+PROC std kopiermuster (TEXT CONST dateiname, 
+                       FILE VAR kopiermuster) 
+#endproc# 
+    Liefert ein Standard-Kopiermuster, abhängig von der Zieldatei
+    'dateiname'. Existiert diese nicht, wird die Quelldatei unverän­
+    dert kopiert, ansonsten richtet sich das Kopiermuster nach der
+    Zieldatei. 
+ 
+ 
+#abschnitt ("8.3", "TRAGEN", "Tragen")# 
+ 
+Durch Tragen können Sätze komplett in eine Zieldatei transportiert
+werden. In der Quelldatei sind sie anschließend nicht mehr vorhan­
+den. Eine ganze Auswahl von Sätzen kann mit 'trage' transportiert
+werden. 'trage satz' transportiert nur den aktuellen Satz. Mit
+'hole satz' kann der letzte Satz der Zieldatei wieder zurückgeholt
+werden, so daß eine EUDAS-Datei auch als Zwischenspeicher für
+Einzelsätze verwendet werden kann. 
+    Existiert die Zieldatei bereits, muß sie mindestens so viele
+Felder wie die Quelldatei besitzen, damit keine Informationen ver­
+lorengehen können. Die Feldnamen müssen nicht übereinstimmen.
+Existiert die Zieldatei noch nicht, wird sie mit den Feldern der
+Quelldatei eingerichtet. 
+    Die Tragefunktion kann um eine gleichzeitige Prüfung erweitert
+werden. Dabei werden Bedingungen überprüft, die bei der Zieldatei
+gespeichert sind. Sätze, die diese Bedingungen verletzen, werden
+nicht getragen. Eine entsprechende Meldung wird in eine Protokoll­
+datei geschrieben, die als Parameter übergeben werden muß. 
+    Die Prüfbedingungen stehen als ausführbares Programm in den
+Notizen der Zieldatei. Prüfbedingungen können mit mehreren Proze­
+duren formuliert werden. 'pruefe' nimmt eine beliebige Bedingung als
+Parameter und gibt bei Mißerfolg eine Meldung aus. 'wertemenge'
+prüft auf Übereinstimmung mit einem der angegebenen Werte. 'feld­
+maske' legt eine Maske für ein Feld fest, die auf den Inhalt zutref­
+fen muß. 
+    Mit Hilfe der Prozedur 'eindeutige felder' können Satzduplikate
+erkannt werden. Auch diese werden nicht getragen. 
+    Die bei den Prüfbedingungen angegebenen Feldnamen müssen in
+der Quelldatei vorhanden sein. Falls eine Prüfprozedur außerhalb
+von 'trage' aufgerufen wird, führt eine Verletzung der Prüfbedin­
+gung zu einem 'errorstop'. 
+ 
+#proc# 
+PROC trage (TEXT CONST dateiname, 
+            FILE VAR protokoll, BOOL CONST test) 
+#endproc# 
+    Alle ausgewählten Sätze werden in die Datei 'dateiname' getra­
+    gen. Diese wird gegebenenfalls eingerichtet. Falls 'test' ange­
+    geben ist, werden die in den Notizen der Zieldatei enthaltenen
+    Bedingungen geprüft. Nur in diesem Fall muß 'protokoll' initial­
+    isiert sein. 
+#f2# 
+    FEHLER: 
+#f1# 
+    #on("i")#kein Satz zum Tragen vorhanden#off("i")# 
+    Die Quelldatei ist leer oder es ist keine Datei geöffnet. 
+#f1# 
+    #on("i")#Datei ist keine EUDAS-Datei#off("i")# 
+    Zieldatei existiert, ist aber keine EUDAS-Datei. 
+#f1# 
+    #on("i")#Zieldatei hat falsche Felderzahl#off("i")# 
+    Zu wenig Felder in der Zieldatei. 
+ 
+#proc# 
+PROC trage satz (TEXT CONST dateiname) 
+#endproc# 
+    Der aktuelle Satz wird in die Datei 'dateiname' getragen. 
+#f2# 
+    FEHLER: 
+#f1# 
+    #on("i")#kein Satz zum Tragen vorhanden#off("i")# 
+    Keine Datei geöffnet oder Datei ist am Ende. 
+#f1# 
+    #on("i")#Datei ist keine EUDAS-Datei#off("i")# 
+    Zieldatei existiert, ist aber keine EUDAS-Datei. 
+#f1# 
+    #on("i")#Zieldatei hat falsche Felderzahl#off("i")# 
+    Zu wenig Felder in der Zieldatei. 
+ 
+#proc# 
+PROC pruefe (TEXT CONST feldname, BOOL CONST bedingung) 
+#endproc# 
+    Wenn die angegebene Bedingung FALSE liefert, wird eine Mel­
+    dung in die Protokolldatei geschrieben und der jeweilige Satz
+    nicht getragen. 
+ 
+#proc# 
+PROC wertemenge (TEXT CONST feldname. menge) 
+#endproc# 
+    Es wird geprüft, ob das angegebene Feld in der Wertemenge
+    enthalten ist. Die einzelnen Werte in der Wertemenge werden
+    dabei durch Komma getrennt. Leerzeichen sind signifikant. 
+ 
+#proc# 
+PROC feldmaske (TEXT CONST feldname, maske) 
+#endproc# 
+    Es wird geprüft, ob das angegebene Feld zu der Maske paßt. Die
+    Zeichen in der Maske haben dabei folgende Bedeutung: 
+      '9'   trifft auf jede Ziffer zu 
+      'X'   trifft auf jedes Zeichen zu 
+      'A'   trifft auf jeden Großbuchstaben zu (einschließlich
+            Umlaute) 
+      'a'   trifft auf jeden Kleinbuchstaben zu (einschließlich
+            Umlaute und 'ß') 
+      '*'   trifft auf eine Folge beliebiger Zeichen zu (auch die
+            leere Folge). Eine sparsame Verwendung wird empfoh­
+            len, da die Bearbeitung sehr aufwendig ist. 
+    Alle anderen Zeichen treffen nur auf ein gleiches Zeichen zu. 
+ 
+#proc# 
+PROC eindeutige felder (INT CONST anzahl) 
+#endproc# 
+    Gibt an, die wieviel ersten Felder einen Satz eindeutig identifi­
+    zieren sollen. Ein Satz, der mit einem Satz der Datei in diesen
+    Feldern übereinstimmt, wird nicht getragen. Ohne diese Angabe
+    wird keine derartige Prüfung vorgenommen. 
+ 
+#proc# 
+PROC hole satz (TEXT CONST dateiname) 
+#endproc# 
+    Holt den letzten Satz der angegebenen Datei und fügt ihn vor
+    dem aktuellen Satz ein. 
+#f2# 
+    FEHLER: 
+#f1# 
+    #on("i")#"dateiname" existiert nicht#off("i")# 
+#f1# 
+    #on("i")#Datei ist keine EUDAS-Datei#off("i")# 
+    Zieldatei existiert, ist aber keine EUDAS-Datei. 
+#f1# 
+    #on("i")#Zieldatei hat falsche Felderzahl#off("i")# 
+    Zu viele Felder in der angegebenen Datei. 
+#f1# 
+    #on("i")#Kein Satz zum Tragen vorhanden#off("i")# 
+    Die angegebene Datei ist leer. 
+#f1# 
+    #on("i")#keine Datei geoeffnet#off("i")# 
+    Es muß eine virtuelle Datei vorhanden sein. 
+ 
+ 
+#abschnitt ("8.4", "VERARBEITUNG", "Verarbeitung")# 
+ 
+Die ausgewählten Sätze der aktuellen Datei können nach einer
+Verarbeitungsvorschrift verändert oder geprüft werden. Dies ge­
+schieht durch die Prozedur 'verarbeite'. Als Parameter kann ent­
+weder ein Verarbeitungsmuster als FILE oder die Verarbeitungs­
+funktion direkt als Prozedur übergeben werden. 
+    Die Vorschrift wird durch den Operator 'V' realisiert. 
+ 
+#proc# 
+PROC verarbeite (FILE VAR verarbeitungsmuster) 
+#endproc# 
+    Die aktuelle Datei wird nach dem angegebenen Muster bearbei­
+    tet. Enthält die Vorschrift, die dem ELAN-Compiler übergeben
+    wird, einen Fehler, wird der Paralleleditor aufgerufen. 
+#f2# 
+    FEHLER: 
+#f1# 
+    #on("i")#keine Datei geoeffnet#off("i")# 
+    Es muß eine virtuelle Datei vorhanden sein. 
+ 
+#proc# 
+PROC verarbeite (PROC verarbeitungsfunktion) 
+#endproc# 
+    Wie oben, nur wird die Vorschrift direkt als Prozedur überge­
+    ben. 
+#f2# 
+    FEHLER: 
+#f1# 
+    #on("i")#keine Datei geoeffnet#off("i")# 
+    Es muß eine virtuelle Datei vorhanden sein. 
+ 
+#proc# 
+OP V (TEXT CONST feldname, ausdruck) 
+#endproc# 
+    Das angegebene Feld des aktuellen Satzes wird durch den Aus­
+    druck ersetzt. 
+#f2# 
+    FEHLER: 
+#f1# 
+    #on("i")#Das Feld "feldname" ist nicht definiert.#off("i")# 
+    Das angegebene Feld ist nicht vorhanden. 
+ 
+ 
+#abschnitt ("8.5", "FUNKTIONEN IN AUSDRÜCKEN", "Funktionen in Ausdrücken")# 
+ 
+Für Ausdrücke bei den in diesem Kapitel beschriebenen Prozeduren
+sind einfache Funktionen zur Abfrage von Feldinhalten vorhanden.
+Mit 'f' kann der Inhalt eines benannten Feldes erfragt werden, bei
+'wert' wird der Inhalt erst in eine REAL-Zahl umgewandelt, wobei
+nichtnumerische Zeichen ignoriert werden. 
+    Die Prozedur 'textdarstellung' kann dazu verwendet werden,
+den Wert einer TEXT-Variablen als TEXT-Denoter in ELAN-Syntax
+darzustellen. 
+    Die Prozedur 'zahltext' kann dazu verwendet werden, aus einer
+REAL-Zahl einen mit der richtigen Zahl von Nachkommastellen ver­
+sehenen, variabel langen Text zu machen. 
+ 
+#proc# 
+TEXT PROC f (TEXT CONST feldname) 
+#endproc# 
+    Liefert den Inhalt des angegebenen Feldes. 
+#f2# 
+    FEHLER: 
+#f1# 
+    #on("i")#Das Feld "feldname" ist nicht definiert.#off("i")# 
+ 
+#proc# 
+REAL PROC wert (TEXT CONST feldname) 
+#endproc# 
+    Liefert den Inhalt des angegebenen Feldes als REAL. Dabei
+    werden nichtnumerische Zeichen ignoriert, ausgenommen das
+    Minuszeichen und das eingestellte Dezimalkomma (s. 'dezimal­
+    komma'). Tritt kein numerisches Zeichen auf, wird der Wert 0.0
+    geliefert. 
+#f2# 
+    FEHLER: 
+#f1# 
+    #on("i")#Das Feld "feldname" ist nicht definiert.#off("i")# 
+ 
+#proc# 
+REAL PROC wert (TEXT CONST feldname, INT CONST kommastellen) 
+#endproc# 
+    Wie 'wert' mit einem Parameter, nur daß das Ergebnis auf die
+    angegebene Anzahl von Nachkommastellen gerundet wird. 
+#f2# 
+    FEHLER: 
+#f1# 
+    #on("i")#Das Feld "feldname" ist nicht definiert.#off("i")# 
+ 
+#proc# 
+TEXT PROC textdarstellung (TEXT CONST anzeigetext) 
+#endproc# 
+    Liefert 'anzeigetext' als TEXT-Denoter, also in Anführungs­
+    strichen. Anführungsstriche im Text werden dabei verdoppelt.
+    Steuerzeichen von 0 bis 31 werden in lesbare Form gebracht. 
+ 
+#proc# 
+TEXT PROC zahltext (REAL CONST wert, INT CONST kommastellen) 
+#endproc# 
+    Liefert den Text des angegebenen Werts mit dem eingestellten
+    Dezimalkomma und mit der angegebenen Zahl von Nachkomma­
+    stellen. Sind die Kommastellen 0, wird auch das Komma unter­
+    drückt. Der Text erhält soviel Stellen, wie zur Darstellung
+    benötigt werden. 
+ 
+#proc# 
+TEXT PROC zahltext (TEXT CONST feldname, 
+                    INT CONST kommastellen) 
+#endproc# 
+    Wirkt wie 'zahltext (wert (feldname), kommastellen)'. 
+
diff --git a/app/eudas/4.4/doc/ref-manual/eudas.ref.9 b/app/eudas/4.4/doc/ref-manual/eudas.ref.9
new file mode 100644
index 0000000..85dd337
--- /dev/null
+++ b/app/eudas/4.4/doc/ref-manual/eudas.ref.9
@@ -0,0 +1,184 @@
+#type ("prop")##limit (14.0)# 
+#format# 
+#page (93)# 
+#kapitel ("9", "Anzeige", " ", " ")# 
+ 
+ 
+ 
+#abschnitt ("9.1", "FENSTERVERWALTER", "Fensterverwalter")# 
+ 
+Funktionen, die einen Teil des Bildschirms in einem rechteckigen
+Fenster beschreiben, werden über den Fensterverwalter untereinan­
+der koordiniert. Jede Funktion fordert für ihren Fensterbereich eine
+Variable vom Typ FENSTER an. Vor jedem Bildschirmzugriff kann die
+Funktion erfahren, ob andere Programme den Bildschirm im Fenster­
+bereich überschrieben haben. Gleichzeitig meldet sie damit Verän­
+derungen an anderen Fenstern an, die sich mit dem eigenen über­
+schneiden. 
+ 
+#proc# 
+PROC fenster initialisieren (FENSTER VAR neu) 
+#endproc# 
+    Jede Fenstervariable muß vor Benutzung initialisiert werden. 
+ 
+#proc# 
+PROC fenstergroesse setzen (FENSTER VAR fenster, 
+                            INT CONST x anf, y anf, 
+                                      x laenge, y laenge) 
+#endproc# 
+    Die Fenstergröße des Fensters wird gesetzt. 'x anf' und 'y anf'
+    werden von 1..n gezählt. Die Größe eines 24x80-Bildschirms
+    entspricht den Angaben (1, 1, 79, 24). Da das letzte Zeichen
+    einer Zeile wegen Rollgefahr nicht benutzt werden kann, werden
+    nur 79 Spalten angegeben. 
+#f2# 
+    FEHLER: 
+#f1# 
+    #on("i")#zu viele Fenster#off("i")# 
+    Es sind nur 16 verschiedene Fenstergrößen möglich. 
+ 
+#proc# 
+PROC fenstergroesse (FENSTER CONST fenster, 
+                     INT VAR x anf, y anf, 
+                             x laenge, y laenge) 
+#endproc# 
+    Meldet die eingestellte Größe des Fensters. 
+ 
+#proc# 
+PROC fensterzugriff (FENSTER CONST mein fenster, 
+                     BOOL VAR veraendert) 
+#endproc# 
+    Ein Zugriff auf 'mein fenster' wird angemeldet. 'veraendert' gibt
+    an, ob das Fenster seit dem letzten Zugriff durch einen über­
+    schneidenden Zugriff verändert wurde. Beim ersten Zugriff ist
+    'veraendert' immer TRUE. 
+ 
+#proc# 
+PROC fenster veraendert (FENSTER CONST fenster) 
+#endproc# 
+    Falls ein Unterprogramm eine FENSTER-Variable des Hauptpro­
+    grammes benutzt, kennzeichnet das Unterprogramm das Fenster
+    mit dieser Prozedur als benutzt, damit das Hauptprogramm das
+    Bild neu ausgibt. 
+ 
+#proc# 
+PROC bildschirm neu 
+#endproc# 
+    Gibt an, daß der Bildschirm von einer Funktion benutzt wurde,
+    die ihre Zugriffe nicht über den Fensterverwalter anmeldet.
+    Alle Fenster werden als verändert gekennzeichnet. 
+ 
+ 
+#abschnitt ("9.2", "ANZEIGEGRUNDFUNKTIONEN", "Anzeigegrundfunktionen")# 
+ 
+Sämtliche Anzeigefunktionen werden in einem Fenster abgewickelt,
+dessen Größe durch 'anzeigefenster' bestimmt wird. 
+    Die Funktion 'bildausgeben' übernimmt die eigentliche Ausgabe.
+Dabei kann durch Parameter mitgeteilt werden, ob sich an der Datei
+außer der Markierung etwas geändert hat. Hat sich nichts geändert,
+wird zur Optimierung unter Umständen nur die Markierung neu
+ausgegeben. Das Bild wird jedoch auf jeden Fall ganz ausgegeben,
+wenn das Fenster von anderer Seite verändert wurde. Auch das
+Öffnen einer neuen Datei wird automatisch erkannt und richtig
+behandelt. 
+    Welche Felder dargestellt werden sollen, kann durch 'feldaus­
+wahl' angegeben werden. Dabei ist für jeden Anzeigemodus eine
+eigene Feldauswahl möglich. Die Darstellung kann durch 'rollen' in
+vertikaler Richtung verschoben werden. 
+    Mit 'uebersicht' kann die Übersicht ausgegeben werden. Ihre
+Größe wird durch 'uebersichtsfenster' angegeben. 
+ 
+#proc# 
+PROC anzeigefenster (INT CONST x anf, y anf, 
+                               x laenge, y laenge) 
+#endproc# 
+    Das Anzeigefenster wird in der entsprechenden Größe reser­
+    viert. 
+#f2# 
+    FEHLER: 
+#f1# 
+    #on("i")#Anzeigefenster zu klein#off("i")# 
+    Das Fenster ist zu schmal (< 40 Zeichen), um eine sinnvolle
+    Anzeige zuzulassen. 
+ 
+#proc# 
+PROC bild ausgeben (BOOL CONST datei veraendert) 
+#endproc# 
+    Im Anzeigefenster wird das Bild je nach eingestelltem Modus
+    ausgegeben, wenn das Fenster verändert wurde oder 'satz ver­
+    aendert' TRUE ist. 'satz veraendert' muß immer dann angegeben
+    werden, wenn am Inhalt der virtuellen Datei etwas verändert
+    wurde. 
+ 
+#proc# 
+PROC feldauswahl (TEXT CONST feldcode) 
+#endproc# 
+    Die im aktuellen Modus anzuzeigenden Felder und ihre Reihen­
+    folge werden ausgewählt. Dabei enthält 'feldcodes' an der i-ten
+    Stelle den Code der Feldnummer des Feldes, das an i-ter Posi­
+    tion erscheinen soll. 
+ 
+#proc# 
+PROC rollen (INT CONST anzahl) 
+#endproc# 
+    Die Darstellung wird um die angegebene Anzahl von Zeilen
+    gerollt. Bei einer positiven Angabe wird zu höheren Feld- bzw.
+    Satznummern gerollt (Bild bewegt sich umgekehrt). Beim ersten
+    bzw. letzten Feld bzw. Satz hört das Rollen automatisch auf. 
+ 
+#proc# 
+PROC uebersichtsfenster (INT CONST x anf, y anf, 
+                                   x laenge, y laenge) 
+#endproc# 
+    Legt die Größe des Übersichtsfensters fest. 
+ 
+#proc# 
+PROC uebersicht (TEXT CONST feldauswahl) 
+#endproc# 
+    Ruft eine Übersicht der aktuellen Datei auf, in der geblättert
+    und markiert werden kann. In 'feldauswahl' steht an der Stelle
+    i der Code der Feldnummer, die als i-tes in der Aufzählung
+    erscheinen soll. 
+ 
+ 
+#abschnitt ("9.3", "EDITORFUNKTIONEN", "Editorfunktionen")# 
+ 
+Es stehen drei Funktionen zur Verfügung, die den Editor im Anzei­
+gemodus benutzen. Sie dienen zum Einfügen und Ändern sowie zum
+Eingeben eines Suchmusters. 
+    Der Editor wird durch ESC 'q' verlassen. Weitere ESC-Funk­
+tionen, die zum Verlassen führen sollen, können durch 'exit zeichen'
+angegegeben und nach Funktionsausführung mit 'exit durch' abge­
+fragt werden. 
+ 
+#proc# 
+PROC aendern (PROC hilfe) 
+#endproc# 
+    Bietet den aktuellen Satz zum Ändern an. Steht die virtuelle
+    Datei am Ende, wird automatisch 'einfuegen' durchgeführt. Bei
+    ESC '?' wird 'hilfe' aufgerufen. 
+ 
+#proc# 
+PROC einfuegen (PROC hilfe) 
+#endproc# 
+    Fügt vor dem aktuellen Satz einen Satz ein, dessen Inhalt im
+    Editor angegeben wird. Bei ESC '?' wird 'hilfe' aufgerufen. 
+ 
+#proc# 
+PROC suchen (PROC hilfe) 
+#endproc# 
+    Im Editor wird eine neue Suchbedingung eingegeben. Bei ESC '?'
+    wird 'hilfe' aufgerufen. 
+ 
+#proc# 
+PROC exit durch (TEXT CONST zeichenkette) 
+#endproc# 
+    Gibt die Zeichen an, die beim Drücken nach ESC zum Verlassen
+    des Editors führen sollen. Die eingegebenen Daten werden je­
+    doch vorher auf jeden Fall noch verarbeitet. 
+ 
+#proc# 
+TEXT PROC exit durch 
+#endproc# 
+    Gibt an, durch welches Zeichen der Editor verlassen wurde. 
+
diff --git a/app/eudas/4.4/doc/ref-manual/eudas.ref.fehler b/app/eudas/4.4/doc/ref-manual/eudas.ref.fehler
new file mode 100644
index 0000000..6ce4287
--- /dev/null
+++ b/app/eudas/4.4/doc/ref-manual/eudas.ref.fehler
@@ -0,0 +1,129 @@
+#type ("prop")##limit (14.0)# 
+#format# 
+#page (115)# 
+#kapitel (" ", "Fehlermeldungen", " ", " ")# 
+ 
+ 
+ 
+In diesem Kapitel sind alle Fehlermeldungen aufgeführt, die von
+EUDAS erzeugt werden und zum Abbruch einer Funktion führen
+können. 
+ 
+#on("i")#'n' ist keine Feldnummer#off("i")# 
+  Es wurde eine Nummer als Feldnummer angegeben, die nicht er­
+  laubt ist. 
+ 
+#on("i")#Datei ist keine EUDAS-Datei#off("i")# 
+  Es wurde versucht, eine andere Datei als EUDAS-Datei zu bear­
+  beiten. 
+ 
+#on("i")#inkonsistente EUDAS-Datei#off("i")# 
+  Die interne Struktur der Datei ist zerstört. Kann durch Hardware­
+  probleme (Archiv-Lesefehler) oder EUDAS-interne Fehler ent­
+  standen sein. 
+ 
+#on("i")#EUDAS-Datei voll#off("i")# 
+  Eine EUDAS-Datei kann nur eine bestimmte Anzahl von Sätzen
+  aufnehmen (mindestens 5000). 
+ 
+#on("i")#Nicht erlaubtes Dezimalkomma#off("i")# 
+  Als Dezimalkomma kann nur ein einzelnes Zeichen angegeben
+  werden. 
+ 
+#on("i")#Zuviel Dateien geoeffnet#off("i")# 
+  Es können nicht mehr als 10 Dateien gleichzeitig geöffnet, geket­
+  tet und gekoppelt sein. 
+ 
+#on("i")#Zu viele Felder#off("i")# 
+  Alle geöffneten Dateien zusammen dürfen nicht mehr als 256
+  Felder der virtuellen Datei ergeben. 
+ 
+#on("i")#Zu viele Koppelfelder#off("i")# 
+  Es dürfen insgesamt nicht mehr als 32 Koppelfelder entstehen. 
+ 
+#on("i")#keine Koppelfelder vorhanden#off("i")# 
+  Eine Datei kann nicht gekoppelt werden, wenn Sie kein Koppelfeld
+  besitzt. 
+ 
+#on("i")#keine Datei geoeffnet#off("i")# 
+  Es kann nicht gekettet oder gekoppelt werden, wenn noch keine
+  Datei geöffnet wurde. Ebenfalls sind keine Verarbeitungsproze­
+  duren möglich. 
+ 
+#on("i")#Nicht möglich, wenn auf Koppeldatei geschaltet#off("i")# 
+  Wenn auf eine Koppeldatei umgeschaltet wurde, ist Öffnen, Ketten
+  und Koppeln nicht möglich. 
+ 
+#on("i")#kein direkter Dateizugriff bei geketteten oder gekoppelten Dateien#off("i")# 
+  Wenn Dateien gekettet oder gekoppelt sind, ist Sortieren und
+  Ändern der Feldstruktur nicht möglich. 
+ 
+#on("i")#Datei nicht gesichert#off("i")# 
+  Eine vorher geöffnete Datei ist verändert und nicht gesichert. 
+ 
+#on("i")#Datei wird von anderer Task geändert#off("i")# 
+  Das Öffnen der Datei zum Ändern ist im Moment nicht möglich, da
+  ein anderer Benutzer sie bereits ändert. 
+ 
+#on("i")#Suchmuster zu umfangreich#off("i")# 
+  Ein Suchmuster darf nicht mehr als 100 Vergleiche erfordern. 
+ 
+#on("i")#direkt Drucken nicht moeglich#off("i")# 
+  Entweder ist kein Druckprogramm installiert oder die Spooltask
+  reagiert nicht. 
+ 
+#on("i")#Das Feld "Feldname" ist nicht definiert#off("i")# 
+  Sie haben einen falschen Namen angegeben. 
+ 
+#on("i")#Kein Satz zum Tragen vorhanden#off("i")# 
+  Es wurde versucht, aus einer leeren Datei oder am Dateiende zu
+  tragen. 
+ 
+#on("i")#Zieldatei hat falsche Felderzahl#off("i")# 
+  Eine Zieldatei beim Tragen hat weniger Felder als die aktuelle
+  Datei. Daher würden beim Tragen Informationen verlorengehen. 
+ 
+#on("i")#Zieldatei darf nicht geöffnet sein#off("i")# 
+  Eine geöffnete Datei ist als Zieldatei nicht zulässig. 
+ 
+#on("i")#Das Feld "Feldname" verletzt die Pruefbedingung#off("i")# 
+  Eine Prüfprozedur wurde außerhalb des Tragens aufgerufen und
+  die Bedingung war nicht erfüllt. 
+ 
+#on("i")#Das Feld "Feldname" ist nicht in der Wertemenge#off("i")# 
+  Eine Prüfprozedur wurde außerhalb des Tragens aufgerufen und
+  die Bedingung war nicht erfüllt. 
+ 
+#on("i")#Das Feld "Feldname" stimmt nicht mit der Maske ueberein#off("i")# 
+  Eine Prüfprozedur wurde außerhalb des Tragens aufgerufen und
+  die Bedingung war nicht erfüllt. 
+ 
+#on("i")#Zu viele Fenster#off("i")# 
+  Es sind nicht mehr als 16 verschiedene Größen von Fenstern
+  möglich. 
+ 
+#on("i")#Fenster zu klein#off("i")# 
+  Ein Menü wurde in einem zu kleinen Fenster aufgerufen. 
+ 
+#on("i")#Hilfe existiert nicht#off("i")# 
+  Es wurde versucht, eine nicht vorhandene Hilfestellung aufzu­
+  rufen. 
+ 
+#on("i")#Hilfe ist leer#off("i")# 
+  Die angewählte Hilfestellung enthält keinen Text. 
+ 
+#on("i")#Anzeigefenster zu klein#off("i")# 
+  Das Anzeigefenster muß mindestens 40 Zeichen breit sein. 
+ 
+#on("i")#Ungueltige Satznummer#off("i")# 
+  Der angegebene Text stellt keine Satznummer dar. 
+ 
+#on("i")#kein rekursiver Aufruf#off("i")# 
+  Innerhalb von EUDAS darf 'eudas' nicht erneut aufgerufen wer­
+  den. 
+ 
+#on("i")#Task existiert nicht#off("i")# 
+  Es wurde versucht, eine nicht existente Task als Manager einzu­
+  stellen. 
+ 
+
diff --git a/app/eudas/4.4/doc/ref-manual/eudas.ref.inhalt b/app/eudas/4.4/doc/ref-manual/eudas.ref.inhalt
new file mode 100644
index 0000000..a9ac27f
--- /dev/null
+++ b/app/eudas/4.4/doc/ref-manual/eudas.ref.inhalt
@@ -0,0 +1,137 @@
+#type ("prop")##limit (14.0)# 
+#format# 
+#page(3)# 
+#kapitel (" ", " Inhalt", "", " ")# 
+ 
+ 
+ 
+#type ("12")# 
+      Vorwort  . . . . . . . . . . . . . . . . . . .  i 
+      Inhalt . . . . . . . . . . . . . . . . . . . .  iii 
+ 
+ 
+#type ("prop")# 
+#abschnitt ("I.", "FUNKTIONEN ZUM NACHSCHLAGEN", "Funktionen zum Nachschlagen")# 
+ 
+#type ("prop")# 
+#on("b")#1   Zustände und Bedienung#off("b")# 
+#free (0.2)# 
+#type ("12")# 
+1.1   Zustände . . . . . . . . . . . . . . . . . . .  3 
+1.2   Menüs  . . . . . . . . . . . . . . . . . . . .  8 
+1.3   Auswahl  . . . . . . . . . . . . . . . . . . .  8 
+1.4   Hilfe und Dialog . . . . . . . . . . . . . . .  9 
+1.5   Editor . . . . . . . . . . . . . . . . . . . .  9 
+ 
+#type ("prop")# 
+#on("b")#2   Zusammenstellung der Funktionen#off("b")# 
+#free (0.2)# 
+#type ("12")# 
+2.1   Menü 'Öffnen'  . . . . . . . . . . . . . . . .  13 
+2.2   Menü 'Einzelsatz'  . . . . . . . . . . . . . .  17 
+2.3   Menü 'Gesamtdatei' . . . . . . . . . . . . . .  21 
+2.4   Menü 'Drucken' . . . . . . . . . . . . . . . .  23 
+2.5   Menü 'Dateien' . . . . . . . . . . . . . . . .  25 
+2.6   Menü 'Archiv'  . . . . . . . . . . . . . . . .  27 
+2.7   Kurzabfrage  . . . . . . . . . . . . . . . . .  29 
+ 
+#type ("prop")# 
+#on("b")#3   Das virtuelle Dateimodell#off("b")# 
+#free (0.2)# 
+#type ("12")# 
+3.1   Dateistruktur  . . . . . . . . . . . . . . . .  31 
+3.2   Öffnen . . . . . . . . . . . . . . . . . . . .  32 
+3.3   Koppeln  . . . . . . . . . . . . . . . . . . .  33 
+3.4   Änderungen . . . . . . . . . . . . . . . . . .  34 
+3.5   Sichern  . . . . . . . . . . . . . . . . . . .  36 
+3.6   Umschalten auf Koppeldatei . . . . . . . . . .  36 
+3.7   Mehrbenutzerbetrieb  . . . . . . . . . . . . .  37 
+ 
+#type ("prop")# 
+#on("b")#4   Ansehen und Bearbeiten#off("b")# 
+#free (0.2)# 
+#type ("12")# 
+4.1   Anzeige  . . . . . . . . . . . . . . . . . . .  39 
+4.2   Satzauswahl  . . . . . . . . . . . . . . . . .  42 
+4.3   Sortieren und Reorganisieren . . . . . . . . .  44 
+4.4   Bearbeiten . . . . . . . . . . . . . . . . . .  46 
+ 
+#type ("prop")# 
+#on("b")#5   Drucken und Druckmuster#off("b")# 
+#free (0.2)# 
+#type ("12")# 
+5.1   Druckmustersyntax  . . . . . . . . . . . . . .  49 
+5.2   Der Druckvorgang . . . . . . . . . . . . . . .  51 
+5.3   Interpretation von Musterzeilen  . . . . . . .  52 
+5.4   Anschluß zum ELAN-Compiler . . . . . . . . . .  56 
+5.5   Fehlermeldungen  . . . . . . . . . . . . . . .  57 
+ 
+ 
+#type ("prop")# 
+#abschnitt ("II.", "EUDAS FÜR PROGRAMMIERER", "EUDAS für Programmierer")# 
+ 
+#type ("prop")# 
+#on("b")#6   Struktur von EUDAS-Dateien#off("b")# 
+#free (0.2)# 
+#type ("12")# 
+6.1   Der Datentyp SATZ  . . . . . . . . . . . . . .  61 
+6.2   Der Datentyp EUDAT . . . . . . . . . . . . . .  63 
+6.3   Satzposition . . . . . . . . . . . . . . . . .  64 
+6.4   Satzzugriffe . . . . . . . . . . . . . . . . .  65 
+6.5   Sortieren und Reorganisieren . . . . . . . . .  66 
+6.6   EUDAS-Dateien als Assoziativspeicher . . . . .  68 
+ 
+#type ("prop")# 
+#on("b")#7   Verwaltung der offenen Dateien#off("b")# 
+#free (0.2)# 
+#type ("12")# 
+7.1   Dateiverwaltung  . . . . . . . . . . . . . . .  71 
+7.2   Feldstruktur . . . . . . . . . . . . . . . . .  75 
+7.3   Positionierung . . . . . . . . . . . . . . . .  77 
+7.4   Änderungen . . . . . . . . . . . . . . . . . .  78 
+7.5   Suchbedingungen  . . . . . . . . . . . . . . .  79 
+ 
+#type ("prop")# 
+#on("b")#8   Funktionen zur Bearbeitung#off("b")# 
+#free (0.2)# 
+#type ("12")# 
+8.1   Drucken  . . . . . . . . . . . . . . . . . . .  83 
+8.2   Kopieren . . . . . . . . . . . . . . . . . . .  85 
+8.3   Tragen . . . . . . . . . . . . . . . . . . . .  87 
+8.4   Verarbeitung . . . . . . . . . . . . . . . . .  89 
+8.5   Funktionen in Ausdrücken . . . . . . . . . . .  90 
+ 
+#type ("prop")# 
+#on("b")#9   Anzeige#off("b")# 
+#free (0.2)# 
+#type ("12")# 
+9.1   Fensterverwalter . . . . . . . . . . . . . . .  93 
+9.2   Anzeigegrundfunktionen . . . . . . . . . . . .  94 
+9.3   Editorfunktionen . . . . . . . . . . . . . . .  95 
+ 
+#type ("prop")# 
+#on("b")#10  Programmierung der Menüs#off("b")# 
+#free (0.2)# 
+#type ("12")# 
+10.1  Menüformat . . . . . . . . . . . . . . . . . .  97 
+10.2  Verwaltung der Menüs . . . . . . . . . . . . .  99 
+10.3  Aufruf . . . . . . . . . . . . . . . . . . . .  101 
+10.4  Dialog . . . . . . . . . . . . . . . . . . . .  103 
+ 
+#type ("prop")# 
+#on("b")#11  Programmierung von Anwendungen#off("b")# 
+#free (0.2)# 
+#type ("12")# 
+11.1  Musterprogramme  . . . . . . . . . . . . . . .  105 
+11.2  Dateianwendungen . . . . . . . . . . . . . . .  109 
+11.3  Integrierte Anwendungen  . . . . . . . . . . .  111 
+ 
+ 
+#type ("prop")# 
+#abschnitt ("III.", "ANHANG", "Anhang")# 
+ 
+#type ("12")# 
+      Fehlermeldungen  . . . . . . . . . . . . . . .  115 
+      Prozeduren mit Parametern  . . . . . . . . . .  119 
+      Register . . . . . . . . . . . . . . . . . . .  125 
+
diff --git a/app/eudas/4.4/doc/ref-manual/eudas.ref.macros b/app/eudas/4.4/doc/ref-manual/eudas.ref.macros
new file mode 100644
index 0000000..e86794e
--- /dev/null
+++ b/app/eudas/4.4/doc/ref-manual/eudas.ref.macros
@@ -0,0 +1,70 @@
+#*format# 
+#limit (13.5)##start (3.5,2.5)##pagelength (21.0)##block# 
+#:firsthead (false)# 
+#linefeed (1.07)# 
+#*macro end# 
+#*text# 
+#type ("prop10")# 
+#linefeed (1.07)# 
+#*macro end# 
+#*beispiel# 
+#type ("12")# 
+#linefeed (0.97)# 
+#*macro end# 
+#*bildschirm# 
+#type ("15")# 
+#linefeed(0.83)# 
+#*macro end# 
+#*proc# 
+#type ("12")# 
+#*macro end# 
+#*endproc# 
+#free (0.1)# 
+#type ("prop10")# 
+#linefeed (1.07)# 
+#*macro end# 
+#*abschnitt ($1,$2,$3)# 
+#headodd# 
+#on("b")#$1#right#$3    %#off("b")# 
+#free (1.0)# 
+#end# 
+#on("b")##ib(9)#$1#ie(9,"   $3")# $2#off("b")# 
+#*macro end# 
+#*char($1)# 
+$1
+#*macro end# 
+#*kapitel ($1,$2,$3,$4)# 
+#free (1.3)# 
+#"nlq"# 
+#type("roman.24")# 
+#on("b")##center#$1#off("b")# 
+#free (0.2)# 
+#type ("roman.18")# 
+#on("b")##center#$2 #off("b")# 
+#on("b")##center# $3#off("b")# 
+#on("b")##center#$4#off("b")# 
+#type ("prop10")# 
+#free (0.6)# 
+#headeven# 
+#on("b")#%    $2 $3 $4#off("b")# 
+#free (1.0)# 
+#end# 
+#headodd# 
+#right##on("b")#%#off("b")# 
+#free (1.0)# 
+#end# 
+#*macro end# 
+#*f2# 
+#free (0.2)# 
+#*macro end# 
+#*a ($1)# 
+#on("b")#$1.#off("b")# 
+#*macro end# 
+#*bsp ($1)# 
+#type("12")#$1#type("prop")#
+#*macro end# 
+#*f1# 
+#free (0.1)# 
+#*macro end# 
+
+
diff --git a/app/eudas/4.4/doc/ref-manual/eudas.ref.proz b/app/eudas/4.4/doc/ref-manual/eudas.ref.proz
new file mode 100644
index 0000000..7ec9b50
--- /dev/null
+++ b/app/eudas/4.4/doc/ref-manual/eudas.ref.proz
@@ -0,0 +1,195 @@
+#type ("prop")##limit (14.0)# 
+#format# 
+#page (119)# 
+#kapitel (" ", "Prozeduren", "mit", "Parametern")# 
+ 
+ 
+ 
+#beispiel# 
+:= (SATZ VAR, SATZ CONST)                                   6.1 
+ 
+aendern (PROC hilfe)                                        9.3 
+aendern erlaubt : BOOL                                      7.1 
+aenderungen eintragen                                       7.4 
+anzahl dateien : INT                                        7.1 
+anzahl felder : INT                                         7.2 
+anzahl koppeldateien : INT                                  7.1 
+anzeigefenster (INT CONST x anf, y anf, 
+                          x laenge, y laenge)               9.2 
+auf satz (EUDAT VAR, INT CONST satznr)                      6.3 
+auf satz (EUDAT VAR, TEXT CONST muster)                     6.3 
+auf satz (INT CONST satznr)                                 7.3 
+ausfuehrtaste (TEXT CONST taste)                           10.3 
+auswahl anbieten (TEXT CONST name, FENSTER CONST f, 
+                  TEXT CONST hilfe, 
+                  PROC (TEXT VAR, INT CONST) inhalt)       10.3 
+ 
+bild ausgeben (BOOL CONST datei veraendert)                 9.2 
+bildschirm neu                                              9.1 
+ 
+dateiende (EUDAT CONST) : BOOL                              6.3 
+dateiende : BOOL                                            7.3 
+dateien loeschen (BOOL CONST auch geaenderte)               7.1 
+dateiversion : INT                                          7.1 
+dezimalkomma (TEXT CONST komma)                             6.5 
+dezimalkomma : TEXT                                         6.5 
+dialog                                                     10.4 
+dialogfenster (INT CONST x anf, y anf, 
+                         x laenge, y laenge)               10.4 
+direkt drucken (BOOL CONST ja)                              8.1 
+druckdatei (TEXT CONST dateiname)                           8.1 
+drucke (TEXT CONST mustername)                              8.1 
+ 
+editget (TEXT CONST prompt, TEXT VAR eingabe, 
+         TEXT CONST res, hilfe)                            10.4 
+eindeutige felder (INT CONST anzahl)                        8.3 
+einfuegen (PROC hilfe)                                      9.3 
+eudas dateiname (INT CONST dateinr) : TEXT                  7.1 
+EUDAT                                                       6.2 
+exit durch (TEXT CONST exit zeichen)                        9.3 
+exit durch : TEXT                                           9.3 
+ 
+f (TEXT CONST feldname) : TEXT                              8.5 
+fehler ausgeben                                            10.4 
+feld aendern (SATZ VAR, INT CONST feldnr, 
+              TEXT CONST inhalt)                            6.1 
+feld aendern (EUDAT VAR, INT CONST feldnr, 
+              TEXT CONST inhalt)                            6.4 
+feld aendern (INT CONST feldnr, TEXT CONST inhalt)          7.2 
+feldauswahl (TEXT CONST feldcodes)                          9.2 
+feld bearbeiten (SATZ CONST, INT CONST feldnr, 
+  PROC (TEXT CONST, INT CONST, INT CONST) bearbeite)        6.1 
+feld bearbeiten (EUDAT CONST, INT CONST feldnr, 
+  PROC (TEXT CONST, INT CONST, INT CONST) bearbeite)        6.4 
+feld bearbeiten (INT CONST feldnr, 
+  PROC (TEXT CONST, INT CONST, INT CONST) bearbeite)        7.2 
+felderzahl (SATZ CONST) : INT                               6.1 
+felderzahl (EUDAT CONST) : INT                              6.2 
+feldindex (SATZ CONST, TEXT CONST muster) : INT             6.1 
+feldinfo (EUDAT VAR, INT CONST feldnr, info)                6.5 
+feldinfo (EUDAT CONST, INT CONST feldnr) : INT              6.5 
+feld lesen (SATZ CONST, INT CONST feldnr, 
+            TEXT VAR inhalt)                                6.1 
+feld lesen (EUDAT CONST, INT CONST feldnr, 
+            TEXT VAR inhalt)                                6.4 
+feld lesen (INT CONST feldnr, TEXT VAR inhalt)              7.2 
+feldmaske (TEXT CONST feldname, maske)                      8.3 
+feldnamen aendern (EUDAT VAR, SATZ CONST namen)             6.2 
+feldnamen bearbeiten (INT CONST feldnr, 
+  PROC (TEXT CONST, INT CONST, INT CONST) bearbeite)        7.2 
+feldnamen lesen (EUDAT CONST, SATZ VAR namen)               6.2 
+feldnamen lesen (INT CONST feldnr, TEXT VAR name)           7.2 
+feldnummer (TEXT CONST feldname) : INT                      7.2 
+FENSTER                                                     9.1 
+fenstergroesse (FENSTER CONST f, 
+                INT VAR x anf, y anf, 
+                        x laenge, y laenge)                 9.1 
+fenstergroesse setzen (FENSTER VAR fenster, 
+                       INT CONST x anf, y anf, 
+                                 x laenge, y laenge)        9.1 
+fenster initialisieren (FENSTER VAR fenster)                9.1 
+fenster veraendert (FENSTER CONST fenster)                  9.1 
+fensterzugriff (FENSTER CONST fenster, 
+                BOOL VAR veraendert)                        9.1 
+ 
+global manager                                             10.2 
+gruppenwechsel (INT CONST gruppennr) : BOOL                 8.1 
+ 
+hilfe anbieten (TEXT CONST name, FENSTER CONST f)          10.3 
+hole satz (TEXT CONST dateiname)                            8.3 
+ 
+inhalt veraendert (INT CONST dateinr) : BOOL                7.1 
+ja (TEXT CONST frage, hilfe) : BOOL                        10.4 
+ 
+K (TEXT CONST feldname, ausdruck)                           8.2 
+kette (TEXT CONST dateiname)                                7.1 
+kopiere (TEXT CONST dateiname, FILE VAR muster)             8.2 
+kopiere (TEXT CONST dateiname, PROC kopierfunktion)         8.2 
+kopple (TEXT CONST dateiname)                               7.1 
+ 
+lfd nr : TEXT                                               8.1 
+ 
+markierte saetze : INT                                      7.5 
+markierung aendern                                          7.5 
+markierungen loeschen                                       7.5 
+maxdruckzeilen (INT CONST anzahl zeilen)                    8.1 
+menue anbieten (ROW 6 TEXT CONST menuenamen, 
+                FENSTER VAR f, 
+                BOOL CONST esc erlaubt, 
+                PROC (INT CONST, INT CONST) interpreter)   10.3 
+menuedaten einlesen (TEXT CONST dateiname)                 10.2 
+menue loeschen (TEXT CONST name, INT CONST index)          10.2 
+menue loeschen (BOOL CONST hilfen reduzieren)              10.2 
+menue manager (DATASPACE VAR ds, 
+               INT CONST order, phase, 
+               TASK CONST order task)                      10.2 
+menuenamen (INT CONST index) : THESAURUS                   10.2 
+ 
+neuer dialog                                               10.4 
+notizen aendern (EUDAT VAR, INT CONST notiz nr, 
+                 TEXT CONST notizen)                        6.2 
+notizen lesen (EUDAT CONST, INT CONST notiz nr, 
+               TEXT VAR notizen)                            6.2 
+ 
+oeffne (EUDAT VAR, TEXT CONST dateiname)                    6.2 
+oeffne (TEXT CONST dateiname, 
+        BOOL CONST aendern erlaubt)                         7.1 
+ 
+pruefe (TEXT CONST feldname, BOOL CONST bedingung)          8.3 
+ 
+reorganisiere (TEXT CONST dateiname)                        6.5 
+rollen (INT CONST anzahl)                                   9.2 
+ 
+saetze (EUDAT CONST) : INT                                  6.3 
+SATZ                                                        6.1 
+satz aendern (EUDAT VAR, SATZ CONST neuer satz)             6.4 
+satz ausgewaehlt : BOOL                                     7.5 
+satz einfuegen (EUDAT VAR, SATZ CONST satz)                 6.4 
+satz einfuegen                                              7.4 
+satz initialisieren (SATZ VAR satz)                         6.1 
+satzkombination : INT                                       7.3 
+satz lesen (EUDAT CONST, SATZ VAR satz)                     6.4 
+satz loeschen (EUDAT VAR)                                   6.4 
+satz loeschen                                               7.4 
+satz markiert : BOOL                                        7.5 
+satznr (EUDAT CONST) : INT                                  6.3 
+satznummer : INT                                            7.3 
+sichere (INT CONST dateinr, TEXT CONST dateiname)           7.1 
+sortiere (EUDAT VAR, TEXT CONST reihenfolge)                6.5 
+sortiere (EUDAT VAR)                                        6.5 
+sortierreihenfolge (EUDAT CONST) : TEXT                     6.5 
+status anzeigen (TEXT CONST zeile)                         10.3 
+std kopiermuster (TEXT CONST dateiname, FILE VAR f)         8.2 
+suchbedingung (INT CONST feldnr, 
+               TEXT CONST bedingung)                        7.5 
+suchbedingung loeschen                                      7.5 
+suchen (PROC hilfe)                                         9.3 
+ 
+textdarstellung (TEXT CONST text) : TEXT                    8.5 
+trage (TEXT CONST dateiname, FILE VAR protokoll, 
+       BOOL CONST test)                                     8.3 
+trage satz (TEXT CONST dateiname)                           8.3 
+ 
+unsortierte saetze (EUDAT CONST) : INT                      6.5 
+ 
+V (TEXT CONST feldname, ausdruck)                           8.4 
+verarbeite (FILE VAR verarbeitungsmuster)                   8.4 
+verarbeite (PROC verarbeitungsfunktion)                     8.4 
+ 
+waehlbar (INT CONST menuenr, funktionsnr, 
+          BOOL CONST moeglich)                             10.3 
+wahl (INT CONST stelle) : INT                              10.3 
+weiter (EUDAT VAR)                                          6.3 
+weiter (EUDAT VAR, TEXT CONST muster)                       6.3 
+weiter (INT CONST modus)                                    7.3 
+wert (TEXT CONST feldname) : REAL                           8.5 
+wert (TEXT CONST feldname, INT CONST kommastellen) : REAL   8.5 
+wertemenge (TEXT CONST feldname, menge)                     8.3 
+ 
+zahltext (REAL CONST wert, INT CONST kommastellen) : TEXT   8.5 
+zahltext (TEXT CONST feldname, 
+          INT CONST kommastellen) : TEXT                    8.5 
+zurueck (EUDAT VAR)                                         6.3 
+zurueck (EUDAT VAR, TEXT CONST muster)                      6.3 
+zurueck (INT CONST modus)                                   7.3 
+
diff --git a/app/eudas/4.4/doc/ref-manual/eudas.ref.reg b/app/eudas/4.4/doc/ref-manual/eudas.ref.reg
new file mode 100644
index 0000000..61ebef9
--- /dev/null
+++ b/app/eudas/4.4/doc/ref-manual/eudas.ref.reg
@@ -0,0 +1,426 @@
+#type ("prop")##limit (6.5)# 
+#format# 
+#page (125)# 
+#kapitel (" ", "Register ", "", " ")# 
+ 
+ 
+ 
+#columns (2, 0.5)# 
+#limit (6.5)# 
+ABKUERZUNGEN-Anweisung 49 
+Abkürzungsteil 49 
+Abkürzungsverzeichnis 68 
+Abkürzungszeile 50 
+Abschlußzeile 39 
+aendern 96 
+Ändern 10, 19 
+  -, nach Vorschrift 48 
+aendern erlaubt 74 
+Änderungen 34 
+aenderungen eintragen 79 
+Änderungsmuster 21 
+Alternative 43 
+Ankreuzen 8 
+anzahl dateien 74 
+anzahl felder 75 
+anzahl koppeldateien 74 
+Anzeige 39, 93 
+anzeigefenster 95 
+Arbeitskopie 13, 32 
+  -, löschen 15, 36 
+  -, sichern 15, 36 
+Archivmanager 28 
+  -, reservieren 29 
+Archiv (Menü) 27 
+Archivübersicht drucken 27 
+Assoziativspeicher 68 
+auf koppeldatei 74 
+Aufräumen 26 
+auf satz 65, 78 
+Auf Satz Nr. 17 
+Ausdrucken 24 
+Ausführen 8 
+ausfuehrtaste 8, 102 
+AUSWAHL 97 
+AUSWAHL: 4 
+Auswahl 8 
+  -, Format 98 
+auswahl anbieten 103 
+ 
+Bearbeiten 46 
+BILD 97 
+bild ausgeben 95 
+bildschirm neu 94 
+ 
+Datei, aufräumen 26 
+  -, kopieren (logisch) 25 
+  -, kopieren vom Archiv 27 
+  -, löschen 25 
+  -, löschen auf Archiv 28 
+  -, Platzbedarf 26 
+  -, reorganisieren 26 
+  -, schreiben auf Archiv 27 
+  -, umbenennen 25 
+  -, virtuelle 32, 71 
+Dateianwendungen 109 
+Dateien Archiv, Übersicht 27 
+dateiende 64, 78 
+dateien loeschen 74 
+Dateien (Menü) 25 
+Dateien System, Übersicht 25 
+Dateilimit 52 
+Dateimanager 28 
+Dateiname 40 
+dateiversion 75 
+DATUM 45 
+Dezimalkomma 45 
+dezimalkomma 67 
+dialog 104 
+Dialog 9, 103 
+dialogfenster 104 
+DIN 45 
+direkt drucken 83f. 
+Druckausgabe, Richtung 23 
+druckdatei 85 
+drucke 84 
+Drucken 23, 49, 83 
+  -, Archivübersicht 27 
+Drucken (Menü) 23 
+Druckmuster 23, 49, 83 
+  -, Fehler 56 
+Druckvorgang 51 
+ 
+editget 104 
+EDITIEREN: 6 
+Editieren 23 
+  -, Zeile 9 
+Editor 9, 29 
+eindeutige felder 47, 89 
+einfuegen 96 
+Einfügen 10, 19 
+  -, Satz 36 
+  -, Zeile 10 
+EINGABE: 4 
+Eingabe 9 
+Einzelsatz (Menü) 17 
+ELAN-Compiler 56 
+ELAN-Kommandos 8 
+ENDE 97 
+Endekennzeichnung 40 
+ESC '?' 6 
+ESC '9' 4 
+ESC '1' 4 
+ESC '?' 4 
+ESC '?' 3 
+ESC 'D' 5 
+ESC ESC 3 
+ESC 'F' 5f. 
+ESC 'g' 5 
+ESC 'h' 4ff. 
+ESC 'K' 36 
+ESC OBEN 5 
+ESC 'p' 5 
+ESC 'q' 4, 6 
+ESC RUBIN 5 
+ESC RUBOUT 5 
+ESC UNTEN 5 
+ESC 'w' 4f. 
+ESC 'z' 4f. 
+eudas 29 
+EUDAS: 3 
+EUDAS-Datei, aufspalten 110 
+  -, drucken 23, 49, 83 
+  -, einrichten 13 
+  -, ketten 14, 32 
+  -, kopieren 21, 46, 85 
+  -, koppeln 14, 32 
+  -, nach Vorschrift ändern 48 
+  -, öffnen 13, 32 
+  -, reorganisieren 67 
+  -, sortieren 22 
+  -, Struktur 31, 61 
+  -, tragen 46, 87 
+  -, Übersicht 22 
+  -, verändern 21 
+eudas dateiname 75 
+EUDAT 61, 63, 109 
+EUMEL-Netz 28 
+exit durch 96 
+ 
+f 91 
+FEHLER 5 
+fehler ausgeben 104 
+Feld 31 
+FELD 98 
+feld aendern 62, 65, 76 
+Feldauswahl 20, 41, 95 
+feld bearbeiten 62, 65, 76 
+felderzahl 62, 63 
+feldindex 62 
+feldinfo 66, 77 
+Feldinhalt 31, 39 
+feld lesen 65, 76 
+feldmaske 47, 89 
+Feldmuster 53 
+Feldname 31, 39 
+  -, ändern 16 
+  -, anfügen 16 
+feldnamen aendern 63 
+feldnamen bearbeiten 76 
+feldnamen lesen 64, 76 
+feldnummer 76 
+Feldstruktur 15 
+Feldtyp 31, 42 
+Feldtypen 45, 66 
+  -, ändern 16 
+Feldvergleich 43 
+Fenster 93 
+fenstergroesse 94 
+fenstergroesse setzen 93 
+fenster initialisieren 93 
+fenster veraendert 94 
+fensterzugriff 94 
+folgedatei 75 
+Folgezeilen 41 
+Formular 39 
+FRAGE: 5 
+Fragen 9 
+Funktion, ausführen 8 
+  -, gesperrte 8 
+ 
+Gesamtdatei (Menü) 21 
+Gib Kommando: 6 
+global manager 36, 100 
+Gruppe 51 
+GRUPPE-Anweisung 49 
+gruppenwechsel 51, 85 
+ 
+Hauptdatei 32 
+HILFE: 4 
+HILFE 97, 99 
+Hilfe 9 
+  -, Format 98 
+hilfe anbieten 103 
+Holen 19 
+hole satz 89 
+HOP LINKS 4 
+HOP 'o' 4 
+HOP OBEN 3ff. 
+HOP RECHTS 4 
+HOP RETURN 4 
+HOP RUBOUT 4 
+HOP UNTEN 3ff. 
+HOP 'x' 4 
+ 
+inhalt veraendert 74 
+Initialisieren 28 
+Initialisierungsteil 49 
+ 
+ja 104 
+ 
+K 46, 86 
+kette 73 
+Ketten 14, 32 
+Klassenwechsel 106 
+Kombinationen 34 
+Kommandos 8 
+Kommandozeile 50 
+kopiere 86 
+Kopieren 21, 46, 85 
+Kopieren (logisch) 25 
+Kopieren vom Archiv 27 
+Kopiermuster 21, 46 
+KOPPEL 40 
+Koppeldatei, umschalten auf 36 
+Koppelfelder 33 
+Koppeln 14, 32f. 
+kopple 72 
+Kurzabfrage 29 
+ 
+LEER 3f. 
+Leertaste 8 
+lfd nr 85 
+lineform 24 
+LINKS 3f. 
+Literaturangaben 108 
+Löschen 25 
+  -, Satz 36 
+  -, Zeile 10 
+Löschen auf Archiv 28 
+ 
+Manager 13 
+Manager (Mehrbenutzer) 16, 36 
+markierte saetze 81 
+Markierung 18, 40, 42 
+markierung aendern 81 
+Markierungen löschen 22 
+markierungen loeschen 81 
+maxdruckzeilen 85 
+MEHR-Anweisung 50 
+MENUE 97 
+Menü 8 
+  -, Aufruf 101 
+  -, Verwaltung 99 
+menue anbieten 101 
+menuedaten einlesen 99 
+Menüformat 97 
+menue loeschen 100 
+menue manager 100 
+menuenamen 100 
+Modi 55 
+MODUS-Anweisung 50 
+Musterprogramme 105 
+Musterteil 50 
+Musterzeichen 53 
+Musterzeile 50 
+  -, Interpretation 52 
+ 
+Nachbearbeiten 24 
+Nachspann 49 
+NACHSPANN-Anweisung 49 
+Namenskonflikte 33 
+neuer dialog 104 
+Normalmodus 55 
+Notizen 15, 31, 64 
+notizen aendern 64, 77 
+notizen lesen 64, 77 
+ 
+'o' 4 
+OBEN 3f. 
+ODER-Verknüpfung 43 
+oeffne 63, 72 
+Öffnen 32 
+Öffnen (Menü) 13 
+ 
+pageform 24 
+Paralleleditor 56, 83 
+Paßwort 29 
+Platzbedarf 26 
+Positionieren 17, 31, 64, 77 
+Priorität 44 
+Programmzeile 51 
+Protokolldatei 47 
+Prüfbedingungen 16, 31, 47, 64,
+   87 
+pruefe 47, 88 
+Pufferplatz 54 
+ 
+RECHTS 3f. 
+Refinement 56 
+reorganisiere 67 
+Reorganisieren 26, 45, 67 
+Reservieren 29 
+RETURN 4 
+Richtung Druckausgabe 23 
+rollen 95 
+Rollen 41 
+RUBIN 4 
+RUBOUT 4 
+ 
+saetze 64 
+SATZ 61 
+Satz 31 
+satz aendern 66 
+satz ausgewaehlt 80 
+Satzauswahl 42 
+Satzeditor 9 
+satz einfuegen 66, 79 
+Satzformular 39 
+satz initialisieren 62 
+satzkombination 77 
+satz lesen 66 
+satz loeschen 66, 79 
+satz markiert 81 
+satznr 64 
+satznummer 77 
+Satznummer 39 
+Satzposition 64 
+Satzzeiger 31 
+Satzzugriffe 65 
+Schreiben auf Archiv 27 
+SEITE 99 
+sichere 73 
+Sichern 15, 36 
+sortiere 67 
+Sortieren 22, 31, 44, 66 
+Sortierreihenfolge 31, 44 
+sortierreihenfolge 67 
+Sortierzustand 45 
+Spaltendruck 52 
+Sperre 36 
+Standard-Kopiermuster 21, 46 
+status anzeigen 103 
+Statuszeile 3 
+std kopiermuster 87 
+Suchbedingung 17, 39, 42 
+  -, löschen 18 
+  -, setzen 18 
+suchbedingung 80 
+suchbedingung lesen 80 
+suchbedingung loeschen 80 
+suchen 96 
+Suchen, Optimierung 44 
+Suchmuster 42 
+  -, eingeben 10 
+ 
+Tabellenmodus 55 
+Tasten 3 
+Tastenfunktionen 3 
+TEXT 45 
+textdarstellung 91 
+Textdatei, ausdrucken 24 
+  -, editieren 23 
+  -, nachbearbeiten 24 
+Textzeile 49f. 
+trage 88 
+Tragen 16, 19, 21, 46, 87 
+trage satz 88 
+ 
+uebersicht 95 
+uebersichtsfenster 95 
+Umbenennen 25 
+Umbruch 40, 55 
+Umschalten auf Koppeldatei 36 
+UND-Verknüpfung 43 
+unsortierte saetze 67 
+UNTEN 3f. 
+Überschrift 39 
+Übersicht 22, 41 
+Übersicht Dateien Archiv 27 
+Übersicht Dateien System 25 
+ 
+V 48, 90 
+Verändern 21 
+verarbeite 90 
+Verarbeitung 89 
+Verknüpfung von Bedingungen
+43 
+virtuelle Datei 32, 71 
+VORSPANN 98 
+Vorspann 49 
+VORSPANN-Anweisung 49 
+ 
+waehlbar 102 
+wahl 103 
+Warten 6 
+weiter 65, 78 
+Weiter 17 
+wert 91 
+wertemenge 47, 88 
+WIEDERHOLUNG-Anweisung 49 
+Wiederholungsteil 49 
+ 
+'x' 4 
+ 
+ZAHL 45 
+zahltext 91 
+Zeichen, reservierte 44 
+ZEIGEN: 6 
+Zeilenende 54 
+Zeilenwiederholung 55 
+Zielarchiv 28 
+Zurück 17 
+zurueck 65, 78 
+Zustand 3 
+Zustandsübergänge 7 
+
diff --git a/app/eudas/4.4/doc/ref-manual/eudas.ref.titel b/app/eudas/4.4/doc/ref-manual/eudas.ref.titel
new file mode 100644
index 0000000..289de34
--- /dev/null
+++ b/app/eudas/4.4/doc/ref-manual/eudas.ref.titel
@@ -0,0 +1,68 @@
+#type ("prop")##limit (14.0)# 
+#format# 
+#free (6.0)# 
+#type ("roman.18")# 
+#on("b")#EUDAS#off("b")# 
+#free (1.0)# 
+#type ("roman.14")# 
+#on("b")#Anwender-#off("b")# 
+#on("b")#Datenverwaltungssystem#off("b")# 
+#free (2.0)# 
+#type ("10")# 
+#on ("b")#VERSION 4#off("b")# 
+#free(1.0)# 
+#on("u")#                                                    #off("u")# 
+#free (0.5)# 
+#on("b")#REFERENZHANDBUCH#off("b")# 
+#type ("prop")##block# 
+#page# 
+#free (9.5)# 
+Hergestellt mit Hilfe der EUMEL-Textverarbeitung und des Pro­
+gramms FontMaster der Martin Schönbeck GmbH. 
+#free (1.7)# 
+Ausgabe September 1987 
+ 
+Dieses Handbuch und das zugehörige Programm sind urheberrechtlich
+geschützt. Die dadurch begründeten Rechte, insbesondere der Ver­
+vielfältigung in irgendeiner Form, bleiben dem Autor vorbehalten. 
+ 
+Es kann keine Garantie dafür übernommen werden, daß das Pro­
+gramm für eine bestimmte Anwendung geeignet ist. Die Verantwor­
+tung dafür liegt beim Kunden. 
+ 
+Das Handbuch wurde mit größter Sorgfalt erstellt. Für die Korrekt­
+heit und Vollständigkeit der Angaben wird aber keine Gewähr über­
+nommen. Das Handbuch kann jederzeit ohne Ankündigung geändert
+werden. 
+ 
+(c) Copyright 1987  Thomas Berlage 
+                    Software-Systeme 
+                    Im alten Keller 3 
+#free (0.1)# 
+                    D-5205 Sankt Augustin 1 
+#page# 
+#type ("roman.24")# 
+#free (7.0)# 
+#center##on("b")#I.#off("b")# 
+#free (1.0)# 
+#type ("roman.18")# 
+#center##on("b")#FUNKTIONEN#off("b")# 
+#center##on("b")#ZUM#off ("b")# 
+#center##on("b")#NACHSCHLAGEN#off("b")# 
+#page# 
+#type ("roman.24")# 
+#free (7.0)# 
+#center##on("b")#II.#off("b")# 
+#free (1.0)# 
+#type ("roman.18")# 
+#center##on("b")#EUDAS#off("b")# 
+#center##on("b")#FÜR#off ("b")# 
+#center##on("b")#PROGRAMMIERER#off("b")# 
+#page# 
+#free (7.0)# 
+#type ("roman.24")# 
+#center##on("b")#III.#off("b")# 
+#free (1.0)# 
+#type ("roman.18")# 
+#center##on("b")#ANHANG#off("b")# 
+
diff --git a/app/eudas/4.4/doc/ref-manual/eudas.ref.vorwort b/app/eudas/4.4/doc/ref-manual/eudas.ref.vorwort
new file mode 100644
index 0000000..f3880f4
--- /dev/null
+++ b/app/eudas/4.4/doc/ref-manual/eudas.ref.vorwort
@@ -0,0 +1,29 @@
+#type ("prop")##limit (14.0)# 
+#format# 
+#page (1)# 
+#kapitel (" ", "Vorwort", " ", " ")# 
+ 
+ 
+ 
+Lieber EUDAS-Benutzer! 
+ 
+Dies ist das zweite Handbuch, das Sie zu EUDAS bekommen. Wenn
+Sie sich mit EUDAS noch nicht auskennen, sollten Sie zunächst das
+#on("i")#Benutzerhandbuch#off("i")# zu Rate ziehen, ehe Sie in dieses Handbuch
+schauen. 
+ 
+    Das #on("i")#Referenzhandbuch#off("i")# ist in zwei Teile geteilt. Im ersten Teil
+finden Sie eine Übersicht über alle EUDAS-Funktionen (im Kapitel
+2) sowie zusammengefaßte Informationen über die Bedienung (Kapi­
+tel 1) und die genaue Wirkung der einzelnen Funktionen (Kapitel 3
+bis 5). Dieser Teil soll Ihnen zum Nachschlagen dienen, wenn Sie
+eine bestimmte Information suchen. 
+    Im zweiten Teil sind alle Informationen zusammengefaßt, die
+ein Programmierer zur Benutzung der EUDAS-Funktionen braucht. Es
+sei an dieser Stelle jedoch davon abgeraten, sofort eigene Program­
+me zu schreiben, da sich in vielen Fällen die gleiche Wirkung auch
+durch Programmierung innerhalb von EUDAS-Funktionen erreichen
+läßt (zum Beispiel in Druck- und Änderungsmustern). 
+    Im Zweifelsfall orientieren Sie sich anhand von Kapitel 11, wie
+Sie Ihr Problem am besten lösen können. 
+
diff --git a/app/eudas/4.4/doc/ref-manual/ref.abb.1-1 b/app/eudas/4.4/doc/ref-manual/ref.abb.1-1
new file mode 100644
index 0000000..bc70722
--- /dev/null
+++ b/app/eudas/4.4/doc/ref-manual/ref.abb.1-1
@@ -0,0 +1,58 @@
+#type ("prop")##limit (13.5)# 
+#start (3.5, 5.0)# 
+#lpos (0.5)##c pos (3.5)##c pos (4.7)##cpos (7.0)##c pos (10.5)# 
+#table# 
+         eudas   ESC q    
+ 
+      ESC ESC     ESC h 
+#free (0.2)# 
+#type ("roman.12")# 
+GIB KDO:        EUDAS    
+#type ("prop")# 
+#free (0.2)# 
+      ESC h       
+    RET           LEER  'Buchst.'    
+ 
+            ESC q           
+ 
+#type ("roman.12")# 
+            FEHLER 
+ 
+ 
+   WARTEN          
+#type ("prop")# 
+         n, j    
+#type ("roman.12")# 
+            FRAGE 
+#type ("prop")# 
+ 
+         RET    
+#type ("roman.12")# 
+            EINGABE 
+#type ("prop")# 
+#linefeed (0.5)# 
+ 
+ 
+            ESC z           
+         ESC q    
+#linefeed (1.0)# 
+#type ("roman.12")# 
+            AUSWAHL 
+#type ("prop")# 
+ 
+         ESC q    
+#type ("roman.12")# 
+            EDITIEREN 
+#type ("prop")# 
+ 
+         ESC q    
+#type ("roman.12")# 
+            SATZEDITOR 
+#type ("prop")# 
+ESC ?   ESC q             
+         ESC q    
+#type ("roman.12")# 
+HILFE           ZEIGEN 
+#type ("prop")# 
+ 
+