2. FEHLERMELDUNGEN

Für die Ausgabe von Fehlermeldungen exisiert die Prozedur fmeld(). Sie setzt die globale Variable fehler auf 1 und gibt die Meldung aus.

Beispiel:

void lesen_von_datei()
{ datei=fopen("xyz","r");
  if (!datei) fmeld("Fehler beim Dateizugriff");
  if (fehler) return;
  .
  .
  .
}

3. BEDARF VON STACKEINTRÄGEN

Zur Überprüfung, ob für ein Wort die nötige Anzahl von Stackeinträgen vorhanden ist, existiert die Funktion need(). Sie ruft im Fehlerfall gleich intern fmeld() auf.

Beispiel:

void multiplizieren()
{ if (need(2)) return;
  real x=pull(); 
  real y=pull();
  push(x*y);
}

5. STACKEINTRÄGE

Die Byteanzahlen für die diversen Datentypen sind maschinen- bzw. compilerabhängig, daher wird hier nicht näher auf die tatsächlichen Aufteilungen im Speicher, sondern auf den prinzipiellen Aufbau eingegangen.

Alle Stackeinträge haben einen einheitlichen Kopf:

typedef struct { keytyp laenge;
                 keytyp namptr;
                 stackinfotyp info; } stackkopftyp;

• laenge ... Größe des Stackeintrags in Bytes.
• nameptr ... Relativadresse des Namens des Stackeintrags.
• info ... Enumerationstyp, der den Datentyp des Stackeintrags charakterisiert.

typedef struct { stackkopftyp header; char wert[1];} stringkopf;
typedef stringkopf *stackstring;

6. VERBUNDE

Es gibt zwei Arten von Verbunden: homogene und inhomogene.

Homogene Verbunde sind Verbunde, in denen ausschließlich eine Art von Stackeinträgen ist (alle Einträge ohne Name). Inhomogene Vergunde sind alle sonstigen.

Homogene Verbunde haben eine andere Adressierungsstruktur als inhomogene. Die für alle Komponenten gemeinsame Information (der Komponentenkopf) wird nur einmal (im Verbundkopf) gespeichert. Damit benötigen homogene Verbunde weniger Speicherplatz.

Außerdem kann direkt adressiert werden, da alle Komponenten gleich lang sind.

Für Realverbunde besteht daher die Möglichkeit, eine Klasse vectortyp zuzuordnen, mit der die Zugriffe zu Komponenten vereinfacht wird.

Beispiel:

vectortyp feld=makerealvector(stackptr);
printf("dritter Eintrag von feld=%g\n",feld[3]);

6.1. Indizieren

Indiziert wird mit der Prozedur indizieren().

int indizieren(int sp,keytyp index);

6.2. Komponentenanzahl

Für die Bestimmung der Komponentenanzahl eines Verbunds oder der Zeichenanzahl eines Strings verwendet man maxindex().

keytyp maxindex(int sp=stackptr);

6.3. Realverbunde

Für Realverbunde existieren einige komfortable Hilfsroutinen:

• int isrealvector(int sp=stackptr) übergibt, falls der Stackeintrag ein Realvektor ist 1, sonst 0.
• vectortyp makerealvector(int sp=stackptr) konvertiert von 'void*' auf 'vectortyp' mit Typkontrolle.
• vectortyp create_realvector(keytyp anz) richtet einen Realverbund mit 'anz' Komponenten ein.

void ramp()
{ keytyp anz=(keytyp)pull();
  vectortyp rampe=create_realvector(anz); 
  for (keytyp i=0;i<anz;i++) rampe[i+1]=i;
}



void sinus()
{ vectortyp feld=makerealvector();
  for (keytyp i=1;i<=maxindex();i++)
  feld[i]=sin(feld[i]);
}

7. EINRICHTEN NEUER STACKEINTRÄGE

Alle Stackeinträge müssen mit der Prozedur create() eingerichtet werden. Sie inkrementiert den Stackpointer, reserviert den Speicherbereich für den Datensatz (mit new) und überprüft die notwendigen Voraussetzungen.

void* create(keytyp laenge,stackinfotyp info);

8. DAS HEADERFILE MAL.H

Die Include-Datei mal.h wird in allen Moduldateien verwendet. Sie enthält die Typdefinitionen für die Stackeinträge, die Klasse vectortyp und Deklarationen für globale Varable (z.B fehler) und Prozeduren.

