Quelltext der Seite PS 440

{{Infobox Programmiersprache
| Name= PS&nbsp;440
| Paradigma= Strukturierte Programmierung
| Erscheinungsjahr= 1970
| Entwickler= [[Gerhard Goos]], Klaus Lagally, Gerd Sapper
| Typisierung= explizit, statisch
| Beeinflusst_von= [[:en:PL360|PL360]], [[Algol&nbsp;68]]
| Betriebssystem= [[TR 440#BS3|BS&nbsp;3]], BSM<ref name="BSM" />
}}

'''PS&nbsp;440''' ist eine [[Systemprogrammiersprache]] für den [[TR&nbsp;440]]. Sie vereint die Vorteile [[Höhere Programmiersprache|höherer Programmiersprachen]], wie größere Übersichtlichkeit, verminderte Fehleranfälligkeit, höheren Dokumentationswert des Quellprogramms und größere Bequemlichkeit beim Programmieren, mit der Möglichkeit, die Hardware des TR&nbsp;440 in allen Einzelheiten zu nutzen.

PS&nbsp;440 wurde an der [[Technische Universität München|TU München]] entwickelt als Hilfsmittel für die Programmierung eines Betriebssystems. Der Hersteller des TR&nbsp;440 hat den PS&#x2011;440-Compiler nicht selbst eingesetzt und auch nicht als Standard-Software vertrieben, aber die [[#Literatur|Dokumentation]] in der Schriftenreihe ''System TR&nbsp;440'' veröffentlicht. Der Compiler wurde von der [[TR 440#Mitwirkung der Benutzer|STARG]] verbreitet und weiterentwickelt.

== Geschichte ==

PS&nbsp;440 wurde von der Arbeitsgruppe für Betriebssysteme der TU München entwickelt als Hilfsmittel zur Programmierung eines Betriebssystems für den TR&nbsp;440.<ref name="BSM">{{Literatur |Autor=G.&nbsp;Goos, J.&nbsp;Jürgens, K.&nbsp;Lagally |Titel=The Operating System BSM Viewed as a Community of Parallel Processes |Sammelwerk=Technischer Bericht |Nummer=7208 |Verlag=[[Technische Universität München|TU München]] |Ort=München |Datum=1972 |Sprache=en}}</ref>

[[Gerhard Goos]] schrieb die Syntax-Analyse des PS&#x2011;440-Compilers mit Hilfe des von ihm entwickelten [[Parsergenerator]]s ''SMG (Syntax-Maschinen-Generator)''. Klaus Lagally<ref name="Lagally">{{Internetquelle |url=http://pcbs13.informatik.uni-stuttgart.de/ifi/bs/people/lagally.htm |titel=Klaus Lagally, em.&nbsp;Prof. Dr.&nbsp;rer.&nbsp;nat., Leiter der Abteilung Betriebssoftware |hrsg=[http://pcbs13.informatik.uni-stuttgart.de/ifi/ivi.php Institutsverbund Informatik der Universität Stuttgart] |datum=2014-04-08 |abruf=2020-11-17}}</ref> schrieb die Codegenerierung. Gerd Sapper<ref>{{Internetquelle |autor=DC2HC |url=https://echo34.de/mitglieder/dj4kw/professional/ |titel=DARC&nbsp;OV&nbsp;E34: Berufliches |hrsg=[https://echo34.de/e34home/willkommen/ OV&nbsp;E34, Funkamateure des Ortsverbandes Lüneburg-Ilmenau] |datum=2015-09-18 |abruf=2020-11-17}}</ref> brachte den Compiler auf den Betriebssystemen zum Ablauf. Das Ergebnis ist in ''Bericht 7002'' (I.&nbsp;Teil des [[#Literatur|PS&#x2011;440-Handbuchs]]) dokumentiert.

Helgrit Wich erstellte ein Skriptum zu einem Programmierkurs von Klaus Lagally und Gerd Sapper, daraus ist dann ''Bericht 7106'' (II.&nbsp;Teil des PS&#x2011;440-Handbuchs) entstanden.

In der Software-Entwicklung für Großrechner bei AEG-Telefunken wurde PS&nbsp;440 nicht eingesetzt, da hier schon frühzeitig die Verwendung der höheren Programmiersprache [[Basic Combined Programming Language|BCPL]] an Stelle einer Assemblersprache verfolgt wurde.<ref>{{Literatur |Autor=Hans-Jürgen Siegert |Titel=AEG-Telefunken TR&nbsp;440:Software und Software-Entwicklung |Sammelwerk=Informatik – Forschung und Entwicklung |Band=22 |Verlag=Springer-Verlag |Datum=2008-10 |ISSN=0949-2925 |Kapitel=BCPL als Systemimplementierungssprache |Seiten=255 |Online=[https://vdocuments.site/aeg-telefunken-tr-440-software-und-software-entwicklung.html Online] |Abruf=2020-08-22 |DOI=10.1007/s00450-008-0046-4}}</ref> 1972 erschien das [[#Literatur|PS&#x2011;440-Handbuch]] in der Serie ''System TR&#x202F;440'' bei Telefunken Computer. Der Compiler wurde über den Arbeitskreis ''Programmaustausch'' der [[TR 440#Mitwirkung der Benutzer|STARG]] verbreitet.

1976 wurde in Stuttgart im Rahmen einer studentischen Semesterarbeit die Testhilfe [[TR 440#Testhilfen|Trace]] für PS&nbsp;440 ergänzt, wie von anderen Compilern des TR&nbsp;440 gewohnt.

Mit der Ausmusterung der letzten TR&nbsp;440 Mitte bis Ende der 80er-Jahre endete naturgemäß die Anwendung der Sprache PS&nbsp;440.

== Programmstruktur ==

Der Compiler bildet die PS&#x2011;440-Quelle auf die Telefunken-Assemblersprache TAS<ref name="TAS">{{Literatur |Titel=TAS : Telefunken-Assembler-Sprache |TitelErg=Änderungsstand&nbsp;1 |Verlag=Telefunken Computer |Ort=Konstanz |Datum=1972-11 |Online=[http://www.tr440.info/doku/TAS_Telefunken-Assembler-Sprache.pdf Scan] |Format=PDF |KBytes=2561 |Abruf=2020-09-08}}</ref> ab; die nicht durch die Sprachmittel von PS&nbsp;440 abgedeckten Systemfunktionen<ref group="A">Hardwarebefehle; Steuerung von Assembler-, Montierer- und Überwacherfunktionen</ref> können durch [[#TAS|Einschübe von TAS-Sequenzen]] genutzt werden. Die erzeugte TAS-Quelle kann anschließend in der üblichen Weise assembliert und [[Linker (Computerprogramm)|montiert]] werden. Der PS&#x2011;440-Compiler ist ein [[Compiler#Einordnung verschiedener Compiler-Arten|Single-Pass-Compiler]]; der TAS-Assembler fungiert als zweiter Durchlauf der Compilation. Diese Konstruktion hat folgende Konsequenzen:
* Ein PS&#x2011;440-Programm besteht aus einem oder mehreren, an einander gereihten (nicht geschachtelten), ''Segmenten''. [[Bezeichner]] sind lokal in einem Segment gültig; Bezeichner, die als ''global'' gekennzeichnet sind, gelten im gesamten Quellprogramm. Bezeichner aus anderen Programmmoduln können per [[#Spezifikation|''Extern-Vereinbarung'']] erreicht werden, globale Bezeichner können als ''Eingang'' gekennzeichnet und so für andere Programmmoduln erreichbar gemacht werden; die Externbezüge werden den Eingangsbezeichnern beim Montieren zugeordnet.
* [[#Anweisungen|Anweisungen]], [[#Deklarationen und Spezifikationen|Deklarationen und Spezifikationen]] können, getrennt durch Semikolon, in gemischter Reihenfolge niedergeschrieben werden.<ref group="A">Der TAS-Assembler legt Konstanten, Variable und Befehle jeweils in eigenen Adresszonen ab, die dann beim Montieren mit gleichartigen Adresszonen aus anderen Programmmoduln jeweils zu Gebieten zusammengefasst werden. Mit anderen Worten: Auch wenn in der PS&#x2011;440-Quelle zwischen den Anweisungen Variablen- oder Konstanten-Deklarationen eingestreut sind, landen die den Anweisungen entsprechenden Befehle schließlich fortlaufend im Maschinenprogramm und werden –&nbsp;abgesehen von Sprungbefehlen und Prozeduraufrufen&nbsp;– fortlaufend ausgeführt. Dies gilt natürlich nur, soweit dieser Mechanismus nicht durch einen <code>STARR</code>- oder <code>ABLAGE</code>-Pseudobefehl in einem TAS-Einschub unterdrückt ist.</ref><ref name="STARR">{{Literatur |Titel=TAS : Telefunken-Assembler-Sprache |TitelErg=Änderungsstand&nbsp;1 |Verlag=Telefunken Computer |Ort=Konstanz |Datum=1972-11 |Kapitel=Kap.&nbsp;C&#x2011;6&nbsp;Anordnung von Informationseinheiten, Adressenzonen und Gebieten |Online=[http://www.tr440.info/doku/TAS_Telefunken-Assembler-Sprache.pdf#page=54 Scan] |Format=PDF |KBytes=2561 |Abruf=2021-04-18}}</ref>
* Alle Bezeichner müssen vor ihrer ersten Verwendung deklariert oder wenigstens spezifiziert sein, sofern ihre Art nicht aus der Verwendung hervorgeht. Beispiele: eine Marke braucht nicht vorab spezifiziert zu werden, wenn sie in einer [[#Anweisungen|Sprung-Anweisung]] verwendet wird; eine Variable, die in einer [[#REF|konstanten Referenz]] verwendet wird, kann auch weiter hinten im Programm deklariert sein.
* [[#Deklarationen und Spezifikationen|Selbständige Bezeichner]] aus PS&#x2011;440-Deklarationen können in den TAS-Einschüben verwendet werden. In TAS deklarierte Bezeichner sind dagegen außerhalb der TAS-Einschübe unbekannt. Am besten deklariert man alle benötigten Bezeichner mit PS&#x2011;440-Sprachmitteln (außerhalb von TAS-Einschüben).
* Als [[TR 440#Testhilfen|quellsprachbezogener Dump]] kann der TAS-Dump verwendet werden.

In PS&nbsp;440 gibt es 97 reservierte Schlüsselwörter, die als [[Trennzeichen|Delimiter]], [[Deklaration (Programmierung)|Deklaratoren]], [[Operator (Mathematik)|Operatoren]] und Bezeichnungen der [[TR 440#Technische Einzelheiten|Hardware-Register]] fungieren.
<!--
* Delimiter: <code>begin by call case co comment continue do else elsf end esac fi finis for from goto if of return segm segment then to until while</code>
* Deklaratoren: <code>data entry full glob global index instr instruct is label long proc procedure procsfb record ref sel select short spec</code>
* Operatoren: <code>abs and aral aut bit bodd dmod eq et exec fval ge gt ival le left leftc lt lval minus ml mll mod ne not odd or plus right rightc rm<ref group="A">Das 1&nbsp;Bit lange Markenregister ''RM'' hat in PS&nbsp;440 keine Bezeichnung. Es wird implizit gesetzt durch Transporte von FULL- und LONG-Werten mit TK=0 oder TK=1; es wird gelöscht durch den TAS-Einschub <code>*/LA M/*</code>; und es kann mittels der Operation <code>RM</code> abgefragt werden.</ref> sval tk tk0 tk1 tk2 tk3 tkal val vel ws</code>
* Register: <code>ac bb bf bu ra raq rd rh rhq rq ry</code>
-->
Die Syntax in der Tradition der [[ALGOL|Algol-ähnlichen Sprachen]] macht insbesondere Anleihen bei [[Algol 68|Algol&nbsp;68]] und umfasst die üblichen Bausteine der [[Strukturierte Programmierung|strukturierten Programmierung]].

== Datentypen ==

Entsprechend der [[TR 440#Informationsdarstellung|Datenstruktur des TR&nbsp;440]] kennt PS&nbsp;440 nur drei Datentypen:
* <code>SHORT</code> Halbwort mit 24&nbsp;Bit Länge,
* <code>FULL</code> Ganzwort mit 48+2&nbsp;Bit Länge,
* <code>LONG</code> Doppelwort mit 2×(48+2)&nbsp;Bit Länge.
Größen dieser Typen können in einem passenden Register oder im Hauptspeicher liegen; im Speicher haben die Halbwörter fortlaufende, die Ganz- und Doppelwörter gerade Adressen. Für alle Operatoren ist festgelegt, auf welche dieser Typen sie anwendbar sind und welchen dieser Typen sie als Ergebnis liefern. Für Zwischenergebnisse in komplexen Ausdrücken wählt der Compiler Register oder Speicherzellen passender Länge aus.

Weitere Datentypen differenzieren anhand des Zugriffsmechanismus:
* <code>INDEX</code> wird zur Deklaration von Halbwörtern im Index-Speicher benutzt: In Ausdrücken verhalten sie sich wie SHORT-Größen, der Speicherzugriff erfolgt jedoch über spezielle Befehle.
* <code>PART</code> ist ein beliebiger, durch eine Bitmaske gesteuerter, Ausschnitt aus einer FULL-Größe; in Ausdrücken wird eine PART-Größe als Ganzwort (wie eine FULL-Größe) weiter verarbeitet.
* <code>LABEL</code>, <code>PROC</code> und <code>PROCSFB</code> beziehen sich auf Adressen in der Befehlszone; sie können Ziel eines Sprunges oder eines Prozeduraufrufs sein.
Den Datentypen im Sinne höherer Programmiersprachen, wie '''bool''', '''int''', '''real''' und '''bytes'''<!-- Fettdruck gemäß Algol68-Syntax bitte nicht ändern --> in Algol&nbsp;68, sind in PS&nbsp;440 keine unterschiedlichen Datentypen zugeordnet; vielmehr wird die Interpretation der Daten teils anhand ihres aktuellen Wertes (nämlich ihrer Typenkennung) bestimmt, teils anhand der Operationen, die man auf sie anwendet.

=== {{Anker|TK}}Typenkennung ===

Jedes Ganzwort enthält neben den 48&nbsp;Bit der eigentlichen Information noch 2&nbsp;Bit als ''Typenkennung'' mit folgender Bedeutung:
* Gleitkommazahlen haben im Ganzwort TK=0 (im Doppelwort TK=0 im ersten, TK=1 im zweiten Teil);
* Festkommazahlen haben TK=1 (im Doppelwort zweimal);
* Befehle belegen Halbwörter innerhalb von Ganzwörtern mit TK=2;
* je sechs Textzeichen belegen normalerweise ein Ganzwort mit TK=3.

[[Literal#Literale in Programmiersprachen|Literale]] legen durch ihre Form die Typenkennung implizit fest, so erzeugen etwa die Literale <code>1.618</code> und <code>6.022⏨23</code> Ganzwörter mit TK=0, die Literale <code>5</code> und <code>-2</code> Ganzwörter mit TK=1 und das Literal <code>"PS&nbsp;440"</code> ein Ganzwort mit TK=3; Bits-Angaben wie <code>'2H&nbsp;0003&nbsp;AFFE'</code> enthalten (links vom H) die gewünschte Typenkennung.<ref group="A">Literale können auch mit einer Längen-Angabe versehen werden, etwa <code>SHORT&nbsp;42</code> oder <code>LONG&nbsp;3.14159265358979323846264338</code>.</ref>

Typenkennungen können mit den Operationen <code>TK0</code>, <code>TK1</code>, <code>TK2</code> und <code>TK3</code> gesetzt und mit der [[#Bedingung|Operation  <code>TK</code>]] abgefragt werden.

=== Operationen und Operanden ===

Einige Operationen verhalten sich unterschiedlich, je nach der Typenkennung ihrer Operanden. So vergleichen etwa die ''Vergleichs-Operationen'' <code>&gt;</code>, <code>≥</code> <code>=</code>, <code>≠</code>, <code>≤</code> und <code>&lt;</code> zwei Operanden mit TK=0 als Gleitkommazahlen (mit Berücksichtigung von Exponent und Vorzeichen), zwei Operanden mit TK=1 als Festkommazahlen (mit Berücksichtigung des Vorzeichens) und zwei Operanden mit TK=2 oder TK=3 als positive Festkommazahlen.<ref group="A">Der Programmierer muss dafür Sorge tragen, dass möglichst nur Operanden mit gleicher Typenkennung verglichen werden. Bei Operanden unterschiedlicher Typenkennungen geht die [[Ordnungsrelation|Transitivität der Vergleichsoperatoren]] verloren; so ergibt sich beispielsweise die widersprüchliche Situation, dass <code>-1&lt;1</code>, <code>1&lt;"1"</code> und <code>"1"&lt;-1</code> alle gleichermaßen zutreffen!</ref>  Auch die Wirkung der ''Verschiebe-Operationen'' <code>LEFT</code>, <code>RIGHT</code>, <code>LEFTC</code> und <code>RIGHTC</code> hängt von der Typenkennung ihres linken Operanden ab.

Bei anderen Operationen entscheidet die Wahl des Operator-Zeichens, welche Variante gewünscht ist. So gibt es beispielsweise unterschiedliche Operatoren für die arithmetischen Operationen, etwa <code>*</code> für die Festkomma-Multiplikation und <code>**</code> für die Gleitkomma-Multiplikation. Diese Operationen lösen eine [[Interrupt|Programmunterbrechung]], den ''TK-Alarm'', aus, wenn ihre Operanden die falsche Typenkennung haben.<ref group="A">Vorsicht ist auch geboten bei den Operatoren <code>+</code> und <code>-</code>: Die führen stets eine Festkomma-Addition bzw. &#x2011;Subtraktion durch (jeweils mit Berücksichtigung des Vorzeichens), auch wenn ein Operand eine andere Typenkennung als 1 hat.  So wird beispielsweise <code>1.618</code> bei der (versehentlichen) Festkomma-Addition als <code>7116039255041</code> aufgefasst und <code>"PS&nbsp;440"</code> als <code>-52971178773327</code>.</ref> Die Operatoren [[Konjunktion (Logik)#Die Konjunktion in der klassischen, zweiwertigen Logik|<code>ET</code>]], [[Disjunktion#Nicht-ausschließende Disjunktion|<code>VEL</code>]] und [[Kontravalenz|<code>AUT</code>]] verknüpfen ihre Operanden bitweise.

{{Anker|REF}}{{Anker|VAL}}Die ''Wertoperatoren'' <code>SVAL</code>, <code>FVAL</code> und <code>LVAL</code> fassen ihren (einzigen) Operanden als Adresse eines Halb-, Ganz- bzw. Doppelworts im Speicher auf und liefern dessen aktuellen Inhalt; entsprechend liefert <code>IVAL</code> den Inhalt einer Indexspeicherzelle (ein Halbwort). Umgekehrt liefert der ''Referenz-Operator'' <code>REF</code>, der nur auf einen Operanden im Speicher angewandt werden kann, dessen Adresse.

=== Ausdrücke ===

{{Anker|Formel}}''Formeln'' beschreiben die Berechnung von Werten aus einfachen Operanden. Sie folgen der üblichen Syntax mit [[Infixnotation]] für [[Zweistellige Verknüpfung|binäre]] und Präfixnotation für [[Einstellige Verknüpfung|unäre]] Operatoren mit den üblichen [[Operatorrangfolge|Prioritäten]] und mit runden Klammern, wo die normalen Operator-Prioriäten nicht passen. <!-- Auch eine [[#Wertzuweisung|Wertzuweisung]] gilt syntaktisch als Ausdruck, kann also (in Klammern) als Operand in einer Formel auftreten. -->Alle Ausgangs-, Zwischen- und Resultatwerte haben eine inhärente Länge gemäß einem der drei [[#Datentypen|Datentypen]] und werden bei Bedarf verlängert oder verkürzt.<ref group="A">Beim Verkürzen eines Wertes auf <code>FULL</code> oder  <code>SHORT</code> wird das rechte Ganz- bzw. Halbwort des Ausgangswerts weiter verwendet. Beim Verlängern von <code>SHORT</code> auf <code>FULL</code> wird links mit Vorzeichen-gleichen Bits aufgefüllt, auch bei TK=2 oder TK=3. Beim Verlängern auf <code>LONG</code> wird links ein Ganzwort mit der Festkommazahl <code>0</code> ergänzt. Auch das kann zu Überraschungen führen: nach <code>LONG&nbsp;L := -FULL&nbsp;1</code> ist L positiv, nach <code>LONG&nbsp;L := -LONG&nbsp;1</code> negativ.</ref>

{{Anker|Bedingung}}Da PS&nbsp;440 keinen [[Boolesche Variable#Programmierung|booleschen Datentyp]] kennt, kann ein Vergleich keine Formel sein, sondern ist eine ''Bedingung'': Bedingungen steuern [[#Strukturierte Anweisungen|Fallunterscheidungen und Wiederholungen]], liefern aber im Gegensatz zu Formeln keinen Wert, der gespeichert oder mit dem weitergerechnet werden kann. Die Grundbausteine der Bedingungen sind [[#Operationen und Operanden|Vergleiche]] und Tests. Die ''Alarmtests'' <code>TKAL</code> und <code>ARAL</code> haben keinen Operanden, die ''Typenkennungs- und Bit-Tests'' haben zwischen dem Operatorsymbol und dem Operanden noch eine TK- bzw. Bit-Nummer, zum Beispiel: <code><span style="color:#808080">IF</span> TK&nbsp;1&nbsp;RA <span style="color:#808080">THEN RA&nbsp;:=&nbsp;-RA FI</span></code>; diese Nummer muss explizit (nicht als Formel) angegeben werden. Vergleiche und Tests können mit den ''logischen Operatoren'' [[Negation#Logik|<code>¬</code>]], [[Konjunktion (Logik)#Die Konjunktion in der klassischen, zweiwertigen Logik|<code>∧</code>]] und [[Disjunktion#Nicht-ausschließende Disjunktion|<code>∨</code>]] zu komplexen Bedingungen verknüpft werden.

== Deklarationen und Spezifikationen ==

=== Selbständige Vereinbarung ===

Die mit selbständigen Vereinbarungen definierten Bezeichner können auch in TAS-Einschüben verwendet werden und erscheinen gegebenenfalls im [[TR 440#Testhilfen|Trace und im TAS-Dump]].

Eine ''Typvereinbarung'' bestimmt Typ und Speicherort von Variablen oder Konstanten; für Variable kann ein Anfangswert, für Konstanten muss der Wert angegeben werden. Eine ''Indexspeicher-Vereinbarung'' bestimmt nur den Speicherort von Indizes; die sind immer ein Halbwort lang, immer variabel und haben keinen definierten Anfangswert. Eine Typ- oder Indexspeicher-Vereinbarung kann mit einer [[#Wertzuweisung|Wertzuweisung]] kombiniert werden, die dann – im Gegensatz zum statischen Anfangswert – zur Laufzeit des Programms ausgeführt wird.

Eine ''Prozedurvereinbarung'' definiert ein Unterprogramm. PS&nbsp;440 kennt weder Prozedur-Parameter noch Funktionswerte: Wie in maschinennaher Programmierung üblich, muss die Informationsübergabe zwischen rufendem Programm und Prozedur über den Hauptspeicher oder die Register organisiert werden. Falls eine Prozedur rekursiv aufgerufen werden soll, muss sie auch den [[Stapelspeicher|Keller]] für ihre lokalen Variablen explizit organisieren.<ref name="A60-Keller">Ein Beispiel ist der Algol-60-Keller, siehe {{Literatur |Titel=TR&nbsp;440 : TAS-Handbuch : Telefunken-Assembler-Sprache |TitelErg=Änderungsstand&nbsp;19 |Verlag=Telefunken Computer |Ort=Konstanz |Datum=1972-06 |Seiten=D9&#x2011;1–D9&#x2011;2 |Online=[http://www.tr440.info/doku/Assemblersprache.pdf#page=154 Scan] |Format=PDF |KBytes=14801 |Abruf=2020-09-08}}</ref> Entsprechend den [[#UP|beiden Aufrufmechanismen]] unterscheidet PS&nbsp;440 auch PROC- und PROCSFB-Vereinbarungen.

''Marken'' werden dadurch vereinbart, dass sie an der entsprechenden Stelle im Programm gesetzt sind (mit nachfolgendem Doppelpunkt).

Beispiele:
   TYPVEREINBARUNGEN:
   ; LONG L1, L2, L3         CO drei LONG-Variable ohne bestimmten Anfangswert;
   ; SHORT S1 PRESET 5       CO eine SHORT-Variable mit Anfangswert 5;
   ; SHORT S2 IS REF L3      CO eine SHORT-Konstante, deren Wert die Adresse von L3 ist;
   ; SHORT S3 := BB          CO eine SHORT-Variable,
                                der der momentane Inhalt von BB als Wert zugewiesen wird;
   ; [0:3]FULL F41           CO ein Aggregat aus zwei FULL-Variablen;<ref group="A">Die Indizierung erfolgt für alle Aggregate, unabhängig vom Typ, ab 0 in Halbwort-Schritten.</ref>
   ; [0:5]FULL VB616         CO ein Aggregat aus drei FULL-Konstanten;
     IS ( REF S&SRF, SHORT 3 CO deren Wert auch halbwortweise angegeben werden kann;<ref group="A">Eine Adresse wie <code>REF S&SRF</code> belegt ein Halbwort.</ref>
        , REF TXT  , SHORT 2
        , '2H 0'             CO aber natürlich auch ganzwortweise;
        )
 &nbsp;
 ; INDEXSPEICHERVEREINBARUNGEN:
   ; INDEX I, J, K             CO drei Indizes;
   ; [0:2]INDEX X3             CO ein Aggregat aus drei weiteren Indizes;
 &nbsp;
 ; PROZEDURVEREINBARUNGEN:
   ; PROC FAK                  CO Fakultät (iterativ);
     IS BEGIN
       INDEX F; FULL P
     ; F := RA; P := 1         CO Argument in RA (muss TK=1 haben);
     ; FOR F FROM F BY -1 TO 2
       DO P := P * F           CO Arithmetischer Alarm möglich! ;
     ; RA := P                 CO Resultat in RA;
     END FAK
   ; PROCSFB INCRTAG           CO Prozedur für CALLSFB;
     IS IF TAG = 6 THEN TAG := 0 ELSE TAG +:= 1 FI

=== Äquivalenz-Vereinbarung ===

Mit einer Äquivalenz-Deklaration wird einem neuen (unselbständigen) Bezeichner eine Bedeutung, bestehend aus Typ und Zugriffsmechanismus, zugewiesen, indem er einer bereits deklarierten Größe (oder einer Komponente davon) gleichgesetzt wird. Beim Zugriffsmechanismus können [[Adressierung (Rechnerarchitektur)#Indirekte Adressierung|indirekte Adressierung]], Indizierung und Teilwortzugriffe verwendet werden; diese Mechanismen werden dynamisch ausgewertet.<ref group="A">Die Äquivalenzvereinbarung von PS&nbsp;440 ist noch eine Spur dynamischer als die von Algol&nbsp;68, wie der Vergleich von <code>FULL F41I = F41[I]</code> mit <code>'''ref''' '''int''' f41i = f41[i]</code><!-- Fettdruck gemäß Algol68-Syntax bitte nicht ändern --> zeigt: In Algol&nbsp; wird <code>i</code> einmalig beim Durchlaufen der Äquivalenzvereinbarung ausgewertet, bei PS&nbsp;440 wird dagegen <code>I</code> bei jedem Zugriff auf <code>F41I</code> erneut ausgewertet.</ref> Eine Äquivalenz-Deklaration kann auf bereits deklarierte selbständige oder unselbständige Größen Bezug nehmen; letztlich muss eine Kette von Äquivalenzen immer auf eine selbständige Größe führen. Die folgenden Beispiele beziehen sich auf die [[#Selbständige Vereinbarung|oben]] deklarierten selbständigen Größen:
   INDIZIERUNG:
   ; SHORT FADR = VB616[0]  CO FADR bezeichnet das erste Halbwort des Aggregats VB616;
   ; FULL  F41I = F41[I]    CO F41I bezeichnet ein Ganzwort aus F41,
                               abhängig vom aktuellen Wert von I;
 &nbsp;
 ; INDIREKTADRESSIERUNG:
   ; [0:9]FULL FK = FVAL K  CO FK bezeichnet dasjenige Aggregat, dessen Adresse aktuell in K steht;
   ; FULL FK2     = FK[2]   CO FK2 ist das zweite Ganzwort aus FK - wo das ist, hängt von K ab;
   ; FULL FKJ     = FK[J]   CO indirekte Adressierung und Indizierung können kombiniert werden;
 &nbsp;
 ; TEILWORTZUGRIFF:
   ; PART E  = '2H FFFFFF FFFFFB' OF VB616[0] CO E bezeichnet ein Bit aus dem 1. Ganzwort von VB616;
     ,    KA = '2H FFFFFF FFFFFC' OF VB616[0] CO KA bezeichnet ein Feld aus zwei weiteren Bits;<ref name="SSR_6_16" />
Selbstverständlich können auch Teilwort-Zugriffe mit Indizierung und indirekter Adressierung kombiniert werden. Diese Äquivalenzvereinbarungen erleichtern das Programmieren des TR&nbsp;440 erheblich, wie das unten stehende [[#Unterprogramm für Fortran-Programm|Unterprogramm für Fortran-Programm]] illustriert.

=== Spezifikation ===

Eine Spezifikation macht die Eigenschaften einer selbständigen Größe bekannt, deren Speicherplatz an anderer Stelle deklariert wird: Eine ''eigentliche Spezifikation'' kündigt eine Vereinbarung im selben Programm an und ermöglicht damit die Compilation in einem Durchlauf; eine ''Extern-Vereinbarung'' hat (trotz des abweichenden Namens) dieselbe Funktion für eine selbständige Größe, die in einem anderen Programmodul vereinbart ist. Eine ''Eingangs-Spezifikation'' ermöglicht einem anderen Programmodul, sich auf eine selbständige Größe des vorliegenden Programms zu beziehen. Extern-Vereinbarungen und Eingangs-Spezifikationen für Indizes sind nicht möglich. Die folgenden Beispiele beziehen sich auf die [[#Selbständige Vereinbarung|oben]] deklarierten selbständigen Größen:
   SPEZIFIKATION:
   ; SPEC [0:5]FULL VB616          CO VB616 kann weiter unten im Programm deklariert werden;
   ; SPEC INDEX     F              CO Das ist auch für Indizes erlaubt;
 &nbsp;
 ; EXTERNVEREINBARUNG:
   ; SPEC WUNDERPGM LABEL MIRAKEL  CO MIRAKEL ist eine Marke im Programmodul WUNDERPGM;
   ; SPEC FAK       FULL  XYZ      CO FAK ist ein Programmmodul, kein lokaler Bezeichner;
   ; SPEC S&SRF     LABEL S&SRF    CO Namensgleichheit mit Bezeichnern stört also nicht;
 &nbsp;
 ; EINGANGSSPEZIFIKATION:
   ; ENTRY FAK, VB616    CO anderen Programmoduln sind die lokalen Größen FAK und VB616 zugänglich;

== Anweisungen ==

=== Einfache Anweisungen ===

==== Wertzuweisung und Tausch ====

{{Anker|Wertzuweisung}}Die ''Wertzuweisung'' weist einer Variablen einen neuen Wert zu; im Gegensatz zur [[#Selbständige Vereinbarung|statischen Vorbelegung mit <code>PRESET</code>]] wird die Wertzuweisung zur Laufzeit des Programms ausgeführt. Wie in Algol&nbsp;68 gilt die Wertzuweisung als Ausdruck, kann also Teil einer Formel oder rechter Teil einer weiteren Wertzuweisung sein. Erhöhungen und Erniedrigungen (siehe Beispiele) ergeben besonders effizienten Maschinencode.

{{Anker|Tausch}}Der ''Tausch'' vertauscht die aktuellen Werte zweier Variablen. Beide Variable müssen dieselbe Länge haben; Indizes können nur mit anderen Indizes oder dem Register ''BB'' getauscht werden. Der Tausch gilt nicht als Ausdruck, kann also –&nbsp;im Gegensatz zur Wertzuweisung&nbsp;– nicht Teil einer Formel sein.

Beispiele:
   WERTZUWEISUNG:
     RAQ := L3            CO kopiert den Inhalt des Doppelworts L3 ins Register RAQ;
   ; L1  := L2            CO das geht natürlich auch mit Variablen im Speicher;
   ; J   := FADR          CO oder mit Indizes;
   ; RA  := L3            CO die Kopie in RA ist kürzer, die linken 48+2&nbsp;Bit fallen weg;
   ; BB +:= 1             CO BB wird um 1 erhöht (kurz für "BB:=BB+1");
   ; P --:= 1.0⏨0         CO Erhöhung und Erniedrigung gibt's auch für Gleitkommazahlen;
   ; RAQ := RH := F41     CO RH erhält den Wert von F41,
                             RAQ denselben Wert auf doppelte Länge mit 0-Bits aufgefüllt;
   ; RAQ := RA * (RH+:=1) CO RH wird um 1 erhöht,
                             mit dem neuen Wert wird RA*RH berechnet und RAQ zugewiesen;
 &nbsp;
 ; TAUSCH:
     RA  :=: RH           CO vertauscht die Inhalte der beiden Register;
   ; BB  :=: J            CO vertauscht die Inhalte des Registers BB und des Index J;
   ; J   :=: K            CO vertauscht die Inhalte zweier Indizes;
   ; FK2 :=: FKJ          CO vertauscht die Inhalte zweier Ganzwörter im Speicher;

==== {{Anker|TAS}}TAS-Einschub ====

Ein ''TAS-Einschub'' fügt die angegebenen Informationseinheiten<ref name="Informationseinheit">{{Literatur |Titel=TAS : Telefunken-Assembler-Sprache |TitelErg=Änderungsstand&nbsp;1 |Verlag=Telefunken Computer |Ort=Konstanz |Datum=1972-11 |Seiten=B&#x2011;7 |Online=[http://www.tr440.info/doku/TAS_Telefunken-Assembler-Sprache.pdf#page=14 Scan] |Format=PDF |KBytes=2561 |Abruf=2020-09-08}}</ref> in die erzeugte TAS-Quelle ein. Damit können Assembler- oder Hardware-Funktionen genutzt werden, für die keine eigenen PS&#x2011;440-Sprachmittel vorgesehen sind.

Beispiele:
   */START LOS, ALARM CIAO/*  CO zwei Deklarationen (TAS-Pseudobefehle);
 ; */SSR 1 12/*               CO ein Befehl, für den es kein PS-440-Sprachmittel gibt;

==== Ausnahmen von der fortlaufenden Befehlsausführung ====

{{Anker|UP}}Ein ''Prozeduraufruf'' führt ein Unterprogramm aus. PS&nbsp;440 unterscheidet zwei unterschiedliche Mechanismen zum Prozeduraufruf, entsprechend den Befehlen <code>SU</code><ref name="SU">{{Literatur |Titel=TR&nbsp;440 : Befehls-Lexikon |Verlag=[[AEG#1945 bis Ende der 1960er Jahre|AEG-Telefunken]] |Ort=Konstanz |Datum= |Seiten=SU–SUE |Online=[http://www.tr440.info/doku/TR440-Befehlslexikon.pdf#page=391 Scan] |Format=PDF |KBytes=5259 |Abruf=2020-09-08}}</ref> und <code>SFB</code>.<ref name="SFB">{{Literatur |Titel=TR&nbsp;440 : Befehls-Lexikon |Verlag=[[AEG#1945 bis Ende der 1960er Jahre|AEG-Telefunken]] |Ort=Konstanz |Datum= |Seiten=SFB–SFBE |Online=[http://www.tr440.info/doku/TR440-Befehlslexikon.pdf#page=333 Scan] |Format=PDF |KBytes=5259 |Abruf=2020-09-08}}</ref> Der SU-Befehl und die entsprechende Rückkehr ins rufende Programm<ref name="MU">{{Literatur |Titel=TR&nbsp;440 : Befehls-Lexikon |Verlag=[[AEG#1945 bis Ende der 1960er Jahre|AEG-Telefunken]] |Ort=Konstanz |Datum= |Seiten=MU |Online=[http://www.tr440.info/doku/TR440-Befehlslexikon.pdf#page=271 Scan] |Format=PDF |KBytes=5259 |Abruf=2020-10-20}}</ref> führen automatisch einen Keller der Rücksprung-Adressen im Index-Speicher; deshalb können CALL-Prozeduren, die keine lokalen Variablen benutzen, auch ohne explizite Keller-Organisation rekursiv aufgerufen werden.

Die ''EXEC-Anweisung'' führt einen Maschinenbefehl aus, der in einem Halbwort steht. Dies wird u.&nbsp;a. zur Parameterversorgung von Unterprogrammen genutzt.

''Sprung'' und ''Rückkehr'' setzen den Programmlauf an anderer Stelle fort und sollten daher nur für Sonderfälle eingesetzt werden.<ref>{{Literatur |Autor=Edsger W. Dijkstra |Titel=Letters to the editor: Go To Statement Considered Harmful |Sammelwerk=[[Communications of the ACM]] |Band=11 |Nummer=3 |Verlag=[[Association for Computing Machinery|ACM]] |Datum=1968-03 |Seiten=147–148 |Sprache=en |DOI=10.1145/362929.362947}}</ref> Normalerweise erfolgt die Rückkehr aus einer Prozedur an deren Ende ohne explizite Rückkehr-Anweisung.

Die ''Leere Anweisung'' ist unsichtbar und wirkungslos, etwa wenn in einem Zweig einer Fallunterscheidung nichts zu tun ist.

Beispiele:
 ; SPRUNG:
     GOTO LEERANWEISUNG   CO Fortsetzung bei Marke LEERANWEISUNG;
   ; RETURN               CO Rückkehranweisung, darf nur innerhalb einer [[#Selbständige Vereinbarung|Prozedurvereinbarung]] stehen;
 &nbsp;
 ; PROZEDURAUFRUF:
     RA := 7              CO Argument bereitstellen;
   ; CALL FAK             CO Prozeduraufruf – es gibt keine formalen Parameter;
   ; F41 := RA            CO Ergebnis abholen;
 &nbsp;
 ; EXECANWEISUNG:
     EXEC HV              CO siehe Anwendung im [[#Unterprogramm für Fortran-Programm|Unterprogramm für Fortran-Programm]];
 &nbsp;
 ; LEERANWEISUNG:
   ;                      CO man sieht's hier nur am Extra-Semikolon;

=== Strukturierte Anweisungen ===

Die Anweisungen einer ''Sequenz'' werden durch Semikolon getrennt und können bei Bedarf mit <code>BEGIN</code> und <code>END</code> eingeklammert werden. Nach dem <code>END</code> darf ein Bezeichner als Kommentar geschrieben werden, um auf den Anfang der Sequenz hinzuweisen.

Die ''Fallunterscheidung'' gibt es als IF- und als CASE-Anweisung. Die IF-Anweisung muss mit <code>FI</code> abgeschlossen werden; so wird das [[Dangling else|''Dangling Else'']] vermieden und Sequenzen in THEN- oder ELSE-Zweig müssen nicht eingeklammert werden. Die CASE-Anweisung unterscheidet Fälle aufgrund eines ganzzahligen Ausdrucks; hier müssen gegebenenfalls Sequenzen eingeklammert werden.

Die ''Wiederholung'' kann durch eine Zählung oder durch eine Bedingung gesteuert werden; soll eine Sequenz wiederholt werden, muss sie mit <code>BEGIN</code> und <code>END</code> eingeklammert werden. Alle Wiederholungen sind [[Schleife (Programmierung)#Arten|vorprüfende Schleifen]].

Beispiele:
   SEQUENZ:
     BEGIN RA := 9; CALL FAK; F41 := RA END SEQUENZ
 &nbsp;
 ; FALLUNTERSCHEIDUNG:
     IF P ≤ 16               CO Die Bedingung bei IF wählt THEN- oder ELSE-Zweig aus;
     THEN RA := P; CALL FAK  CO Hier ist keine BEGIN-END-Klammer notwendig;
     ELSE RA := 0
     FI
   ; IF   RA = 0             CO das könnte auch die [[Vorzeichenbehaftete Null|negative Null]] sein;
     THEN RA := 0            CO jetzt ist's definitiv die positive Null;
     FI                      CO ELSE-Zweig kann fehlen;
   ; CASE MONAT-1            CO MONAT muss im Bereich 1:12 liegen;
     FROM MLAENGE := 31      CO Januar;
        , IF TK 2 JAHR       CO Februar;
          THEN MLAENGE := 29
          ELSE MLAENGE := 28
          FI
        , MLAENGE := 31      CO März;
        , MLAENGE := 30      CO April;
        , MLAENGE := 31      CO Mai;
        , MLAENGE := 30      CO Juni;
        , MLAENGE := 31      CO Juli;
        , MLAENGE := 31      CO August;
        , MLAENGE := 30      CO September;
        , MLAENGE := 31      CO Oktober;
        , MLAENGE := 30      CO November;
        , MLAENGE := 31      CO Dezember;
     ESAC
 &nbsp;
 ; WIEDERHOLUNG:
     FOR I FROM 1 TO 16      CO Zählschleife;
     DO BEGIN RA := I; CALL FAK; FF[I] := RA END I
   ; WHILE ODD               CO Schleife mit Bedingung;
     DO RA := RA RIGHT 1     CO Schleife endet mit einer geraden Zahl in RA;
   ; TO 99                   CO 100-mal (Zählung beginnt bei 0);
     DO BEGIN BB := VB616; */SSR 6 16/* END

== Vollständige Beispiele ==

Die folgenden Beispiele zeigen die PS&#x2011;440-Sprachmittel im Zusammenhang aus Benutzersicht (keine Systemprogramme). Da es derzeit keine Möglichkeit gibt, PS&#x2011;440-Programme zu testen, könnten sie Fehler enthalten.

Das PS&#x2011;440-Handbuch enthält als ''Anhang&nbsp;2'' ein ausführliches Beispiel für ein vollständiges Programm.<ref>{{Literatur |Titel=PS&nbsp;440 |TitelErg=Anhang&nbsp;2 |Datum= |Seiten=163–191 |Online=[http://www.tr440.info/doku/PS440_1972-05.pdf#page=148 Scan] |Format=PDF |KBytes=12862 |Abruf=2020-08-06}}</ref>

=== Selbständiges Benutzerprogramm ===

Das aus der folgenden Quelle erzeugte Programm kann im Benutzer-Auftrag mit dem normalen STARTE-Kommando aktiviert werden und schreibt dann den Text „Grüß Gott!“ ins Ablaufprotokoll (und im Dialogbetrieb an die Konsole des jeweiligen Benutzers).
 SEGMENT HALLOWELT
 ; */START VIA, ALARM CIAO/*               CO Start- und Alarm-Adresse;
 ; [0:255]FULL INDIZES; */XBASIS INDIZES/* CO Platz für Indizes;
 ; */VORBES (1,0), UNTPR 7/*               CO Vorbesetzung Arbeitsspeicher und BU-Register;
 &nbsp;
 ; [0:5]FULL VB616               CO Versorgungsblock für Systemdienst SSR 6 16;<ref name="SSR_6_16">{{Literatur |Titel=Systemdienste |TitelErg=Änderungsstand&nbsp;9 |Verlag=[[Computer Gesellschaft Konstanz|CGK]] |Ort=Konstanz |Datum=1975-01 |Seiten=SSR 6&nbsp;16 |Online=[http://www.tr440.info/doku/Systemdienste.pdf#page=114 Scan] |Format=PDF |KBytes=5961 |Abruf=2020-09-08}}</ref>
   IS ( REF CIAO                 CO Fehler-Ausgang;
      , SHORT 3                  CO Ausgabe ins Ablaufprotokoll und an Konsole;
      , REF "*021Grüß Gott!"     CO 1 Zeile Text (mit Vorschubzeichen [[TR 440#Zeichencodierung|NL]]);
      , SHORT 2                  CO 2 Ganzwörter (12 Zeichen) ausgeben;
      , FULL 0                   CO bedeutungslos, da keine Konsoleingabe verlangt;
      )
 ; FULL VB012 = VB616            CO VB616[0:1] taugt auch als Versorgung für SSR 0 12;<ref name="SSR_0_12">{{Literatur |Titel=Systemdienste |TitelErg=Änderungsstand&nbsp;9 |Verlag=[[Computer Gesellschaft Konstanz|CGK]] |Ort=Konstanz |Datum=1975-01 |Seiten=SSR 0&nbsp;12 |Online=[http://www.tr440.info/doku/Systemdienste.pdf#page=16 Scan] |Format=PDF |KBytes=5961 |Abruf=2020-09-08}}</ref>
 &nbsp;
 ; VIA:  BB := REF VB616; */SSR 6 16/* CO Text ausgeben;
 ; CIAO: BB := REF VB012; */SSR 0 12/* CO Programmlauf beenden;
 FINIS

Die fünf Angaben, die das Betriebssystem zum Start eines Programms im Benutzer-Auftrag benötigt, müssen in TAS-Einschüben gemacht werden. Auch die Systemdienste (SSR-Befehle) werden in TAS-Einschüben aufgerufen. Im Falle eines SSR-Fehlers oder eines Alarms (mit denen hier nicht zu rechnen ist) würde das Programm bei der Marke <code>CIAO</code> fortgesetzt, also ohne Weiteres beendet werden.

SSR-Befehle erwarten die Adresse eines Versorgungsblocks im Register BB. Die Art der gewünschten Systemleistung wird durch die beiden Adressteile des SSR-Befehls bestimmt, die Einzelheiten durch den Inhalt des Versorgungsblocks.<ref name="SSR">{{Literatur |Titel=Systemdienste |TitelErg=Änderungsstand&nbsp;9 |Verlag=[[Computer Gesellschaft Konstanz|CGK]] |Ort=Konstanz |Datum=1975-01 |Seiten=4 |Online=[http://www.tr440.info/doku/Systemdienste.pdf#page=9 Scan] |Format=PDF |KBytes=5961 |Abruf=2020-09-08}}</ref>

Alle Variablen, Konstanten und Befehls-Adressen werden mit PS&#x2011;440-Sprachmitteln deklariert; die deklarierten Namen können in TAS-Einschüben verwendet werden (hier: <code>VIA</code>, <code>CIAO</code> und <code>INDIZES</code>).

Die Äquivalenz-Vereinbarung in Zeile 13 erklärt <code>VB012</code> als Alias für das erste Ganzwort aus <code>VB616</code>. Eine Spezifikation <code>LABEL CIAO</code> ist unnötig, da <code>CIAO</code> nur in einem TAS-Einschub und in einer konstanten Referenz verwendet wird; da genügt es, dass die Marke <code>CIAO</code> irgendwo im Segment gesetzt ist.

=== Unterprogramm für Fortran-Programm ===

Das folgende Unterprogramm kann aus einem Fortran-Programm mit der Anweisung <code>CALL JETZT (JAHR, MONAT, TAG, STUNDE, MINUTE, SEKUNDE)</code> aufgerufen werden.<ref group="A"><code>JETZT</code> kann auch aus einem Algol&#x2011;60-Programm aufgerufen werden, wenn es dort als externe Fortran-Prozedur deklariert ist (Algol-Spracherweiterung). Der Algol-Typ <code>'''integer'''</code> entspricht dem Fortran-Typ <code>INTEGER*4</code>.</ref> Als aktuelle Parameter sind 1 bis 6 <code>INTEGER</code>-Variable (oder Feldelemente) anzugeben, in die <code>JETZT</code> das aktuelle Datum samt Uhrzeit einträgt. Überzählige Parameter werden ignoriert. Das Unterprogramm lässt <code>INTEGER*2</code>- und <code>INTEGER*4</code>-Parameter zu und veranlasst bei falscher Versorgung den Abbruch des Programmlaufs mit einer Fehlermeldung.
 SEGMENT PROCSFB JETZT
 IS BEGIN */STRUKT (1, KB)/*   CO Daten für den Rückverfolger;
 ; [0:3]FULL KB                CO Kontrollblock;
   PRESET ( SHORT '2H 0'       CO Platz für Rückkehr-Adresse;
          , SHORT 1            CO Code-Prozedur;
          , SHORT '2H 81 0A0A' CO Fortran-Anschluss;
          , REF TE             CO Meldungstext im Fehlerfall;
          )
 ; SHORT RADR  = KB[0]         CO Rückkehr-Adresse;
       , FTADR = KB[3]         CO Fehlertext-Adresse;
 ; SHORT KBADR IS REF KB
 ; FULL  [[TR 440#Zeichencodierung|TE]]    IS "*037"       CO kein Text (nur Text-Ende);
 ; RADR        := BB           CO Rückkehradresse retten;
 &nbsp;
 ; INDEX PADR  := RA           CO Adresse der Parameterversorgung retten;
 ; FULL PARAMETER = FVAL PADR
 ; SHORT FADR     = HW                 OF PARAMETER[0] CO Fehleradresse;
 ; LABEL FEHLER   = SVAL FADR                          CO Fehlerroutine;
 ; PART SPRACHE   = '3H FFFFFF 0FFFFF' OF PARAMETER[0] CO Sprachschlüssel;
      , AUFRUF    = '3H FFFFFF FFFCFF' OF PARAMETER[0] CO Aufrufart;
      , PARZAHL   = '3H FFFFFF FFFF00' OF PARAMETER[0] CO Anzahl Parameter;
 ; IF  SPRACHE ≠ 1 THEN FTADR := REF "JETZT muss als FORTRAN-Unterprogramm aufgerufen werden*037"
   ELSF AUFRUF = 2 THEN FTADR := REF "JETZT muss mit CALL aufgerufen werden*037"
   FI
 ; IF FTADR ≠ REF TE THEN RH := REF KBADR; GOTO FEHLER FI
 &nbsp;
 ; SPEC S&SRF LABEL S&SRF  CO Unterprogramm zur Behandlung von SSR-Fehlern;
 ; [0:1]FULL VB432         CO Versorgungsblock für SSR 4 32;
   IS (REF S&SRF, SHORT 1) CO Ergebnis in 12 Dezimalziffern zu je 4 Bit mit TK=3 gewünscht;
 ; BB := REF VB432; */SSR 4 32/*; FULL UHR := RA CO Datum und Uhrzeit holen;
 &nbsp;
 ; INDEX P, PMAX, TYP, FBX
 ; FULL  PP = PARAMETER[P][P]
 ; SHORT HV = HW OF PP[0]              CO Zugriff auf den aktuellen Parameter;
 ; PART SCHL= '3H FFFFFF 3FFFFF' OF PP CO Beschreibung des aktuellen Parameters;
      , ART = '3H FFFFFF 3FFF00' OF PP CO Beschreibung &amp; Art des aktuellen Parameters;
      , VTYP= '3H FFFFFF C000FF' OF PP CO Typ des aktuellen Parameters;
      , FBA = '3H FFFFFF C00000' OF PP CO gegebenenfalls Adresse der Feldbeschreibung;
 ; FULL FB  = FVAL FBX                 CO gegebenenfalls Feldbeschreibung;
 ; PART FTYP= '3H FFFFFF FF00FF' OF FB CO Typ aus Feldbeschreibung;
 ; IF PARZAHL > 6 THEN PMAX := 6 ELSE PMAX := PARZAHL FI
 ; FOR P FROM 1 TO PMAX
   DO BEGIN
     IF   SCHL = 2 THEN FBX := FBA; TYP := FTYP CO Feld-Element;
     ELSF ART  = 2 THEN             TYP := VTYP CO einfache Variable;
     ELSE FTADR := REF "Parameter muss Variable oder Feld-Element sein*037"
     FI
   ; RAQ := (RAQ := UHR) LEFT 8; SHORT WERT := RA; UHR := RQ       CO nächsten Teilwert isolieren;
   ; FULL IWERT := 10 * TK1 (WERT RIGHT 4) + TK1 (WERT ET '3HF')   CO Teilwert nach INTEGER wandeln;
   ; IF P = 1
     THEN IF IWERT > 69 THEN IWERT +:= 1900 ELSE IWERT +:= 2000 FI CO Jahr vierstellig;
     FI
   ; IF FTADR ≠ REF TE THEN CO inkompatibler Aktualparameter, nix tun;
     ELSF TYP = 1      THEN EXEC HV; SVAL BB := IWERT
     ELSF TYP = 2      THEN EXEC HV; FVAL BB := IWERT
     ELSE FTADR := REF "Parameter muss INTEGER*2 oder INTEGER*4 sein*037"
     FI
   ; IF FTADR ≠ REF TE THEN RH := REF KBADR; GOTO FEHLER FI
   END P
 &nbsp;
 ; BB := RADR
 END JETZT
 &nbsp;
 FINIS

Der Vorteil von PS&nbsp;440 gegenüber TAS: Man übersetzt die Struktur der diversen Versorgungs- und Kontrollblöcke aus der Dokumentation<ref name="FTN-TAS">{{Literatur |Titel=TR&nbsp;440 – TAS-Handbuch – Telefunken-Assemblersprache |Datum= |Seiten=D8&#x2011;1–D8&#x2011;8 |Online=[http://www.tr440.info/doku/Assemblersprache.pdf#page=146 Scan]}}</ref> als Äquivalenz-Deklarationen ins PS&#x2011;440-Programm und muss sich dann beim Zugriff auf die so deklarierten Größen keine Gedanken um indirekte Adressierung, Indizierung und Teilwort-Zugriffe machen, da das alles der Compiler berücksichtigt. Entscheidend dabei ist, dass sich die Äquivalenzen auf veränderliche Adressen beziehen können, die erst zur Laufzeit des Programms ausgewertet werden.

Da das Unterprogramm mehrfach vom selben Programm aufgerufen werden kann, sind Vorbelegungen mit <code>PRESET</code> nur soweit verlässlich, wie sie durch das Unterprogramm selbst nicht verändert werden. Andernfalls muss es den Variablen ihren Anfangswert dynamisch zuweisen – ausgenommen <code>FTADR</code>, das nur für eine Fehlermeldung verändert wird, von der es keine Rückkehr ins rufende Programm gibt.

Das Unterprogramm <code>JETZT</code> wird gemäß Programmiersystem-Konvention mit dem SFB-Befehl<ref name="SFB" /> aufgerufen, der die Rückkehradresse ins BB-Register bringt; der PS&#x2011;440-Compiler erwartet, dass beim Verlassen der Prozedur die Rückkehradresse wieder in <code>BB</code> steht. Also muss am Anfang <code>BB</code> gerettet und am Ende wiederhergestellt werden. Der STRUKT-Pseudobefehl ist ein Hinweis für die [[TR 440#Testhilfen|Rückverfolgung]]; aufgrund dieser Angabe erwartet der Rückverfolger im Alarm- oder Fehlerfall die Rückkehradresse im Kontrollblock. Der sonstige Inhalt des Kontrollblocks wird von dem Fehler-Unterprogramm ausgewertet, dessen Adresse im Parameterblock übergeben wurde; diesem Unterprogramm muss im RH-Register die Adresse eines Halbworts, das rechtsbündig die Adresse des Kontrollblocks enthält, übergeben werden.

Beim Aufruf eines Unterprogramms aus höheren Programmiersprachen steht die Adresse des Parameter-Blocks im RA-Register; diese muss als Nächstes gerettet werden. Der Parameter-Block besteht aus einem Kopfwort mit allgemeinen Angaben, gefolgt von je zwei Halbwörtern (Haupt- und Zusatzversorgung) pro Parameter. Die Zusatzversorgung beschreibt Typ und Art des jeweiligen Parameters und damit auch implizit die Wirkung der Hauptversorgung; im Falle eines Feldelements oder einer einfachen Variablen ist die Hauptversorgung ein Befehl, der dessen bzw. deren Adresse ins BB-Register bringt.

Ein Unterprogramm, das aus höheren Programmiersprachen aufgerufen wird, kann die Indizes 0 bis 7 für eigene Zwecke benutzen, sofern es nicht seinerseits andere Unterprogramme aufruft, die diese Indizes verändern. <code>JETZT</code> benutzt insgesamt fünf dieser acht Indizes.

== Literatur ==

* {{Literatur
   |Autor=Gerhard Goos, Klaus Lagally, Gerd Sapper, Helgrit Wich
   |Titel=PS&nbsp;440
   |Sammelwerk=System TR&nbsp;440
   |Nummer=N31.ZZ.10
   |Verlag=Telefunken Computer GmbH
   |Ort=Konstanz
   |Datum=1972-05
   |Online=[http://www.tr440.info/doku/PS440_1972-05.pdf Scan]
   |Format=PDF
   |KBytes=12862
   |Abruf=2020-08-06}}
* {{Literatur
   |Autor=Gerd Sapper
   |Hrsg=[[Hans Langmaack (Informatiker)|Hans Langmaack]] u. [[Manfred Paul (Informatiker)|Manfred Paul]]
   |Titel=The Programming Language PS440 as a Tool for Implementing a Time-Sharing-System
   |Sammelwerk=1.&nbsp;Fachtagung über Programmiersprachen
   |Reihe=Lecture notes in economics and mathematical systems
   |NummerReihe=75
   |Verlag=[[Springer Science+Business Media|Springer Verlag]]
   |Ort=Berlin · Heidelberg · New&nbsp;York
   |Datum=1972
   |ISBN=3-540-06051-0
   |Seiten=43–49
   |Sprache=en}}
* {{Literatur
   |Autor=Gerd R. Sapper
   |Titel=Maschinenorientierte Sprachen
   |Reihe=Handbuch der Informatik
   |BandReihe=3.1
   |HrsgReihe=[[Albert Endres]], [[Hermann Krallmann]], [[Peter Schnupp]]
   |Verlag=[[R. Oldenbourg Verlag]]
   |Ort=München, Wien
   |Datum=1989
   |ISBN=3-486-20662-1}}

== Anmerkungen ==
<references group="A" />

== Einzelnachweise ==
<references />

[[Kategorie:Imperative Programmiersprache]]
[[Kategorie:Historische Software]]