summaryrefslogtreecommitdiff
path: root/app/eudas/4.4/doc/ref-manual
diff options
context:
space:
mode:
Diffstat (limited to 'app/eudas/4.4/doc/ref-manual')
-rw-r--r--app/eudas/4.4/doc/ref-manual/abb.1-171
-rw-r--r--app/eudas/4.4/doc/ref-manual/abb.4-143
-rw-r--r--app/eudas/4.4/doc/ref-manual/abb.4-246
-rw-r--r--app/eudas/4.4/doc/ref-manual/abb.6-175
-rw-r--r--app/eudas/4.4/doc/ref-manual/abb.6-277
-rw-r--r--app/eudas/4.4/doc/ref-manual/abb.7-146
-rw-r--r--app/eudas/4.4/doc/ref-manual/abb.9-141
-rw-r--r--app/eudas/4.4/doc/ref-manual/abb.9-296
-rw-r--r--app/eudas/4.4/doc/ref-manual/abb.9-3113
-rw-r--r--app/eudas/4.4/doc/ref-manual/abb.9-498
-rw-r--r--app/eudas/4.4/doc/ref-manual/abb.9-551
-rw-r--r--app/eudas/4.4/doc/ref-manual/bildergenerator25
-rw-r--r--app/eudas/4.4/doc/ref-manual/eudas.ref.1323
-rw-r--r--app/eudas/4.4/doc/ref-manual/eudas.ref.10394
-rw-r--r--app/eudas/4.4/doc/ref-manual/eudas.ref.11327
-rw-r--r--app/eudas/4.4/doc/ref-manual/eudas.ref.2820
-rw-r--r--app/eudas/4.4/doc/ref-manual/eudas.ref.3256
-rw-r--r--app/eudas/4.4/doc/ref-manual/eudas.ref.4421
-rw-r--r--app/eudas/4.4/doc/ref-manual/eudas.ref.5415
-rw-r--r--app/eudas/4.4/doc/ref-manual/eudas.ref.6466
-rw-r--r--app/eudas/4.4/doc/ref-manual/eudas.ref.7519
-rw-r--r--app/eudas/4.4/doc/ref-manual/eudas.ref.8444
-rw-r--r--app/eudas/4.4/doc/ref-manual/eudas.ref.9184
-rw-r--r--app/eudas/4.4/doc/ref-manual/eudas.ref.fehler129
-rw-r--r--app/eudas/4.4/doc/ref-manual/eudas.ref.inhalt137
-rw-r--r--app/eudas/4.4/doc/ref-manual/eudas.ref.macros70
-rw-r--r--app/eudas/4.4/doc/ref-manual/eudas.ref.proz195
-rw-r--r--app/eudas/4.4/doc/ref-manual/eudas.ref.reg426
-rw-r--r--app/eudas/4.4/doc/ref-manual/eudas.ref.titel68
-rw-r--r--app/eudas/4.4/doc/ref-manual/eudas.ref.vorwort29
-rw-r--r--app/eudas/4.4/doc/ref-manual/ref.abb.1-158
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")#
+
+