Programmiersprache Pascal

Programmeinheiten

Ein Programm ist eine auf einem (geeignet konfigurierten) Rechner separat lauffähige Einheit zur Eingabe, Manipulation und Ausgabe von Daten.

Ein Programm entsteht meist aus einer Reihe von Komponenten.
Zu unterscheiden sind verschiedene Arten von Komponenten:

Programmeinheit
syntaktische Sprachkonstruktion - Menge von Anweisungen, die der Lösung einer bestimmten Aufgabe dienen
meist werden die Quelltexte mehrerer Programmeinheiten in einer Datei gespeichert
nur einige Programmeinheiten sind separat übersetzbar
Übersetzungseinheit
Datei, die eine Menge von Anweisungen enthält, die separat übersetzbar sind
beinhaltet mindestens eine, meist jedoch mehrere Programmeinheiten
Einfügeeinheit
Datei (include file), die eine Menge von Anweisungen enthält, die nicht separat übersetzbar sein müssen (und es meist auch nicht sind)
Einfügeeinheiten werden mit Hilfe eines Preprozessors vor der Übersetzung in eine Übersetzungseinheit eingefügt.
Die eingefügten Anweisungen sind meist Deklarationen, die in verschiedenen Programmeinheiten benötigt werden und deren Identität in all diesen Programmeinheiten gesichert werden muß.

Ziele der Aufgliederung in Programmeinheiten sind vor allem:

Verbesserung der Programmverständlichkeit
Effektiveres Entwickeln und Testen in kleine(re)n Einheiten
Einfachere Wartbarkeit
Mehrfachverwendung von Programmcode

Programmeinheiten können mehr oder weniger unabhängig voneinander entwickelt werden.
Nichttriviale Programme setzen sich typischerweise aus verschiedenen Programmeinheiten zusammen.

Folgende Programmeinheiten können unterschieden werden:

Hauptprogramm (main program)
kann mit Mitteln des Betriebssystems direkt aktiviert werden
bisher üblicherweise zentrale Programmeinheit in allen Programmen - Ausnahme z.B. Oberon
das Hauptprogramm ist immer als separate Übersetzungseinheit zulässig
Standard Pascal: es ist die einzig mögliche Übersetzungseinheit
Unterprogramme (subprograms, routines)
nicht direkt mit den Mitteln des Betriebssystems aktivierbar
unterschieden werden meist zwei Formen von Unterprogrammen: Prozeduren und Funktionen
In einigen Sprachen werden Funktionen syntaktisch als Spezialfall der Prozedur realisiert, es wird dann von regulären Prozeduren bzw. Funktionsprozeduren gesprochen.
Unterprogramme sind in einigen Sprachen separat übersetzbar (z.B. FORTRAN, C), in anderen müssen sie Bestandteil einer anderen Programmeinheit sein.
In Standard Pascal müssen Unterprogramme vom Hauptprogramm eingeschlossen werden. In neueren Pascal-Versionen sowie in Sprachen wie Modula, Oberon oder Ada können Unterprogramme als Bestandteil von Moduln unabhängig von einem Hauptprogramm übersetzt werden.
Module (modules, packages)
fassen Deklarationsanweisungen zu einer nachnutzbaren Einheit zusammen, dies schließt insbesondere Unterprogramme ein
Module sind nicht in allen Sprachen erlaubt - dies gilt auch für Standard Pascal
Module existieren unter anderem in Modula und Oberon (module), Ada (package), Turbo Pascal (unit), XL Pascal (segment), Extended Pascal (module), ältere Sprach(version)en sehen sie nicht vor.
Ein Modul ist typischerweise eine separate Übersetzungseinheit.
Module exportieren Ressourcen wie Unterprogramme, Datentypen, Konstanten und eventuell auch Variablen.

Programmeinheiten besitzen im allgemeinen folgenden Aufbau:

                                       sprach(versions)abhängig in
+----------------------------------+
| programmeinheit name (parameter) |
+----------------------------------+
| Interface                        |
|   importierte Ressourcen         |     Hauptprogramm, Modul
|   exportierte Ressourcen         |     Modul
+----------------------------------+
| lokale Deklarationen             |
+-- -- -- -- -- -- -- -- -- -- -- -+
| Implementation                   |     Modul
|   der exportierten Ressourcen    |
+-- -- -- -- -- -- -- -- -- -- -- -+
| ausführbare Anweisungen          |     Hauptprogramm, Unterprogramm  
+-- -- -- -- -- -- -- -- -- -- -- -+     Modul: Initialisierungsteil
| END ...                          |
+----------------------------------+

Bezugnahme auf Programmeinheiten:

Hauptprogramm
Aufruf nur unter Nutzung von Diensten des Betriebssystems möglich
viele, aber nicht alle Sprach(version)en verfügen über Unterprogramme, mit deren Hilfe Dienste des Betriebssystems aufrufbar sind (z.B. nicht in Standard Pascal, aber z.B. in Turbo Pascal)
Unterprogramme
Aufrufe durch das Hauptprogramm, den Initialisierungsteil eines Moduls oder durch andere Unterprogramme möglich
kein direkter Aufruf über das Betriebssystem
Module
keine Aufrufe
nur Import von Ressourcen des Moduls
im allgemeinen ist ein expliziter Verweis auf den Modul erforderlich, durch den das Laden des Moduls veranlaßt wird
das Laden des Moduls bewirkt die Ausführung des Initialisierungsteils

Bezugnahme auf Übersetzungseinheiten:
Derartige Bezugnahmen sind nur möglich, wenn die Übersetzungseinheit identisch mit einer Programmeinheit ist.

Die Möglichkeit der separaten Übersetzung ist äußerst wichtig für die Realisierung größerer Software-Projekte.

Bezugnahme auf Einfügeeinheiten:
Die Bezugnahme erfolgt in vielen Sprach(version)en über INCLUDE-Anweisungen.
Mitunter sind derartige Anweisungen Bestandteil der Programmiersprache, in anderen Fällen stellt das Programmiersystem entsprechende Erweiterungen bereit. Standard Pascal zum Beispiel sieht keine solchen Einheiten vor, viele Pascal-Systeme besitzen sie jedoch.

Die Wirkung einer INCLUDE-Anweisung ist folgende:
In einem Vorverarbeitungsschritt wird die INCLUDE-Anweisung durch den Inhalt der Datei ersetzt, auf welche die Anweisung verweist.
Durch Lage der INCLUDE-Anweisung und Inhalt der INCLUDE-Datei muß gesichert werden, daß im Ergebnis der Vorverarbeitung syntaktisch korrekter Quelltext entsteht.
Die Vorverarbeitung kann während des Einlesens des Quelltextes oder explizit durch einen Preprozessor erfolgen.

P. Böhme, 07.09.1996