Viele der Prozeduren und Variablen befinden sich in der Datei mal.C (bzw mal.cpp unter Windows).

Prozeduren, die Informationen über Stackeinträge holen, sind meist so definiert, daß sie auf beliebige Stackeinträge (nicht nur den Top of Stack) angewandt werden können. Gibt man jedoch keinen Stackpointer an, so gilt als Vorbesetzung stackptr, also der Top of Stack.

Informationen über Stackeinträge:

• keytyp laenge() ... Größe des Stackeintrags in Byte
• stackinfotyp info() ... Art des Stackeintrags
• keytyp maxindex() ... Anzahl der Verbundkomponenten
• int isrealvector() ... <>0 bedeutet Realverbund
• int isemedvector() ... <>0 Verbund von EMED-Datensätzen
• int iscompound()

• void push(real zahl) ... legt 'zahl' auf den Stack.
• real pull() ... holt eine Realzahl vom Stack.
• spullstring(char *text) und
• lpullstring(char *text)

9. BEHANDLUNG VON NAMEN

Es existieren zwei Prozeduren zum Setzen von Namen:

void setname()

void setname(char *name)

int getname()

int getname(char *name)

12. DIE KLASSE SOURCETYP

MAL-Sourcecode kann von verschiedensten Quellen stammen:

• Bedieneingabe
• Datei
• Doppelpunktdefinition
• Codestring
• Zwischenbedienung ('debugging>' oder 'breakpoint>')

13. INTERPRETATION

14. DER INTERPRETER

Der Interpreter wird für verschiedenste Zwecke benötigt, nicht nur für die normale Interpretation während der Laufzeit. Zum Beispiel muß vor dem Abspeichern einer Doppelpunktdefinition deren letzter Strichpunkt bestimmt werden. Zu diesem Zweck muß ihr Code ohne Ausführung interpretiert werden. Auch bei der Komprimierfunktion im MAL-Editor ist ein Interpreter nötig.

Damit der Code für alle jene Interpreter ident und leicht zu warten ist, wird für alle diese Zwecke die Klasse interpreter_class (in der Datei interp.cpp) verwendet. Sie hat zwei Public-Members:

• interpret() Liest den Sourcecode aus der globalen Variable source.
• wortholen(char *wort) Holt das nächste Word aus dem Sourcecode.

15. ZAHLENUMWANDLUNG

Für die Zahlenkonvertierung bei Eingabe existiert die Prozedur realzahl().

int realzahl(char *wort,real &zahl);

int isword(char *wort)

void get_format(char *format);

16. SYSTEMVARIABLE

Für Systemvariable mit Real-Werten existieren die Funktionen get_sysvar() und set_sysvar(). set_sysvar() richtet die Variable ein, wenn sie noch nicht lokal definiert ist.

• real get_sysvar(char *name,real preset);
• void set_sysvar(char *name);

17. FUNKTIONEN UND OPERATOREN

Weil mathematische Funktionen und Operatoren für verschiedenste Datentypen verwendet werden können, sind die Adressierungsstrukturen vorprogrammiert. Für Funktionen existiert eine Prozedur funktionen(), die mit der entsprechenden mathematischen Funktion versorgt werden muß.

typedef double (*funktionentyp)(double);



void funktionen(funktionentyp funktion)
{ if (need(1)) return;
  .
  .
}

void sinus()
{ funktionen(sin); 
}

typedef real (*operatortyp)(real,real);



void operatoren(operatortyp op)
{ if (need(2)) return;
  stackinfotyp t1=info(stackptr-1);
  stackinfotyp t2=info(stackptr);
  .
  .
}

real multiplizieren(real op1,real op2)
{ return op1*op2; 
}



void multiplikation()
{ operatoren(multiplizieren); 
}

18. VEKTOREN UND MATRIZEN

In der Datei vector.C sind die Klassen

• double_vector
• vector3d
• vector2d
• double_matrix
• matrix3d

double_vector(keytyp dimension);
double_vector(double_vector &a);
~double_vector() { delete data; }
void zero();
double& operator[](int i);
void operator=(double_vector right);
void operator=(vector3d right);
void operator=(vector2d right);
friend double_vector operator+(double_vector a,double_vector b);
friend double_vector operator-(double_vector b,double_vector b);
void operator+=(double_vector b);
void operator-=(double_vector b);
friend double_vector operator*(double_vector a,double skalar);
void operator*=(double skalar);
double size();
void normalize();
void print();
void print(char *title);
void push();